runtime/nongui/IBBlob.pas

{************************************************************************}
{                                                                        }
{       Borland Delphi Visual Component Library                          }
{       InterBase Express core components                                }
{                                                                        }
{       Copyright (c) 1998-2000 Inprise Corporation                      }
{                                                                        }
{    InterBase Express is based in part on the product                   }
{    Free IB Components, written by Gregory H. Deatz for                 }
{    Hoagland, Longo, Moran, Dunst & Doukas Company.                     }
{    Free IB Components is used under license.                           }
{                                                                        }
{    The contents of this file are subject to the InterBase              }
{    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 at http://www.Inprise.com/IPL.html }
{    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 Original Code was created by InterBase Software Corporation     }
{       and its successors.                                              }
{    Portions created by Inprise Corporation are Copyright (C) Inprise   }
{       Corporation. All Rights Reserved.                                }
{    Contributor(s): Jeff Overcash                                       }
{                                                                        }
{    IBX For Lazarus (Firebird Express)                                  }
{    Contributor: Tony Whyman, MWA Software http://www.mwasoftware.co.uk }
{    Portions created by MWA Software are copyright McCallum Whyman      }
{    Associates Ltd 2011 - 2018                                               }
{************************************************************************}

unit IBBlob;

{$mode Delphi}

interface

uses
  SysUtils, Classes, DB, IB, IBDatabase;


const
  DefaultBlobSegmentSize = 16 * 1024;

type
  TIBBlobStates = (bsUninitialised, bsDataPending, bsData, bsModified);

  { TIBBlobStream }
  TIBBlobStream = class(TStream)
  private
    FBase: TIBBase;
    FBlob: IBlob;
    FBlobMaxSegmentSize: Int64;
    FBlobNumSegments: Int64;
    FBlobSize: Int64;
    FBlobType: TBlobType;
    FBuffer: PChar;
    FColumnName: string;
    FMode: TBlobStreamMode;
    FPosition: Int64;
    FBlobState: TIBBlobStates;
    FRelationName: string;
    function GetBlobID: TISC_QUAD;
    function GetModified: Boolean;
    procedure CheckActive;
  protected
    procedure CloseBlob;
    procedure EnsureBlobInitialized;
    procedure EnsureLoaded;
    procedure GetBlobInfo;
    function  GetSize: Int64; override;
    function GetDatabase: TIBDatabase;
    function GetTransaction: TIBTransaction;
    procedure OpenBlob;
    procedure SetBlobID(Value: TISC_QUAD);
    procedure SetDatabase(Value: TIBDatabase);
    procedure SetMode(Value: TBlobStreamMode);
    procedure SetState(aValue: TIBBlobStates);
    procedure SetTransaction(Value: TIBTransaction);
  public
    constructor Create;
    destructor Destroy; override;
    procedure CheckReadable;
    procedure CheckWritable;
    procedure Finalize;
    procedure LoadFromFile(Filename: string);
    procedure LoadFromStream(Stream: TStream);
    function Read(var Buffer; Count: Longint): Longint; override;
    procedure SaveToFile(Filename: string);
    procedure SaveToStream(Stream: TStream);
    function Seek(const Offset: Int64; Origin: TSeekOrigin): Int64; override;
    procedure SetField(aField: TField);
    procedure SetSize(const NewSize: Int64); override;
    procedure SetSize(NewSize: Longint); override;
    procedure Truncate;
    function Write(const Buffer; Count: Longint): Longint; override;
    property BlobID: TISC_QUAD read GetBlobID write SetBlobID;
    property Blob: IBlob read FBlob;
    property BlobMaxSegmentSize: Int64 read FBlobMaxSegmentSize;
    property BlobNumSegments: Int64 read FBlobNumSegments;
    property BlobSize: Int64 read GetSize;
    property BlobType: TBlobType read FBlobType;
    property Database: TIBDatabase read GetDatabase write SetDatabase;
    property Mode: TBlobStreamMode read FMode write SetMode;
    property Modified: Boolean read GetModified;
    property Transaction: TIBTransaction read GetTransaction write SetTransaction;
    property RelationName: string read FRelationName;
    property ColumnName: string read FColumnName;
  end;

implementation

uses IBMessages, IBCustomDataSet;

{ TIBBlobStream }
constructor TIBBlobStream.Create;
begin
  inherited Create;
  FBase := TIBBase.Create(Self);
  FBuffer := nil;
  FBlobSize := 0;
  FBlobState := bsUninitialised;
  FBlob := nil;
end;

destructor TIBBlobStream.Destroy;
begin
  CloseBlob;
  FBase.Free;
  SetSize(0);
  inherited Destroy;
end;

procedure TIBBlobStream.CheckReadable;
begin
  if FMode = bmWrite then IBError(ibxeBlobCannotBeRead, [nil]);
end;

procedure TIBBlobStream.CheckWritable;
begin
  if FMode = bmRead then IBError(ibxeBlobCannotBeWritten, [nil]);
end;

function TIBBlobStream.GetModified: Boolean;
begin
  Result := FBlobState = bsModified;
end;

procedure TIBBlobStream.CheckActive;
begin
  if Database = nil then
    IBError(ibxeDatabaseNotAssigned,[nil]);

  if (Database.Attachment = nil) or
                     not Database.Attachment.IsConnected then
    IBError(ibxeDatabaseClosed,[nil]);

  if Transaction = nil then
    IBError(ibxeTransactionNotAssigned,[nil]);

  if (Transaction.TransactionIntf = nil) or
      not Transaction.TransactionIntf.InTransaction then
    IBError(ibxeNotInTransaction,[nil]);
end;

function TIBBlobStream.GetBlobID: TISC_QUAD;
begin
  if (FBlob = nil) or (FBlobSize = 0) then
  begin
    Result.gds_quad_high := 0;
    Result.gds_quad_low := 0;
  end
  else
    Result := FBlob.GetBlobID;
end;

procedure TIBBlobStream.CloseBlob;
begin
  Finalize;
  FBlob := nil;
  SetState(bsUninitialised);
end;

procedure TIBBlobStream.EnsureBlobInitialized;
begin
  if FBlobState <> bsUninitialised then Exit;

  if FMode = bmWrite then
    SetState(bsData)
  else
  begin
    CheckReadable;
    if FBlob = nil then Exit;
    try
      GetBlobInfo;
      {Defer reading in blob until read method called}
    except
      FBlob := nil;
      raise;
    end;
    SetState(bsDataPending);
  end;
end;

procedure TIBBlobStream.EnsureLoaded;
begin
  EnsureBlobInitialized;
  if (FBlobState = bsDataPending) and (FBlob <> nil) then
  begin
    SetSize(FBlobSize);
    FBlob.Read(FBuffer^, FBlobSize);
    SetState(bsData);
  end;
end;

procedure TIBBlobStream.Finalize;
begin
  if FBlobState <> bsModified then
    exit;
  CheckWritable;
  if FBlobSize > 0 then
  begin
    { need to start writing to a blob, create one }
    FBlob := Database.Attachment.CreateBlob(Transaction.TransactionIntf,RelationName,ColumnName);
    FBlob.Write(FBuffer^, FBlobSize);
    FBlob.Close;
  end;
  SetState(bsData);
end;

procedure TIBBlobStream.GetBlobInfo;
var
  iBlobSize: Int64;
begin
  if FBlob = nil then Exit;

  FBlob.GetInfo(FBlobNumSegments, FBlobMaxSegmentSize, iBlobSize, FBlobType);
  SetSize(iBlobSize);
end;

function TIBBlobStream.GetSize: Int64;
begin
  EnsureBlobInitialized;
  Result := FBlobSize;
end;

function TIBBlobStream.GetDatabase: TIBDatabase;
begin
  result := FBase.Database;
end;

function TIBBlobStream.GetTransaction: TIBTransaction;
begin
  result := FBase.Transaction;
end;

procedure TIBBlobStream.LoadFromFile(Filename: string);
var
  Stream: TStream;
begin
  Stream := TFileStream.Create(FileName, fmOpenRead);
  try
    LoadFromStream(Stream);
  finally
    Stream.Free;
  end;
end;

procedure TIBBlobStream.LoadFromStream(Stream: TStream);
begin
  CheckWritable;
  EnsureBlobInitialized;
  Stream.Position := 0;
  SetSize(Stream.Size);
  if FBlobSize <> 0 then
    Stream.ReadBuffer(FBuffer^, FBlobSize);
  SetState(bsModified);
end;

procedure TIBBlobStream.OpenBlob;
begin
  CheckReadable;
  try
    GetBlobInfo;
    {Defer reading in blob until read method called}
  except
    FBlob.Close;
    raise;
  end;
  SetState(bsDataPending);
end;

function TIBBlobStream.Read(var Buffer; Count: Longint): Longint;
begin
  CheckReadable;
  EnsureLoaded;
  if Count <= 0 then
  begin
    result := 0;
    exit;
  end;
  if (FPosition + Count > FBlobSize) then
    result := FBlobSize - FPosition
  else
    result := Count;
  Move(FBuffer[FPosition], Buffer, result);
  Inc(FPosition, Result);
end;

procedure TIBBlobStream.SaveToFile(Filename: string);
var
  Stream: TStream;
begin
  Stream := TFileStream.Create(FileName, fmCreate);
  try
    SaveToStream(Stream);
  finally
    Stream.Free;
  end;
end;

procedure TIBBlobStream.SaveToStream(Stream: TStream);
begin
  CheckReadable;
  EnsureLoaded;
  if FBlobSize <> 0 then
  begin
    Seek(0, soFromBeginning);
    Stream.WriteBuffer(FBuffer^, FBlobSize);
  end;
end;

function TIBBlobStream.Seek(const Offset: Int64; Origin: TSeekOrigin): Int64;
begin
  EnsureBlobInitialized;
  case Origin of
    soBeginning     : FPosition := Offset;
    soCurrent       : Inc(FPosition, Offset);
    soEnd           : FPosition := FBlobSize + Offset;
  end;
  result := FPosition;
end;

procedure TIBBlobStream.SetField(aField: TField);
begin
  FRelationName := '';
  if aField.FieldDef <> nil then
    FRelationName := (aField.FieldDef as TIBFieldDef).RelationName;
  FColumnName := aField.FieldName;;
end;

procedure TIBBlobStream.SetBlobID(Value: TISC_QUAD);
begin
  CheckActive;
  FBlob := nil;
  if (Value.gds_quad_high = 0) and (Value.gds_quad_low = 0) then
    Exit;
  FBlob := Database.Attachment.OpenBlob(Transaction.TransactionIntf,RelationName,ColumnName,Value);
  if FBlobState <> bsData then
    SetState(bsUninitialised);
end;

procedure TIBBlobStream.SetDatabase(Value: TIBDatabase);
begin
  FBase.Database := Value;
  SetState(bsUninitialised);
end;

procedure TIBBlobStream.SetMode(Value: TBlobStreamMode);
begin
  FMode := Value;
  SetState(bsUninitialised);
end;

procedure TIBBlobStream.SetState(aValue: TIBBlobStates);
begin
  if FBlobState = aValue then Exit;

  if (FBlobState = bsDataPending) and (FBlob <> nil) then
    FBlob.Close;

  FBlobState := aValue;
end;

procedure TIBBlobStream.SetSize(const NewSize: Int64);
begin
  if (NewSize <> FBlobSize) then
  begin
    ReallocMem(FBuffer, NewSize);
    FBlobSize := NewSize;
    if NewSize = 0 then
      FBuffer := nil;
  end;
end;

procedure TIBBlobStream.SetSize(NewSize: Longint);
begin
  SetSize(Int64(NewSize));
end;

procedure TIBBlobStream.SetTransaction(Value: TIBTransaction);
begin
  FBase.Transaction := Value;
  SetState(bsUninitialised);
end;

procedure TIBBlobStream.Truncate;
begin
  SetSize(0);
  SetState(bsModified);
end;

function TIBBlobStream.Write(const Buffer; Count: Longint): Longint;
begin
  CheckWritable;
  EnsureLoaded;  {Could be an untruncated bmReadWrite Blob}
  result := Count;
  if Count <= 0 then
    exit;
  if (FPosition + Count > FBlobSize) then
    SetSize(FPosition + Count);
  Move(Buffer, FBuffer[FPosition], Count);
  Inc(FPosition, Count);
  SetState(bsModified);
end;

end.
Revision:	362
Committed:	Tue Dec 7 13:27:39 2021 UTC (3 years ago) by tony
Content type:	text/x-pascal
File size:	11542 byte(s)
Log Message:	initiate test release
#	User	Rev	Content
1	tony	209	{************************************************************************}
2			{ }
3			{ Borland Delphi Visual Component Library }
4			{ InterBase Express core components }
5			{ }
6			{ Copyright (c) 1998-2000 Inprise Corporation }
7			{ }
8			{ InterBase Express is based in part on the product }
9			{ Free IB Components, written by Gregory H. Deatz for }
10			{ Hoagland, Longo, Moran, Dunst & Doukas Company. }
11			{ Free IB Components is used under license. }
12			{ }
13			{ The contents of this file are subject to the InterBase }
14			{ Public License Version 1.0 (the "License"); you may not }
15			{ use this file except in compliance with the License. You }
16			{ may obtain a copy of the License at http://www.Inprise.com/IPL.html }
17			{ Software distributed under the License is distributed on }
18			{ an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either }
19			{ express or implied. See the License for the specific language }
20			{ governing rights and limitations under the License. }
21			{ The Original Code was created by InterBase Software Corporation }
22			{ and its successors. }
23			{ Portions created by Inprise Corporation are Copyright (C) Inprise }
24			{ Corporation. All Rights Reserved. }
25			{ Contributor(s): Jeff Overcash }
26			{ }
27			{ IBX For Lazarus (Firebird Express) }
28			{ Contributor: Tony Whyman, MWA Software http://www.mwasoftware.co.uk }
29			{ Portions created by MWA Software are copyright McCallum Whyman }
30			{ Associates Ltd 2011 - 2018 }
31			{************************************************************************}
32
33			unit IBBlob;
34
35			{$mode Delphi}
36
37			interface
38
39			uses
40			SysUtils, Classes, DB, IB, IBDatabase;
41
42
43			const
44			DefaultBlobSegmentSize = 16 * 1024;
45
46			type
47			TIBBlobStates = (bsUninitialised, bsDataPending, bsData, bsModified);
48
49			{ TIBBlobStream }
50			TIBBlobStream = class(TStream)
51			private
52			FBase: TIBBase;
53			FBlob: IBlob;
54			FBlobMaxSegmentSize: Int64;
55			FBlobNumSegments: Int64;
56			FBlobSize: Int64;
57			FBlobType: TBlobType;
58			FBuffer: PChar;
59			FColumnName: string;
60			FMode: TBlobStreamMode;
61			FPosition: Int64;
62			FBlobState: TIBBlobStates;
63			FRelationName: string;
64			function GetBlobID: TISC_QUAD;
65			function GetModified: Boolean;
66			procedure CheckActive;
67			protected
68			procedure CloseBlob;
69			procedure EnsureBlobInitialized;
70			procedure EnsureLoaded;
71			procedure GetBlobInfo;
72			function GetSize: Int64; override;
73			function GetDatabase: TIBDatabase;
74			function GetTransaction: TIBTransaction;
75			procedure OpenBlob;
76			procedure SetBlobID(Value: TISC_QUAD);
77			procedure SetDatabase(Value: TIBDatabase);
78			procedure SetMode(Value: TBlobStreamMode);
79			procedure SetState(aValue: TIBBlobStates);
80			procedure SetTransaction(Value: TIBTransaction);
81			public
82			constructor Create;
83			destructor Destroy; override;
84			procedure CheckReadable;
85			procedure CheckWritable;
86			procedure Finalize;
87			procedure LoadFromFile(Filename: string);
88			procedure LoadFromStream(Stream: TStream);
89			function Read(var Buffer; Count: Longint): Longint; override;
90			procedure SaveToFile(Filename: string);
91			procedure SaveToStream(Stream: TStream);
92			function Seek(const Offset: Int64; Origin: TSeekOrigin): Int64; override;
93			procedure SetField(aField: TField);
94			procedure SetSize(const NewSize: Int64); override;
95			procedure SetSize(NewSize: Longint); override;
96			procedure Truncate;
97			function Write(const Buffer; Count: Longint): Longint; override;
98			property BlobID: TISC_QUAD read GetBlobID write SetBlobID;
99			property Blob: IBlob read FBlob;
100			property BlobMaxSegmentSize: Int64 read FBlobMaxSegmentSize;
101			property BlobNumSegments: Int64 read FBlobNumSegments;
102			property BlobSize: Int64 read GetSize;
103			property BlobType: TBlobType read FBlobType;
104			property Database: TIBDatabase read GetDatabase write SetDatabase;
105			property Mode: TBlobStreamMode read FMode write SetMode;
106			property Modified: Boolean read GetModified;
107			property Transaction: TIBTransaction read GetTransaction write SetTransaction;
108			property RelationName: string read FRelationName;
109			property ColumnName: string read FColumnName;
110			end;
111
112			implementation
113
114	tony	291	uses IBMessages, IBCustomDataSet;
115	tony	209
116			{ TIBBlobStream }
117			constructor TIBBlobStream.Create;
118			begin
119			inherited Create;
120			FBase := TIBBase.Create(Self);
121			FBuffer := nil;
122			FBlobSize := 0;
123			FBlobState := bsUninitialised;
124			FBlob := nil;
125			end;
126
127			destructor TIBBlobStream.Destroy;
128			begin
129			CloseBlob;
130			FBase.Free;
131			SetSize(0);
132			inherited Destroy;
133			end;
134
135			procedure TIBBlobStream.CheckReadable;
136			begin
137			if FMode = bmWrite then IBError(ibxeBlobCannotBeRead, [nil]);
138			end;
139
140			procedure TIBBlobStream.CheckWritable;
141			begin
142			if FMode = bmRead then IBError(ibxeBlobCannotBeWritten, [nil]);
143			end;
144
145			function TIBBlobStream.GetModified: Boolean;
146			begin
147			Result := FBlobState = bsModified;
148			end;
149
150			procedure TIBBlobStream.CheckActive;
151			begin
152			if Database = nil then
153			IBError(ibxeDatabaseNotAssigned,[nil]);
154
155			if (Database.Attachment = nil) or
156			not Database.Attachment.IsConnected then
157			IBError(ibxeDatabaseClosed,[nil]);
158
159			if Transaction = nil then
160			IBError(ibxeTransactionNotAssigned,[nil]);
161
162			if (Transaction.TransactionIntf = nil) or
163			not Transaction.TransactionIntf.InTransaction then
164			IBError(ibxeNotInTransaction,[nil]);
165			end;
166
167			function TIBBlobStream.GetBlobID: TISC_QUAD;
168			begin
169			if (FBlob = nil) or (FBlobSize = 0) then
170			begin
171			Result.gds_quad_high := 0;
172			Result.gds_quad_low := 0;
173			end
174			else
175			Result := FBlob.GetBlobID;
176			end;
177
178			procedure TIBBlobStream.CloseBlob;
179			begin
180			Finalize;
181			FBlob := nil;
182			SetState(bsUninitialised);
183			end;
184
185			procedure TIBBlobStream.EnsureBlobInitialized;
186			begin
187			if FBlobState <> bsUninitialised then Exit;
188
189			if FMode = bmWrite then
190			SetState(bsData)
191			else
192			begin
193			CheckReadable;
194			if FBlob = nil then Exit;
195			try
196			GetBlobInfo;
197			{Defer reading in blob until read method called}
198			except
199			FBlob := nil;
200			raise;
201			end;
202			SetState(bsDataPending);
203			end;
204			end;
205
206			procedure TIBBlobStream.EnsureLoaded;
207			begin
208			EnsureBlobInitialized;
209			if (FBlobState = bsDataPending) and (FBlob <> nil) then
210			begin
211			SetSize(FBlobSize);
212			FBlob.Read(FBuffer^, FBlobSize);
213			SetState(bsData);
214			end;
215			end;
216
217			procedure TIBBlobStream.Finalize;
218			begin
219			if FBlobState <> bsModified then
220			exit;
221			CheckWritable;
222			if FBlobSize > 0 then
223			begin
224			{ need to start writing to a blob, create one }
225			FBlob := Database.Attachment.CreateBlob(Transaction.TransactionIntf,RelationName,ColumnName);
226			FBlob.Write(FBuffer^, FBlobSize);
227			FBlob.Close;
228			end;
229			SetState(bsData);
230			end;
231
232			procedure TIBBlobStream.GetBlobInfo;
233			var
234			iBlobSize: Int64;
235			begin
236			if FBlob = nil then Exit;
237
238			FBlob.GetInfo(FBlobNumSegments, FBlobMaxSegmentSize, iBlobSize, FBlobType);
239			SetSize(iBlobSize);
240			end;
241
242			function TIBBlobStream.GetSize: Int64;
243			begin
244			EnsureBlobInitialized;
245			Result := FBlobSize;
246			end;
247
248			function TIBBlobStream.GetDatabase: TIBDatabase;
249			begin
250			result := FBase.Database;
251			end;
252
253			function TIBBlobStream.GetTransaction: TIBTransaction;
254			begin
255			result := FBase.Transaction;
256			end;
257
258			procedure TIBBlobStream.LoadFromFile(Filename: string);
259			var
260			Stream: TStream;
261			begin
262			Stream := TFileStream.Create(FileName, fmOpenRead);
263			try
264			LoadFromStream(Stream);
265			finally
266			Stream.Free;
267			end;
268			end;
269
270			procedure TIBBlobStream.LoadFromStream(Stream: TStream);
271			begin
272			CheckWritable;
273			EnsureBlobInitialized;
274			Stream.Position := 0;
275			SetSize(Stream.Size);
276			if FBlobSize <> 0 then
277			Stream.ReadBuffer(FBuffer^, FBlobSize);
278			SetState(bsModified);
279			end;
280
281			procedure TIBBlobStream.OpenBlob;
282			begin
283			CheckReadable;
284			try
285			GetBlobInfo;
286			{Defer reading in blob until read method called}
287			except
288			FBlob.Close;
289			raise;
290			end;
291			SetState(bsDataPending);
292			end;
293
294			function TIBBlobStream.Read(var Buffer; Count: Longint): Longint;
295			begin
296			CheckReadable;
297			EnsureLoaded;
298			if Count <= 0 then
299			begin
300			result := 0;
301			exit;
302			end;
303			if (FPosition + Count > FBlobSize) then
304			result := FBlobSize - FPosition
305			else
306			result := Count;
307			Move(FBuffer[FPosition], Buffer, result);
308			Inc(FPosition, Result);
309			end;
310
311			procedure TIBBlobStream.SaveToFile(Filename: string);
312			var
313			Stream: TStream;
314			begin
315			Stream := TFileStream.Create(FileName, fmCreate);
316			try
317			SaveToStream(Stream);
318			finally
319			Stream.Free;
320			end;
321			end;
322
323			procedure TIBBlobStream.SaveToStream(Stream: TStream);
324			begin
325			CheckReadable;
326			EnsureLoaded;
327			if FBlobSize <> 0 then
328			begin
329			Seek(0, soFromBeginning);
330			Stream.WriteBuffer(FBuffer^, FBlobSize);
331			end;
332			end;
333
334			function TIBBlobStream.Seek(const Offset: Int64; Origin: TSeekOrigin): Int64;
335			begin
336			EnsureBlobInitialized;
337			case Origin of
338			soBeginning : FPosition := Offset;
339			soCurrent : Inc(FPosition, Offset);
340			soEnd : FPosition := FBlobSize + Offset;
341			end;
342			result := FPosition;
343			end;
344
345			procedure TIBBlobStream.SetField(aField: TField);
346			begin
347			FRelationName := '';
348			if aField.FieldDef <> nil then
349			FRelationName := (aField.FieldDef as TIBFieldDef).RelationName;
350			FColumnName := aField.FieldName;;
351			end;
352
353			procedure TIBBlobStream.SetBlobID(Value: TISC_QUAD);
354			begin
355			CheckActive;
356			FBlob := nil;
357			if (Value.gds_quad_high = 0) and (Value.gds_quad_low = 0) then
358			Exit;
359			FBlob := Database.Attachment.OpenBlob(Transaction.TransactionIntf,RelationName,ColumnName,Value);
360			if FBlobState <> bsData then
361			SetState(bsUninitialised);
362			end;
363
364			procedure TIBBlobStream.SetDatabase(Value: TIBDatabase);
365			begin
366			FBase.Database := Value;
367			SetState(bsUninitialised);
368			end;
369
370			procedure TIBBlobStream.SetMode(Value: TBlobStreamMode);
371			begin
372			FMode := Value;
373			SetState(bsUninitialised);
374			end;
375
376			procedure TIBBlobStream.SetState(aValue: TIBBlobStates);
377			begin
378			if FBlobState = aValue then Exit;
379
380			if (FBlobState = bsDataPending) and (FBlob <> nil) then
381			FBlob.Close;
382
383			FBlobState := aValue;
384			end;
385
386			procedure TIBBlobStream.SetSize(const NewSize: Int64);
387			begin
388			if (NewSize <> FBlobSize) then
389			begin
390			ReallocMem(FBuffer, NewSize);
391			FBlobSize := NewSize;
392			if NewSize = 0 then
393			FBuffer := nil;
394			end;
395			end;
396
397			procedure TIBBlobStream.SetSize(NewSize: Longint);
398			begin
399			SetSize(Int64(NewSize));
400			end;
401
402			procedure TIBBlobStream.SetTransaction(Value: TIBTransaction);
403			begin
404			FBase.Transaction := Value;
405			SetState(bsUninitialised);
406			end;
407
408			procedure TIBBlobStream.Truncate;
409			begin
410			SetSize(0);
411			SetState(bsModified);
412			end;
413
414			function TIBBlobStream.Write(const Buffer; Count: Longint): Longint;
415			begin
416			CheckWritable;
417			EnsureLoaded; {Could be an untruncated bmReadWrite Blob}
418			result := Count;
419			if Count <= 0 then
420			exit;
421			if (FPosition + Count > FBlobSize) then
422			SetSize(FPosition + Count);
423			Move(Buffer, FBuffer[FPosition], Count);
424			Inc(FPosition, Count);
425			SetState(bsModified);
426			end;
427
428			end.