fbintf/client/FBBlob.pas

(*
 *  Firebird Interface (fbintf). The fbintf components provide a set of
 *  Pascal language bindings for the Firebird API. Although predominantly
 *  a new development they include source code taken from IBX and may be
 *  considered a derived product. This software thus also includes the copyright
 *  notice and license conditions from IBX.
 *
 *  Except for those parts dervied from IBX, contents of this file are subject
 *  to the Initial Developer's Public License Version 1.0 (the "License"); you
 *  may not use this file except in compliance with the License. You may obtain a
 *  copy of the License here:
 *
 *    http://www.firebirdsql.org/index.php?op=doc&id=idpl
 *
 *  Software distributed under the License is distributed on an "AS
 *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 *  implied. See the License for the specific language governing rights
 *  and limitations under the License.
 *
 *  The Initial Developer of the Original Code is Tony Whyman.
 *
 *  The Original Code is (C) 2016 Tony Whyman, MWA Software
 *  (http://www.mwasoftware.co.uk).
 *
 *  All Rights Reserved.
 *
 *  Contributor(s): ______________________________________.
 *
*)
unit FBBlob;

{$IFDEF FPC}
{$mode objfpc}{$H+}
{$interfaces COM}
{$ENDIF}

interface

uses
  Classes, SysUtils, IB, FBActivityMonitor, FBTransaction, FBClientAPI;

type

  { TFBBlobMetaData }

  TFBBlobMetaData  = class(TActivityReporter)
  private
    FRelationName: string;
    FColumnName: string;
  protected
    FUnconfirmedCharacterSet: boolean;
    FHasSubType: boolean;
    FSubType: integer;
    FCharSetID: cardinal;
    FSegmentSize: cardinal;
    procedure NeedFullMetadata; virtual; abstract;
    procedure NeedSubType;
  public
    constructor Create(Transaction: TFBTransaction; RelationName, ColumnName: string
      );
    procedure SetCharSetID(aValue: integer);

  public
    {IBlobMetaData}
   function GetSubType: integer;
   function GetCharSetID: cardinal;
   function GetCodePage: TSystemCodePage;
   function GetSegmentSize: cardinal;
   function GetRelationName: string;
   function GetColumnName: string;
   function GetUnconfirmedCharacterSet: boolean;
  end;

  TFBBlob = class(TActivityReporter)
  private
    FMetaData: IBlobMetaData;
    FAttachment: IAttachment;
    FTransaction: ITransaction;
    FBPB: IBPB;
    FStringData: rawbytestring;
    FStringCached: boolean;
  protected
    FCreating: boolean;
    FBlobID: TISC_QUAD;
    procedure CheckReadable; virtual; abstract;
    procedure CheckWritable; virtual; abstract;
    procedure ClearStringCache;
    function GetIntf: IBlob; virtual; abstract;
    procedure InternalClose(Force: boolean); virtual; abstract;
    procedure InternalCancel(Force: boolean); virtual; abstract;
  public
    constructor Create(Attachment: IAttachment; Transaction: TFBTransaction;
                       MetaData: IBlobMetaData; BPB: IBPB); overload;
    constructor Create(Attachment: IAttachment; Transaction: TFBTransaction;
                       MetaData: IBlobMetaData; BlobID: TISC_QUAD; BPB: IBPB); overload;
    destructor Destroy; override;
    procedure TransactionEnding(aTransaction: TFBTransaction; Force: boolean);

  public
    {IBlobMetaData}
   function GetSubType: integer;
   function GetCharSetID: cardinal;
   function GetCodePage: TSystemCodePage;
   function GetSegmentSize: cardinal;
   function GetRelationName: string;
   function GetColumnName: string;
   function GetUnconfirmedCharacterSet: boolean;

   {IBlob}
    function GetBPB: IBPB;
    procedure Cancel;
    procedure Close;
    function GetBlobSize: Int64;
    procedure GetInfo(var NumSegments: Int64; var MaxSegmentSize, TotalSize: Int64;
      var BlobType: TBlobType); virtual; abstract;
    function GetBlobID: TISC_QUAD;
    function GetBlobMode: TFBBlobMode;
    function Read(var Buffer; Count: Longint): Longint; virtual; abstract;
    function Write(const Buffer; Count: Longint): Longint;  virtual; abstract;
    function LoadFromFile(Filename: string): IBlob;
    function LoadFromStream(S: TStream) : IBlob;
    function SaveToFile(Filename: string): IBlob;
    function SaveToStream(S: TStream): IBlob;
    function GetAttachment: IAttachment;
    function GetTransaction: ITransaction;
    function GetAsString: rawbytestring;
    procedure SetAsString(aValue: rawbytestring);
    function SetString(aValue: rawbytestring): IBlob;
  end;


implementation

uses FBMessages;

{ TFBBlob }

procedure TFBBlob.ClearStringCache;
begin
  FStringData := '';
  FStringCached := false;
end;

constructor TFBBlob.Create(Attachment: IAttachment;
  Transaction: TFBTransaction; MetaData: IBlobMetaData; BPB: IBPB);
begin
  inherited Create(Transaction);
  FAttachment := Attachment;
  FTransaction := Transaction;
  FMetaData := MetaData;
  FBPB := BPB;
  FCreating := true;
end;

constructor TFBBlob.Create(Attachment: IAttachment;
  Transaction: TFBTransaction; MetaData: IBlobMetaData; BlobID: TISC_QUAD; BPB: IBPB);
begin
  Create(Attachment,Transaction,MetaData,BPB);
  FBlobID := BlobID;
  FCreating := false;
end;

destructor TFBBlob.Destroy;
begin
  if FCreating then
    Cancel
  else
    Close;
  inherited Destroy;
end;

procedure TFBBlob.TransactionEnding(aTransaction: TFBTransaction;
  Force: boolean);
begin
  if aTransaction <> FTransaction then
    Exit;
  if FCreating then
    InternalCancel(Force)
  else
    InternalClose(Force);
end;

function TFBBlob.GetSubType: integer;
begin
  Result := FMetaData.GetSubType;
end;

function TFBBlob.GetCharSetID: cardinal;
begin
  Result := FMetaData.GetCharSetID;
end;

function TFBBlob.GetCodePage: TSystemCodePage;
begin
  Result := FMetaData.GetCodePage;
end;

function TFBBlob.GetSegmentSize: cardinal;
begin
  Result := FMetaData.GetSegmentSize;
end;

function TFBBlob.GetRelationName: string;
begin
  Result := FMetaData.GetRelationName;
end;

function TFBBlob.GetColumnName: string;
begin
  Result := FMetaData.GetColumnName;
end;

function TFBBlob.GetUnconfirmedCharacterSet: boolean;
begin
  Result := (FMetadata as TFBBlobMetadata).GetUnconfirmedCharacterSet;
end;

function TFBBlob.GetBPB: IBPB;
begin
  Result := FBPB;
end;

procedure TFBBlob.Cancel;
begin
  InternalCancel(false);
end;

procedure TFBBlob.Close;
begin
  InternalClose(false);
end;

function TFBBlob.GetBlobSize: Int64;
var NumSegments: Int64;
    MaxSegmentSize: Int64;
    BlobType: TBlobType;
begin
  GetInfo(NumSegments,MaxSegmentSize,Result,BlobType);
end;

function TFBBlob.GetBlobID: TISC_QUAD;
begin
  Result := FBlobID;
end;

function TFBBlob.GetBlobMode: TFBBlobMode;
begin
  if FCreating then
    Result := fbmWrite
  else
    Result := fbmRead;
end;

function TFBBlob.LoadFromFile(Filename: string): IBlob;
var
  Stream: TStream;
begin
  Stream := TFileStream.Create(FileName, fmOpenRead);
  try
    Result := LoadFromStream(Stream);
  finally
    Stream.Free;
  end;
end;

const BufSize = 8 * 1024;

function TFBBlob.LoadFromStream(S: TStream): IBlob;
var Buffer: array [0..BufSize-1] of char;
    BytesRead: integer;
begin
  CheckWritable;
  S.Position := 0;
  repeat
    BytesRead := S.Read(Buffer,BufSize);
    Write(Buffer,BytesRead);
  until BytesRead = 0;
  Close;
  Result := GetIntf;
end;

function TFBBlob.SaveToFile(Filename: string): IBlob;
var
  Stream: TStream;
begin
  Stream := TFileStream.Create(FileName, fmCreate);
  try
    Result := SaveToStream(Stream);
  finally
    Stream.Free;
  end;
end;

function TFBBlob.SaveToStream(S: TStream): IBlob;
var Buffer: array [0..BufSize-1] of char;
    BytesRead: integer;
begin
  CheckReadable;
  repeat
    BytesRead := Read(Buffer,BufSize);
    S.Write(Buffer,BytesRead);
  until BytesRead = 0;
  Close;
  Result := GetIntf;
end;

function TFBBlob.GetAttachment: IAttachment;
begin
  Result := FAttachment;
end;

function TFBBlob.GetTransaction: ITransaction;
begin
   Result := FTransaction;
end;

function TFBBlob.GetAsString: rawbytestring;
var ss: TStringStream;
begin
  if FStringCached then
  begin
    Result := FStringData;
    Exit;
  end;

  ss := TStringStream.Create('');
  try
    SaveToStream(ss);
    Result :=  ss.DataString;
    if (GetSubType = 1) and (FBPB = nil) then
      SetCodePage(Result,GetCodePage,false);
  finally
    ss.Free;
  end;
  FStringData := Result;
  FStringCached := true;
end;

procedure TFBBlob.SetAsString(aValue: rawbytestring);
var
  ss: TStringStream;
begin
  {if GetUnconfirmedCharacterSet then
    IBError(ibxeNoDefaultCharacterSet,[nil]);}

  if (GetSubType = 1) and  (StringCodePage(aValue) <> GetCodePage) and
           (GetCodePage <> CP_NONE) and (FBPB = nil) then
    SetCodePage(aValue,GetCodePage,true);
  ss := TStringStream.Create(aValue);
  try
    LoadFromStream(ss);
  finally
    ss.Free;
  end;
  FStringData := aValue;
  FStringCached := true;
end;

function TFBBlob.SetString(aValue: rawbytestring): IBlob;
begin
  SetAsString(aValue);
  Result := GetIntf;
end;

{TFBBlobMetaData}

procedure TFBBlobMetaData.NeedSubType;
begin
  if not FHasSubType then
  begin
    NeedFullMetadata;
    FHasSubType := true;
  end;
end;

constructor TFBBlobMetaData.Create(Transaction: TFBTransaction; RelationName,
  ColumnName: string);
begin
  inherited Create(Transaction);
//  if (RelationName = '') or (ColumnName = '') then
 //   IBError(ibxeMissingColumnName,[]);
  FRelationName := RelationName;
  FColumnName := ColumnName;
  FSegmentSize := 80;
  FUnconfirmedCharacterSet := true;
  FCharSetID := 0;
end;

procedure TFBBlobMetaData.SetCharSetID(aValue: integer);
begin
  FCharSetID := aValue;
  FUnconfirmedCharacterSet := false;
end;

function TFBBlobMetaData.GetSubType: integer;
begin
  NeedSubType;
  Result := FSubType;
end;

function TFBBlobMetaData.GetCharSetID: cardinal;
begin
  NeedFullMetadata;
  Result := FCharSetID;
end;

function TFBBlobMetaData.GetCodePage: TSystemCodePage;
begin
  FirebirdClientAPI.CharSetID2CodePage(GetCharSetID,Result);
end;

function TFBBlobMetaData.GetSegmentSize: cardinal;
begin
  NeedFullMetadata;
  Result := FSegmentSize;
end;

function TFBBlobMetaData.GetRelationName: string;
begin
  Result := FRelationName;
end;

function TFBBlobMetaData.GetColumnName: string;
begin
  Result := FColumnName;
end;

function TFBBlobMetaData.GetUnconfirmedCharacterSet: boolean;
begin
  NeedFullMetadata;
  Result := FUnconfirmedCharacterSet;
end;


end.

Revision:	47
Committed:	Mon Jan 9 15:31:51 2017 UTC (7 years, 3 months ago) by tony
Content type:	text/x-pascal
File size:	10311 byte(s)
Log Message:	Committing updates for Release R2-0-1
#	User	Rev	Content
1	tony	45	(*
2			* Firebird Interface (fbintf). The fbintf components provide a set of
3			* Pascal language bindings for the Firebird API. Although predominantly
4			* a new development they include source code taken from IBX and may be
5			* considered a derived product. This software thus also includes the copyright
6			* notice and license conditions from IBX.
7			*
8			* Except for those parts dervied from IBX, contents of this file are subject
9			* to the Initial Developer's Public License Version 1.0 (the "License"); you
10			* may not use this file except in compliance with the License. You may obtain a
11			* copy of the License here:
12			*
13			* http://www.firebirdsql.org/index.php?op=doc&id=idpl
14			*
15			* Software distributed under the License is distributed on an "AS
16			* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
17			* implied. See the License for the specific language governing rights
18			* and limitations under the License.
19			*
20			* The Initial Developer of the Original Code is Tony Whyman.
21			*
22			* The Original Code is (C) 2016 Tony Whyman, MWA Software
23			* (http://www.mwasoftware.co.uk).
24			*
25			* All Rights Reserved.
26			*
27			* Contributor(s): ______________________________________.
28			*
29			*)
30			unit FBBlob;
31
32			{$IFDEF FPC}
33			{$mode objfpc}{$H+}
34			{$interfaces COM}
35			{$ENDIF}
36
37			interface
38
39			uses
40			Classes, SysUtils, IB, FBActivityMonitor, FBTransaction, FBClientAPI;
41
42			type
43
44			{ TFBBlobMetaData }
45
46			TFBBlobMetaData = class(TActivityReporter)
47			private
48			FRelationName: string;
49			FColumnName: string;
50			protected
51			FUnconfirmedCharacterSet: boolean;
52			FHasSubType: boolean;
53			FSubType: integer;
54			FCharSetID: cardinal;
55			FSegmentSize: cardinal;
56			procedure NeedFullMetadata; virtual; abstract;
57			procedure NeedSubType;
58			public
59			constructor Create(Transaction: TFBTransaction; RelationName, ColumnName: string
60			);
61	tony	47	procedure SetCharSetID(aValue: integer);
62	tony	45
63			public
64			{IBlobMetaData}
65			function GetSubType: integer;
66			function GetCharSetID: cardinal;
67			function GetCodePage: TSystemCodePage;
68			function GetSegmentSize: cardinal;
69			function GetRelationName: string;
70			function GetColumnName: string;
71			function GetUnconfirmedCharacterSet: boolean;
72			end;
73
74			TFBBlob = class(TActivityReporter)
75			private
76			FMetaData: IBlobMetaData;
77			FAttachment: IAttachment;
78			FTransaction: ITransaction;
79			FBPB: IBPB;
80			FStringData: rawbytestring;
81			FStringCached: boolean;
82			protected
83			FCreating: boolean;
84			FBlobID: TISC_QUAD;
85			procedure CheckReadable; virtual; abstract;
86			procedure CheckWritable; virtual; abstract;
87			procedure ClearStringCache;
88			function GetIntf: IBlob; virtual; abstract;
89			procedure InternalClose(Force: boolean); virtual; abstract;
90			procedure InternalCancel(Force: boolean); virtual; abstract;
91			public
92			constructor Create(Attachment: IAttachment; Transaction: TFBTransaction;
93			MetaData: IBlobMetaData; BPB: IBPB); overload;
94			constructor Create(Attachment: IAttachment; Transaction: TFBTransaction;
95			MetaData: IBlobMetaData; BlobID: TISC_QUAD; BPB: IBPB); overload;
96			destructor Destroy; override;
97			procedure TransactionEnding(aTransaction: TFBTransaction; Force: boolean);
98
99			public
100			{IBlobMetaData}
101			function GetSubType: integer;
102			function GetCharSetID: cardinal;
103			function GetCodePage: TSystemCodePage;
104			function GetSegmentSize: cardinal;
105			function GetRelationName: string;
106			function GetColumnName: string;
107			function GetUnconfirmedCharacterSet: boolean;
108
109			{IBlob}
110			function GetBPB: IBPB;
111			procedure Cancel;
112			procedure Close;
113			function GetBlobSize: Int64;
114			procedure GetInfo(var NumSegments: Int64; var MaxSegmentSize, TotalSize: Int64;
115			var BlobType: TBlobType); virtual; abstract;
116			function GetBlobID: TISC_QUAD;
117			function GetBlobMode: TFBBlobMode;
118			function Read(var Buffer; Count: Longint): Longint; virtual; abstract;
119			function Write(const Buffer; Count: Longint): Longint; virtual; abstract;
120			function LoadFromFile(Filename: string): IBlob;
121			function LoadFromStream(S: TStream) : IBlob;
122			function SaveToFile(Filename: string): IBlob;
123			function SaveToStream(S: TStream): IBlob;
124			function GetAttachment: IAttachment;
125			function GetTransaction: ITransaction;
126			function GetAsString: rawbytestring;
127			procedure SetAsString(aValue: rawbytestring);
128			function SetString(aValue: rawbytestring): IBlob;
129			end;
130
131
132
133			implementation
134
135			uses FBMessages;
136
137			{ TFBBlob }
138
139			procedure TFBBlob.ClearStringCache;
140			begin
141			FStringData := '';
142			FStringCached := false;
143			end;
144
145			constructor TFBBlob.Create(Attachment: IAttachment;
146			Transaction: TFBTransaction; MetaData: IBlobMetaData; BPB: IBPB);
147			begin
148			inherited Create(Transaction);
149			FAttachment := Attachment;
150			FTransaction := Transaction;
151			FMetaData := MetaData;
152			FBPB := BPB;
153			FCreating := true;
154			end;
155
156			constructor TFBBlob.Create(Attachment: IAttachment;
157			Transaction: TFBTransaction; MetaData: IBlobMetaData; BlobID: TISC_QUAD; BPB: IBPB);
158			begin
159			Create(Attachment,Transaction,MetaData,BPB);
160			FBlobID := BlobID;
161			FCreating := false;
162			end;
163
164			destructor TFBBlob.Destroy;
165			begin
166			if FCreating then
167			Cancel
168			else
169			Close;
170			inherited Destroy;
171			end;
172
173			procedure TFBBlob.TransactionEnding(aTransaction: TFBTransaction;
174			Force: boolean);
175			begin
176			if aTransaction <> FTransaction then
177			Exit;
178			if FCreating then
179			InternalCancel(Force)
180			else
181			InternalClose(Force);
182			end;
183
184			function TFBBlob.GetSubType: integer;
185			begin
186			Result := FMetaData.GetSubType;
187			end;
188
189			function TFBBlob.GetCharSetID: cardinal;
190			begin
191			Result := FMetaData.GetCharSetID;
192			end;
193
194			function TFBBlob.GetCodePage: TSystemCodePage;
195			begin
196			Result := FMetaData.GetCodePage;
197			end;
198
199			function TFBBlob.GetSegmentSize: cardinal;
200			begin
201			Result := FMetaData.GetSegmentSize;
202			end;
203
204			function TFBBlob.GetRelationName: string;
205			begin
206			Result := FMetaData.GetRelationName;
207			end;
208
209			function TFBBlob.GetColumnName: string;
210			begin
211			Result := FMetaData.GetColumnName;
212			end;
213
214			function TFBBlob.GetUnconfirmedCharacterSet: boolean;
215			begin
216			Result := (FMetadata as TFBBlobMetadata).GetUnconfirmedCharacterSet;
217			end;
218
219			function TFBBlob.GetBPB: IBPB;
220			begin
221			Result := FBPB;
222			end;
223
224			procedure TFBBlob.Cancel;
225			begin
226			InternalCancel(false);
227			end;
228
229			procedure TFBBlob.Close;
230			begin
231			InternalClose(false);
232			end;
233
234			function TFBBlob.GetBlobSize: Int64;
235			var NumSegments: Int64;
236			MaxSegmentSize: Int64;
237			BlobType: TBlobType;
238			begin
239			GetInfo(NumSegments,MaxSegmentSize,Result,BlobType);
240			end;
241
242			function TFBBlob.GetBlobID: TISC_QUAD;
243			begin
244			Result := FBlobID;
245			end;
246
247			function TFBBlob.GetBlobMode: TFBBlobMode;
248			begin
249			if FCreating then
250			Result := fbmWrite
251			else
252			Result := fbmRead;
253			end;
254
255			function TFBBlob.LoadFromFile(Filename: string): IBlob;
256			var
257			Stream: TStream;
258			begin
259			Stream := TFileStream.Create(FileName, fmOpenRead);
260			try
261			Result := LoadFromStream(Stream);
262			finally
263			Stream.Free;
264			end;
265			end;
266
267			const BufSize = 8 * 1024;
268
269			function TFBBlob.LoadFromStream(S: TStream): IBlob;
270			var Buffer: array [0..BufSize-1] of char;
271			BytesRead: integer;
272			begin
273			CheckWritable;
274			S.Position := 0;
275			repeat
276			BytesRead := S.Read(Buffer,BufSize);
277			Write(Buffer,BytesRead);
278			until BytesRead = 0;
279			Close;
280			Result := GetIntf;
281			end;
282
283			function TFBBlob.SaveToFile(Filename: string): IBlob;
284			var
285			Stream: TStream;
286			begin
287			Stream := TFileStream.Create(FileName, fmCreate);
288			try
289			Result := SaveToStream(Stream);
290			finally
291			Stream.Free;
292			end;
293			end;
294
295			function TFBBlob.SaveToStream(S: TStream): IBlob;
296			var Buffer: array [0..BufSize-1] of char;
297			BytesRead: integer;
298			begin
299			CheckReadable;
300			repeat
301			BytesRead := Read(Buffer,BufSize);
302			S.Write(Buffer,BytesRead);
303			until BytesRead = 0;
304			Close;
305			Result := GetIntf;
306			end;
307
308			function TFBBlob.GetAttachment: IAttachment;
309			begin
310			Result := FAttachment;
311			end;
312
313			function TFBBlob.GetTransaction: ITransaction;
314			begin
315			Result := FTransaction;
316			end;
317
318			function TFBBlob.GetAsString: rawbytestring;
319			var ss: TStringStream;
320			begin
321			if FStringCached then
322			begin
323			Result := FStringData;
324			Exit;
325			end;
326
327			ss := TStringStream.Create('');
328			try
329			SaveToStream(ss);
330			Result := ss.DataString;
331			if (GetSubType = 1) and (FBPB = nil) then
332			SetCodePage(Result,GetCodePage,false);
333			finally
334			ss.Free;
335			end;
336			FStringData := Result;
337			FStringCached := true;
338			end;
339
340			procedure TFBBlob.SetAsString(aValue: rawbytestring);
341			var
342			ss: TStringStream;
343			begin
344			{if GetUnconfirmedCharacterSet then
345			IBError(ibxeNoDefaultCharacterSet,[nil]);}
346
347			if (GetSubType = 1) and (StringCodePage(aValue) <> GetCodePage) and
348			(GetCodePage <> CP_NONE) and (FBPB = nil) then
349			SetCodePage(aValue,GetCodePage,true);
350			ss := TStringStream.Create(aValue);
351			try
352			LoadFromStream(ss);
353			finally
354			ss.Free;
355			end;
356			FStringData := aValue;
357			FStringCached := true;
358			end;
359
360			function TFBBlob.SetString(aValue: rawbytestring): IBlob;
361			begin
362			SetAsString(aValue);
363			Result := GetIntf;
364			end;
365
366			{TFBBlobMetaData}
367
368			procedure TFBBlobMetaData.NeedSubType;
369			begin
370			if not FHasSubType then
371			begin
372			NeedFullMetadata;
373			FHasSubType := true;
374			end;
375			end;
376
377			constructor TFBBlobMetaData.Create(Transaction: TFBTransaction; RelationName,
378			ColumnName: string);
379			begin
380			inherited Create(Transaction);
381			// if (RelationName = '') or (ColumnName = '') then
382			// IBError(ibxeMissingColumnName,[]);
383			FRelationName := RelationName;
384			FColumnName := ColumnName;
385			FSegmentSize := 80;
386	tony	47	FUnconfirmedCharacterSet := true;
387			FCharSetID := 0;
388	tony	45	end;
389
390	tony	47	procedure TFBBlobMetaData.SetCharSetID(aValue: integer);
391			begin
392			FCharSetID := aValue;
393			FUnconfirmedCharacterSet := false;
394			end;
395
396	tony	45	function TFBBlobMetaData.GetSubType: integer;
397			begin
398			NeedSubType;
399			Result := FSubType;
400			end;
401
402			function TFBBlobMetaData.GetCharSetID: cardinal;
403			begin
404			NeedFullMetadata;
405			Result := FCharSetID;
406			end;
407
408			function TFBBlobMetaData.GetCodePage: TSystemCodePage;
409			begin
410			FirebirdClientAPI.CharSetID2CodePage(GetCharSetID,Result);
411			end;
412
413			function TFBBlobMetaData.GetSegmentSize: cardinal;
414			begin
415			NeedFullMetadata;
416			Result := FSegmentSize;
417			end;
418
419			function TFBBlobMetaData.GetRelationName: string;
420			begin
421			Result := FRelationName;
422			end;
423
424			function TFBBlobMetaData.GetColumnName: string;
425			begin
426			Result := FColumnName;
427			end;
428
429			function TFBBlobMetaData.GetUnconfirmedCharacterSet: boolean;
430			begin
431			NeedFullMetadata;
432			Result := FUnconfirmedCharacterSet;
433			end;
434
435
436			end.
437