ViewVC Help
View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing
root/public/ibx/trunk/runtime/IBCustomDataSet.pas
(Generate patch)
# Line 1 | Line 1
1 < {************************************************************************}
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                                                 }
31 < {                                                                        }
32 < {************************************************************************}
33 <
34 < unit IBCustomDataSet;
35 <
36 < {$Mode Delphi}
37 <
38 < {$IFDEF DELPHI}
39 < {$DEFINE TDBDFIELD_IS_BCD}
40 < {$ENDIF}
41 <
42 < interface
43 <
44 < uses
45 < {$IFDEF WINDOWS }
46 <  Windows,
47 < {$ELSE}
48 <  unix,
49 < {$ENDIF}
50 <  SysUtils, Classes, Forms, Controls, IBDatabase,
51 <  IBExternals, IB, IBHeader,  IBSQL, Db,
52 <  IBUtils, IBBlob;
53 <
54 < const
55 <  BufferCacheSize    =  1000;  { Allocate cache in this many record chunks}
56 <  UniCache           =  2;     { Uni-directional cache is 2 records big }
57 <
58 < type
59 <  TIBCustomDataSet = class;
60 <  TIBDataSet = class;
61 <
62 <  { TIBDataSetUpdateObject }
63 <
64 <  TIBDataSetUpdateObject = class(TComponent)
65 <  private
66 <    FRefreshSQL: TStrings;
67 <    procedure SetRefreshSQL(value: TStrings);
68 <  protected
69 <    function GetDataSet: TIBCustomDataSet; virtual; abstract;
70 <    procedure SetDataSet(ADataSet: TIBCustomDataSet); virtual; abstract;
71 <    procedure Apply(UpdateKind: TUpdateKind; buff: PChar); virtual; abstract;
72 <    function GetSQL(UpdateKind: TUpdateKind): TStrings; virtual; abstract;
73 <    procedure InternalSetParams(Query: TIBSQL; buff: PChar);
74 <    property DataSet: TIBCustomDataSet read GetDataSet write SetDataSet;
75 <  public
76 <    constructor Create(AOwner: TComponent); override;
77 <    destructor Destroy; override;
78 <  published
79 <    property RefreshSQL: TStrings read FRefreshSQL write SetRefreshSQL;
80 <  end;
81 <
82 <  TBlobDataArray = array[0..0] of TIBBlobStream;
83 <  PBlobDataArray = ^TBlobDataArray;
84 <
85 <  { TIBCustomDataSet }
86 <  TFieldData = record
87 <    fdDataType: Short;
88 <    fdDataScale: Short;
89 <    fdNullable: Boolean;
90 <    fdIsNull: Boolean;
91 <    fdDataSize: Short;
92 <    fdDataLength: Short;
93 <    fdDataOfs: Integer;
94 <  end;
95 <  PFieldData = ^TFieldData;
96 <
97 <  TCachedUpdateStatus = (
98 <                         cusUnmodified, cusModified, cusInserted,
99 <                         cusDeleted, cusUninserted
100 <                        );
101 <  TIBDBKey = record
102 <    DBKey: array[0..7] of Byte;
103 <  end;
104 <  PIBDBKey = ^TIBDBKey;
105 <
106 <  TRecordData = record
107 <    rdBookmarkFlag: TBookmarkFlag;
108 <    rdFieldCount: Short;
109 <    rdRecordNumber: Integer;
110 <    rdCachedUpdateStatus: TCachedUpdateStatus;
111 <    rdUpdateStatus: TUpdateStatus;
112 <    rdSavedOffset: DWORD;
113 <    rdDBKey: TIBDBKey;
114 <    rdFields: array[1..1] of TFieldData;
115 <  end;
116 <  PRecordData = ^TRecordData;
117 <
118 <  { TIBStringField allows us to have strings longer than 8196 }
119 <
120 <  TIBStringField = class(TStringField)
121 <  public
122 <    constructor create(AOwner: TComponent); override;
123 <    class procedure CheckTypeSize(Value: Integer); override;
124 <    function GetAsString: string; override;
125 <    function GetAsVariant: Variant; override;
126 <    function GetValue(var Value: string): Boolean;
127 <    procedure SetAsString(const Value: string); override;
128 <  end;
129 <
130 <  { TIBBCDField }
131 <  {  Actually, there is no BCD involved in this type,
132 <     instead it deals with currency types.
133 <     In IB, this is an encapsulation of Numeric (x, y)
134 <     where x < 18 and y <= 4.
135 <     Note: y > 4 will default to Floats
136 <  }
137 <  TIBBCDField = class(TBCDField)
138 <  protected
139 <    class procedure CheckTypeSize(Value: Integer); override;
140 <    function GetAsCurrency: Currency; override;
141 <    function GetAsString: string; override;
142 <    function GetAsVariant: Variant; override;
143 <    function GetDataSize: Integer; override;
144 <  public
145 <    constructor Create(AOwner: TComponent); override;
146 <  published
147 <    property Size default 8;
148 <  end;
149 <
150 <  TIBDataLink = class(TDetailDataLink)
151 <  private
152 <    FDataSet: TIBCustomDataSet;
153 <  protected
154 <    procedure ActiveChanged; override;
155 <    procedure RecordChanged(Field: TField); override;
156 <    function GetDetailDataSet: TDataSet; override;
157 <    procedure CheckBrowseMode; override;
158 <  public
159 <    constructor Create(ADataSet: TIBCustomDataSet);
160 <    destructor Destroy; override;
161 <  end;
162 <
163 <  TIBGeneratorApplyOnEvent = (gaeOnNewRecord,gaeOnPostRecord);
164 <
165 <  { TIBGenerator }
166 <
167 <  TIBGenerator = class(TPersistent)
168 <  private
169 <    FOwner: TIBCustomDataSet;
170 <    FApplyOnEvent: TIBGeneratorApplyOnEvent;
171 <    FFieldName: string;
172 <    FGeneratorName: string;
173 <    FIncrement: integer;
174 <    procedure SetIncrement(const AValue: integer);
175 <  protected
176 <    function GetNextValue(ADatabase: TIBDatabase; ATransaction: TIBTransaction): integer;
177 <  public
178 <    constructor Create(Owner: TIBCustomDataSet);
179 <    procedure Apply;
180 <    property Owner: TIBCustomDataSet read FOwner;
181 <  published
182 <    property Generator: string read FGeneratorName write FGeneratorName;
183 <    property Field: string read FFieldName write FFieldName;
184 <    property Increment: integer read FIncrement write SetIncrement default 1;
185 <    property ApplyOnEvent: TIBGeneratorApplyOnEvent read FApplyOnEvent write FApplyOnEvent;
186 <  end;
187 <
188 <  { TIBCustomDataSet }
189 <  TIBUpdateAction = (uaFail, uaAbort, uaSkip, uaRetry, uaApply, uaApplied);
190 <
191 <  TIBUpdateErrorEvent = procedure(DataSet: TDataSet; E: EDatabaseError;
192 <                                 UpdateKind: TUpdateKind; var UpdateAction: TIBUpdateAction)
193 <                                 of object;
194 <  TIBUpdateRecordEvent = procedure(DataSet: TDataSet; UpdateKind: TUpdateKind;
195 <                                   var UpdateAction: TIBUpdateAction) of object;
196 <
197 <  TIBUpdateRecordTypes = set of TCachedUpdateStatus;
198 <
199 <  TIBCustomDataSet = class(TDataset)
200 <  private
201 <    FGeneratorField: TIBGenerator;
202 <    FNeedsRefresh: Boolean;
203 <    FForcedRefresh: Boolean;
204 <    FDidActivate: Boolean;
205 <    FIBLoaded: Boolean;
206 <    FBase: TIBBase;
207 <    FBlobCacheOffset: Integer;
208 <    FBlobStreamList: TList;
209 <    FBufferChunks: Integer;
210 <    FBufferCache,
211 <    FOldBufferCache: PChar;
212 <    FBufferChunkSize,
213 <    FCacheSize,
214 <    FOldCacheSize: Integer;
215 <    FFilterBuffer: PChar;
216 <    FBPos,
217 <    FOBPos,
218 <    FBEnd,
219 <    FOBEnd: DWord;
220 <    FCachedUpdates: Boolean;
221 <    FCalcFieldsOffset: Integer;
222 <    FCurrentRecord: Long;
223 <    FDeletedRecords: Long;
224 <    FModelBuffer,
225 <    FOldBuffer: PChar;
226 <    FOpen: Boolean;
227 <    FInternalPrepared: Boolean;
228 <    FQDelete,
229 <    FQInsert,
230 <    FQRefresh,
231 <    FQSelect,
232 <    FQModify: TIBSQL;
233 <    FRecordBufferSize: Integer;
234 <    FRecordCount: Integer;
235 <    FRecordSize: Integer;
236 <    FUniDirectional: Boolean;
237 <    FUpdateMode: TUpdateMode;
238 <    FUpdateObject: TIBDataSetUpdateObject;
239 <    FParamCheck: Boolean;
240 <    FUpdatesPending: Boolean;
241 <    FUpdateRecordTypes: TIBUpdateRecordTypes;
242 <    FMappedFieldPosition: array of Integer;
243 <    FDataLink: TIBDataLink;
244 <
245 <    FBeforeDatabaseDisconnect,
246 <    FAfterDatabaseDisconnect,
247 <    FDatabaseFree: TNotifyEvent;
248 <    FOnUpdateError: TIBUpdateErrorEvent;
249 <    FOnUpdateRecord: TIBUpdateRecordEvent;
250 <    FBeforeTransactionEnd,
251 <    FAfterTransactionEnd,
252 <    FTransactionFree: TNotifyEvent;
253 <
254 <    function GetSelectStmtHandle: TISC_STMT_HANDLE;
255 <    procedure SetUpdateMode(const Value: TUpdateMode);
256 <    procedure SetUpdateObject(Value: TIBDataSetUpdateObject);
257 <
258 <    function AdjustCurrentRecord(Buffer: Pointer; GetMode: TGetMode): TGetResult;
259 <    procedure AdjustRecordOnInsert(Buffer: Pointer);
260 <    function CanEdit: Boolean;
261 <    function CanInsert: Boolean;
262 <    function CanDelete: Boolean;
263 <    function CanRefresh: Boolean;
264 <    procedure CheckEditState;
265 <    procedure ClearBlobCache;
266 <    procedure CopyRecordBuffer(Source, Dest: Pointer);
267 <    procedure DoBeforeDatabaseDisconnect(Sender: TObject);
268 <    procedure DoAfterDatabaseDisconnect(Sender: TObject);
269 <    procedure DoDatabaseFree(Sender: TObject);
270 <    procedure DoBeforeTransactionEnd(Sender: TObject);
271 <    procedure DoAfterTransactionEnd(Sender: TObject);
272 <    procedure DoTransactionFree(Sender: TObject);
273 <    procedure FetchCurrentRecordToBuffer(Qry: TIBSQL; RecordNumber: Integer;
274 <                                         Buffer: PChar);
275 <    function GetDatabase: TIBDatabase;
276 <    function GetDBHandle: PISC_DB_HANDLE;
277 <    function GetDeleteSQL: TStrings;
278 <    function GetInsertSQL: TStrings;
279 <    function GetSQLParams: TIBXSQLDA;
280 <    function GetRefreshSQL: TStrings;
281 <    function GetSelectSQL: TStrings;
282 <    function GetStatementType: TIBSQLTypes;
283 <    function GetModifySQL: TStrings;
284 <    function GetTransaction: TIBTransaction;
285 <    function GetTRHandle: PISC_TR_HANDLE;
286 <    procedure InternalDeleteRecord(Qry: TIBSQL; Buff: Pointer); virtual;
287 <    function InternalLocate(const KeyFields: string; const KeyValues: Variant;
288 <                            Options: TLocateOptions): Boolean; virtual;
289 <    procedure InternalPostRecord(Qry: TIBSQL; Buff: Pointer); virtual;
290 <    procedure InternalRevertRecord(RecordNumber: Integer); virtual;
291 <    function IsVisible(Buffer: PChar): Boolean;
292 <    procedure SaveOldBuffer(Buffer: PChar);
293 <    procedure SetBufferChunks(Value: Integer);
294 <    procedure SetDatabase(Value: TIBDatabase);
295 <    procedure SetDeleteSQL(Value: TStrings);
296 <    procedure SetInsertSQL(Value: TStrings);
297 <    procedure SetInternalSQLParams(Qry: TIBSQL; Buffer: Pointer);
298 <    procedure SetRefreshSQL(Value: TStrings);
299 <    procedure SetSelectSQL(Value: TStrings);
300 <    procedure SetModifySQL(Value: TStrings);
301 <    procedure SetTransaction(Value: TIBTransaction);
302 <    procedure SetUpdateRecordTypes(Value: TIBUpdateRecordTypes);
303 <    procedure SetUniDirectional(Value: Boolean);
304 <    procedure RefreshParams;
305 <    procedure SQLChanging(Sender: TObject); virtual;
306 <    function AdjustPosition(FCache: PChar; Offset: DWORD;
307 <                            Origin: Integer): DWORD;
308 <    procedure ReadCache(FCache: PChar; Offset: DWORD; Origin: Integer;
309 <                       Buffer: PChar);
310 <    procedure ReadRecordCache(RecordNumber: Integer; Buffer: PChar;
311 <                              ReadOldBuffer: Boolean);
312 <    procedure WriteCache(FCache: PChar; Offset: DWORD; Origin: Integer;
313 <                        Buffer: PChar);
314 <    procedure WriteRecordCache(RecordNumber: Integer; Buffer: PChar);
315 <    function InternalGetRecord(Buffer: PChar; GetMode: TGetMode;
316 <                       DoCheck: Boolean): TGetResult; virtual;
317 <
318 <  protected
319 <    procedure ActivateConnection;
320 <    function ActivateTransaction: Boolean;
321 <    procedure DeactivateTransaction;
322 <    procedure CheckDatasetClosed;
323 <    procedure CheckDatasetOpen;
324 <    function GetActiveBuf: PChar;
325 <    procedure InternalBatchInput(InputObject: TIBBatchInput); virtual;
326 <    procedure InternalBatchOutput(OutputObject: TIBBatchOutput); virtual;
327 <    procedure InternalPrepare; virtual;
328 <    procedure InternalUnPrepare; virtual;
329 <    procedure InternalExecQuery; virtual;
330 <    procedure InternalRefreshRow; virtual;
331 <    procedure InternalSetParamsFromCursor; virtual;
332 <    procedure CheckNotUniDirectional;
333 <
334 < (*    { IProviderSupport }
335 <    procedure PSEndTransaction(Commit: Boolean); override;
336 <    function PSExecuteStatement(const ASQL: string; AParams: TParams;
337 <      ResultSet: Pointer = nil): Integer; override;
338 <    function PsGetTableName: string; override;
339 <    function PSGetQuoteChar: string; override;
340 <    function PSGetUpdateException(E: Exception; Prev: EUpdateError): EUpdateError; override;
341 <    function PSInTransaction: Boolean; override;
342 <    function PSIsSQLBased: Boolean; override;
343 <    function PSIsSQLSupported: Boolean; override;
344 <    procedure PSStartTransaction; override;
345 <    procedure PSReset; override;
346 <    function PSUpdateRecord(UpdateKind: TUpdateKind; Delta: TDataSet): Boolean; override;
347 < *)
348 <    { TDataSet support }
349 <    procedure InternalInsert; override;
350 <    procedure InitRecord(Buffer: PChar); override;
351 <    procedure Disconnect; virtual;
352 <    function ConstraintsStored: Boolean;
353 <    procedure ClearCalcFields(Buffer: PChar); override;
354 <    function AllocRecordBuffer: PChar; override;
355 <    procedure DoBeforeDelete; override;
356 <    procedure DoBeforeEdit; override;
357 <    procedure DoBeforeInsert; override;
358 <    procedure DoAfterInsert; override;
359 <    procedure DoBeforePost; override;
360 <    procedure FreeRecordBuffer(var Buffer: PChar); override;
361 <    procedure GetBookmarkData(Buffer: PChar; Data: Pointer); override;
362 <    function GetBookmarkFlag(Buffer: PChar): TBookmarkFlag; override;
363 <    function GetCanModify: Boolean; override;
364 <    function GetDataSource: TDataSource; override;
365 <    function GetFieldClass(FieldType: TFieldType): TFieldClass; override;
366 <    function GetRecNo: Integer; override;
367 <    function GetRecord(Buffer: PChar; GetMode: TGetMode;
368 <                       DoCheck: Boolean): TGetResult; override;
369 <    function GetRecordCount: Integer; override;
370 <    function GetRecordSize: Word; override;
371 <    procedure InternalAddRecord(Buffer: Pointer; Append: Boolean); override;
372 <    procedure InternalCancel; override;
373 <    procedure InternalClose; override;
374 <    procedure InternalDelete; override;
375 <    procedure InternalFirst; override;
376 <    function InternalGetFieldData(Field: TField; Buffer: Pointer): Boolean; virtual;
377 <    procedure InternalGotoBookmark(Bookmark: Pointer); override;
378 <    procedure InternalHandleException; override;
379 <    procedure InternalInitFieldDefs; override;
380 <    procedure InternalInitRecord(Buffer: PChar); override;
381 <    procedure InternalLast; override;
382 <    procedure InternalOpen; override;
383 <    procedure InternalPost; override;
384 <    procedure InternalRefresh; override;
385 <    procedure InternalSetFieldData(Field: TField; Buffer: Pointer); virtual;
386 <    procedure InternalSetToRecord(Buffer: PChar); override;
387 <    function IsCursorOpen: Boolean; override;
388 <    procedure ReQuery;
389 <    procedure SetBookmarkFlag(Buffer: PChar; Value: TBookmarkFlag); override;
390 <    procedure SetBookmarkData(Buffer: PChar; Data: Pointer); override;
391 <    procedure SetCachedUpdates(Value: Boolean);
392 <    procedure SetDataSource(Value: TDataSource);
393 <    procedure SetFieldData(Field : TField; Buffer : Pointer); override;
394 <    procedure SetFieldData(Field : TField; Buffer : Pointer;
395 <      NativeFormat : Boolean); overload; override;
396 <    procedure SetRecNo(Value: Integer); override;
397 <
398 <  protected
399 <    {Likely to be made public by descendant classes}
400 <    property SQLParams: TIBXSQLDA read GetSQLParams;
401 <    property Params: TIBXSQLDA read GetSQLParams;
402 <    property InternalPrepared: Boolean read FInternalPrepared;
403 <    property QDelete: TIBSQL read FQDelete;
404 <    property QInsert: TIBSQL read FQInsert;
405 <    property QRefresh: TIBSQL read FQRefresh;
406 <    property QSelect: TIBSQL read FQSelect;
407 <    property QModify: TIBSQL read FQModify;
408 <    property StatementType: TIBSQLTypes read GetStatementType;
409 <    property SelectStmtHandle: TISC_STMT_HANDLE read GetSelectStmtHandle;
410 <
411 <    {Likely to be made published by descendant classes}
412 <    property BufferChunks: Integer read FBufferChunks write SetBufferChunks;
413 <    property CachedUpdates: Boolean read FCachedUpdates write SetCachedUpdates;
414 <    property UniDirectional: Boolean read FUniDirectional write SetUniDirectional default False;
415 <    property GeneratorField: TIBGenerator read FGeneratorField write FGeneratorField;
416 <    property DeleteSQL: TStrings read GetDeleteSQL write SetDeleteSQL;
417 <    property InsertSQL: TStrings read GetInsertSQL write SetInsertSQL;
418 <    property RefreshSQL: TStrings read GetRefreshSQL write SetRefreshSQL;
419 <    property SelectSQL: TStrings read GetSelectSQL write SetSelectSQL;
420 <    property ModifySQL: TStrings read GetModifySQL write SetModifySQL;
421 <    property UpdateMode: TUpdateMode read FUpdateMode write SetUpdateMode default upWhereAll;
422 <    property ParamCheck: Boolean read FParamCheck write FParamCheck default True;
423 <
424 <    property BeforeDatabaseDisconnect: TNotifyEvent read FBeforeDatabaseDisconnect
425 <                                                 write FBeforeDatabaseDisconnect;
426 <    property AfterDatabaseDisconnect: TNotifyEvent read FAfterDatabaseDisconnect
427 <                                                write FAfterDatabaseDisconnect;
428 <    property DatabaseFree: TNotifyEvent read FDatabaseFree
429 <                                        write FDatabaseFree;
430 <    property BeforeTransactionEnd: TNotifyEvent read FBeforeTransactionEnd
431 <                                             write FBeforeTransactionEnd;
432 <    property AfterTransactionEnd: TNotifyEvent read FAfterTransactionEnd
433 <                                            write FAfterTransactionEnd;
434 <    property TransactionFree: TNotifyEvent read FTransactionFree
435 <                                           write FTransactionFree;
436 <
437 <  public
438 <    constructor Create(AOwner: TComponent); override;
439 <    destructor Destroy; override;
440 <    procedure ApplyUpdates;
441 <    function CachedUpdateStatus: TCachedUpdateStatus;
442 <    procedure CancelUpdates;
443 <    procedure FetchAll;
444 <    function LocateNext(const KeyFields: string; const KeyValues: Variant;
445 <                        Options: TLocateOptions): Boolean;
446 <    procedure RecordModified(Value: Boolean);
447 <    procedure RevertRecord;
448 <    procedure Undelete;
449 <
450 <    { TDataSet support methods }
451 <    function BookmarkValid(Bookmark: TBookmark): Boolean; override;
452 <    function CompareBookmarks(Bookmark1, Bookmark2: TBookmark): Integer; override;
453 <    function CreateBlobStream(Field: TField; Mode: TBlobStreamMode): TStream; override;
454 <    function GetCurrentRecord(Buffer: PChar): Boolean; override;
455 <    function GetFieldData(Field : TField; Buffer : Pointer) : Boolean; overload; override;
456 <    function GetFieldData(FieldNo: Integer; Buffer: Pointer): Boolean; overload; (*override;*)
457 <    function GetFieldData(Field : TField; Buffer : Pointer;
458 <      NativeFormat : Boolean) : Boolean; overload; override;
459 <    function Locate(const KeyFields: string; const KeyValues: Variant;
460 <                    Options: TLocateOptions): Boolean; override;
461 <    function Lookup(const KeyFields: string; const KeyValues: Variant;
462 <                    const ResultFields: string): Variant; override;
463 <    function UpdateStatus: TUpdateStatus; override;
464 <    function IsSequenced: Boolean; override;
465 <    function ParamByName(ParamName: String): TIBXSQLVAR;
466 <    property DBHandle: PISC_DB_HANDLE read GetDBHandle;
467 <    property TRHandle: PISC_TR_HANDLE read GetTRHandle;
468 <    property UpdateObject: TIBDataSetUpdateObject read FUpdateObject write SetUpdateObject;
469 <    property UpdatesPending: Boolean read FUpdatesPending;
470 <    property UpdateRecordTypes: TIBUpdateRecordTypes read FUpdateRecordTypes
471 <                                                      write SetUpdateRecordTypes;
472 <
473 <  published
474 <    property Database: TIBDatabase read GetDatabase write SetDatabase;
475 <    property Transaction: TIBTransaction read GetTransaction
476 <                                          write SetTransaction;
477 <    property ForcedRefresh: Boolean read FForcedRefresh
478 <                                    write FForcedRefresh default False;
479 <    property AutoCalcFields;
480 <
481 <    property AfterCancel;
482 <    property AfterClose;
483 <    property AfterDelete;
484 <    property AfterEdit;
485 <    property AfterInsert;
486 <    property AfterOpen;
487 <    property AfterPost;
488 <    property AfterRefresh;
489 <    property AfterScroll;
490 <    property BeforeCancel;
491 <    property BeforeClose;
492 <    property BeforeDelete;
493 <    property BeforeEdit;
494 <    property BeforeInsert;
495 <    property BeforeOpen;
496 <    property BeforePost;
497 <    property BeforeRefresh;
498 <    property BeforeScroll;
499 <    property OnCalcFields;
500 <    property OnDeleteError;
501 <    property OnEditError;
502 <    property OnNewRecord;
503 <    property OnPostError;
504 <    property OnUpdateError: TIBUpdateErrorEvent read FOnUpdateError
505 <                                                 write FOnUpdateError;
506 <    property OnUpdateRecord: TIBUpdateRecordEvent read FOnUpdateRecord
507 <                                                   write FOnUpdateRecord;
508 <  end;
509 <
510 <  TIBDataSet = class(TIBCustomDataSet)
511 <  private
512 <    function GetPrepared: Boolean;
513 <
514 <  protected
515 <    procedure SetFiltered(Value: Boolean); override;
516 <    procedure InternalOpen; override;
517 <
518 <  public
519 <    procedure Prepare;
520 <    procedure UnPrepare;
521 <    procedure BatchInput(InputObject: TIBBatchInput);
522 <    procedure BatchOutput(OutputObject: TIBBatchOutput);
523 <    procedure ExecSQL;
524 <
525 <  public
526 <    property Params;
527 <    property Prepared : Boolean read GetPrepared;
528 <    property QDelete;
529 <    property QInsert;
530 <    property QRefresh;
531 <    property QSelect;
532 <    property QModify;
533 <    property StatementType;
534 <    property SelectStmtHandle;
535 <
536 <  published
537 <    { TIBCustomDataSet }
538 <    property BufferChunks;
539 <    property CachedUpdates;
540 <    property DeleteSQL;
541 <    property InsertSQL;
542 <    property RefreshSQL;
543 <    property SelectSQL;
544 <    property ModifySQL;
545 <    property GeneratorField;
546 <    property ParamCheck;
547 <    property UniDirectional;
548 <    property Filtered;
549 <
550 <    property BeforeDatabaseDisconnect;
551 <    property AfterDatabaseDisconnect;
552 <    property DatabaseFree;
553 <    property BeforeTransactionEnd;
554 <    property AfterTransactionEnd;
555 <    property TransactionFree;
556 <
557 <    { TIBDataSet }
558 <    property Active;
559 <    property AutoCalcFields;
560 <    property DataSource read GetDataSource write SetDataSource;
561 <
562 <    property AfterCancel;
563 <    property AfterClose;
564 <    property AfterDelete;
565 <    property AfterEdit;
566 <    property AfterInsert;
567 <    property AfterOpen;
568 <    property AfterPost;
569 <    property AfterScroll;
570 <    property BeforeCancel;
571 <    property BeforeClose;
572 <    property BeforeDelete;
573 <    property BeforeEdit;
574 <    property BeforeInsert;
575 <    property BeforeOpen;
576 <    property BeforePost;
577 <    property BeforeScroll;
578 <    property OnCalcFields;
579 <    property OnDeleteError;
580 <    property OnEditError;
581 <    property OnFilterRecord;
582 <    property OnNewRecord;
583 <    property OnPostError;
584 <  end;
585 <
586 <  { TIBDSBlobStream }
587 <  TIBDSBlobStream = class(TStream)
588 <  protected
589 <    FField: TField;
590 <    FBlobStream: TIBBlobStream;
591 <  public
592 <    constructor Create(AField: TField; ABlobStream: TIBBlobStream;
593 <                       Mode: TBlobStreamMode);
594 <    function Read(var Buffer; Count: Longint): Longint; override;
595 <    function Seek(Offset: Longint; Origin: Word): Longint; override;
596 <    procedure SetSize(NewSize: Longint); override;
597 <    function Write(const Buffer; Count: Longint): Longint; override;
598 <  end;
599 <
600 < const
601 < DefaultFieldClasses: array[TFieldType] of TFieldClass = (
602 <    nil,                { ftUnknown }
603 <    TIBStringField,     { ftString }
604 <    TSmallintField,     { ftSmallint }
605 <    TIntegerField,      { ftInteger }
606 <    TWordField,         { ftWord }
607 <    TBooleanField,      { ftBoolean }
608 <    TFloatField,        { ftFloat }
609 <    TCurrencyField,     { ftCurrency }
610 <    TIBBCDField,        { ftBCD }
611 <    TDateField,         { ftDate }
612 <    TTimeField,         { ftTime }
613 <    TDateTimeField,     { ftDateTime }
614 <    TBytesField,        { ftBytes }
615 <    TVarBytesField,     { ftVarBytes }
616 <    TAutoIncField,      { ftAutoInc }
617 <    TBlobField,         { ftBlob }
618 <    TMemoField,         { ftMemo }
619 <    TGraphicField,      { ftGraphic }
620 <    TBlobField,         { ftFmtMemo }
621 <    TBlobField,         { ftParadoxOle }
622 <    TBlobField,         { ftDBaseOle }
623 <    TBlobField,         { ftTypedBinary }
624 <    nil,                { ftCursor }
625 <    TStringField,       { ftFixedChar }
626 <    TWideStringField,    { ftWideString }
627 <    TLargeIntField,     { ftLargeInt }
628 <    nil,          { ftADT }
629 <    nil,        { ftArray }
630 <    nil,    { ftReference }
631 <    nil,     { ftDataSet }
632 <    TBlobField,         { ftOraBlob }
633 <    TMemoField,         { ftOraClob }
634 <    TVariantField,      { ftVariant }
635 <    nil,    { ftInterface }
636 <    nil,     { ftIDispatch }
637 <    TGuidField,        { ftGuid }
638 <    TDateTimeField,    {ftTimestamp}
639 <    TIBBCDField,       {ftFMTBcd}
640 <    nil,  {ftFixedWideChar}
641 <    TWideMemoField);   {ftWideMemo}
642 < (*
643 <    TADTField,          { ftADT }
644 <    TArrayField,        { ftArray }
645 <    TReferenceField,    { ftReference }
646 <    TDataSetField,     { ftDataSet }
647 <    TBlobField,         { ftOraBlob }
648 <    TMemoField,         { ftOraClob }
649 <    TVariantField,      { ftVariant }
650 <    TInterfaceField,    { ftInterface }
651 <    TIDispatchField,     { ftIDispatch }
652 <    TGuidField);        { ftGuid } *)
653 < (*var
654 <  CreateProviderProc: function(DataSet: TIBCustomDataSet): IProvider = nil;*)
655 <
656 < implementation
657 <
658 < uses IBIntf, Variants, FmtBCD;
659 <
660 < const FILE_BEGIN = 0;
661 <      FILE_CURRENT = 1;
662 <      FILE_END = 2;
663 <
664 < type
665 <
666 <  TFieldNode = class(TObject)
667 <  protected
668 <    FieldName : String;
669 <    COMPUTED_BLR : Boolean;
670 <    DEFAULT_VALUE : boolean;
671 <    NextField : TFieldNode;
672 <  end;
673 <
674 <  TRelationNode = class(TObject)
675 <  protected
676 <    RelationName : String;
677 <    FieldNodes : TFieldNode;
678 <    NextRelation : TRelationNode;
679 <  end;
680 <
681 <
682 < { TIBStringField}
683 <
684 < constructor TIBStringField.Create(AOwner: TComponent);
685 < begin
686 <  inherited Create(AOwner);
687 < end;
688 <
689 < class procedure TIBStringField.CheckTypeSize(Value: Integer);
690 < begin
691 <  { don't check string size. all sizes valid }
692 < end;
693 <
694 < function TIBStringField.GetAsString: string;
695 < begin
696 <  if not GetValue(Result) then Result := '';
697 < end;
698 <
699 < function TIBStringField.GetAsVariant: Variant;
700 < var
701 <  S: string;
702 < begin
703 <  if GetValue(S) then Result := S else Result := Null;
704 < end;
705 <
706 < function TIBStringField.GetValue(var Value: string): Boolean;
707 < var
708 <  Buffer: PChar;
709 < begin
710 <  Buffer := nil;
711 <  IBAlloc(Buffer, 0, Size + 1);
712 <  try
713 <    Result := GetData(Buffer);
714 <    if Result then
715 <    begin
716 <      Value := string(Buffer);
717 <      if Transliterate and (Value <> '') then
718 <        DataSet.Translate(PChar(Value), PChar(Value), False);
719 <    end
720 <  finally
721 <    FreeMem(Buffer);
722 <  end;
723 < end;
724 <
725 < procedure TIBStringField.SetAsString(const Value: string);
726 < var
727 <  Buffer: PChar;
728 < begin
729 <  Buffer := nil;
730 <  IBAlloc(Buffer, 0, Size + 1);
731 <  try
732 <    StrLCopy(Buffer, PChar(Value), Size);
733 <    if Transliterate then
734 <      DataSet.Translate(Buffer, Buffer, True);
735 <    SetData(Buffer);
736 <  finally
737 <    FreeMem(Buffer);
738 <  end;
739 < end;
740 <
741 < { TIBBCDField }
742 <
743 < constructor TIBBCDField.Create(AOwner: TComponent);
744 < begin
745 <  inherited Create(AOwner);
746 <  SetDataType(ftBCD);
747 <  Size := 8;
748 < end;
749 <
750 < class procedure TIBBCDField.CheckTypeSize(Value: Integer);
751 < begin
752 < { No need to check as the base type is currency, not BCD }
753 < end;
754 <
755 < function TIBBCDField.GetAsCurrency: Currency;
756 < begin
757 <  if not GetValue(Result) then
758 <    Result := 0;
759 < end;
760 <
761 < function TIBBCDField.GetAsString: string;
762 < var
763 <  C: System.Currency;
764 < begin
765 <  if GetValue(C) then
766 <    Result := CurrToStr(C)
767 <  else
768 <    Result := '';
769 < end;
770 <
771 < function TIBBCDField.GetAsVariant: Variant;
772 < var
773 <  C: System.Currency;
774 < begin
775 <  if GetValue(C) then
776 <    Result := C
777 <  else
778 <    Result := Null;
779 < end;
780 <
781 < function TIBBCDField.GetDataSize: Integer;
782 < begin
783 < {$IFDEF TBCDFIELD_IS_BCD}
784 <  Result := 8;
785 < {$ELSE}
786 <  Result := inherited GetDataSize
787 < {$ENDIF}
788 < end;
789 <
790 < { TIBDataLink }
791 <
792 < constructor TIBDataLink.Create(ADataSet: TIBCustomDataSet);
793 < begin
794 <  inherited Create;
795 <  FDataSet := ADataSet;
796 < end;
797 <
798 < destructor TIBDataLink.Destroy;
799 < begin
800 <  FDataSet.FDataLink := nil;
801 <  inherited Destroy;
802 < end;
803 <
804 <
805 < procedure TIBDataLink.ActiveChanged;
806 < begin
807 <  if FDataSet.Active then
808 <    FDataSet.RefreshParams;
809 < end;
810 <
811 <
812 < function TIBDataLink.GetDetailDataSet: TDataSet;
813 < begin
814 <  Result := FDataSet;
815 < end;
816 <
817 < procedure TIBDataLink.RecordChanged(Field: TField);
818 < begin
819 <  if (Field = nil) and FDataSet.Active then
820 <    FDataSet.RefreshParams;
821 < end;
822 <
823 < procedure TIBDataLink.CheckBrowseMode;
824 < begin
825 <  if FDataSet.Active then
826 <    FDataSet.CheckBrowseMode;
827 < end;
828 <
829 < { TIBCustomDataSet }
830 <
831 < constructor TIBCustomDataSet.Create(AOwner: TComponent);
832 < begin
833 <  inherited Create(AOwner);
834 <  FIBLoaded := False;
835 <  CheckIBLoaded;
836 <  FIBLoaded := True;
837 <  FBase := TIBBase.Create(Self);
838 <  FCurrentRecord := -1;
839 <  FDeletedRecords := 0;
840 <  FUniDirectional := False;
841 <  FBufferChunks := BufferCacheSize;
842 <  FBlobStreamList := TList.Create;
843 <  FGeneratorField := TIBGenerator.Create(self);
844 <  FDataLink := TIBDataLink.Create(Self);
845 <  FQDelete := TIBSQL.Create(Self);
846 <  FQDelete.OnSQLChanging := SQLChanging;
847 <  FQDelete.GoToFirstRecordOnExecute := False;
848 <  FQInsert := TIBSQL.Create(Self);
849 <  FQInsert.OnSQLChanging := SQLChanging;
850 <  FQInsert.GoToFirstRecordOnExecute := False;
851 <  FQRefresh := TIBSQL.Create(Self);
852 <  FQRefresh.OnSQLChanging := SQLChanging;
853 <  FQRefresh.GoToFirstRecordOnExecute := False;
854 <  FQSelect := TIBSQL.Create(Self);
855 <  FQSelect.OnSQLChanging := SQLChanging;
856 <  FQSelect.GoToFirstRecordOnExecute := False;
857 <  FQModify := TIBSQL.Create(Self);
858 <  FQModify.OnSQLChanging := SQLChanging;
859 <  FQModify.GoToFirstRecordOnExecute := False;
860 <  FUpdateRecordTypes := [cusUnmodified, cusModified, cusInserted];
861 <  FParamCheck := True;
862 <  FForcedRefresh := False;
863 <  {Bookmark Size is Integer for IBX}
864 <  BookmarkSize := SizeOf(Integer);
865 <  FBase.BeforeDatabaseDisconnect := DoBeforeDatabaseDisconnect;
866 <  FBase.AfterDatabaseDisconnect := DoAfterDatabaseDisconnect;
867 <  FBase.OnDatabaseFree := DoDatabaseFree;
868 <  FBase.BeforeTransactionEnd := DoBeforeTransactionEnd;
869 <  FBase.AfterTransactionEnd := DoAfterTransactionEnd;
870 <  FBase.OnTransactionFree := DoTransactionFree;
871 <  if AOwner is TIBDatabase then
872 <    Database := TIBDatabase(AOwner)
873 <  else
874 <    if AOwner is TIBTransaction then
875 <      Transaction := TIBTransaction(AOwner);
876 < end;
877 <
878 < destructor TIBCustomDataSet.Destroy;
879 < begin
880 <  if Active then Active := false;
881 <  if FIBLoaded then
882 <  begin
883 <    if assigned(FGeneratorField) then FGeneratorField.Free;
884 <    FDataLink.Free;
885 <    FBase.Free;
886 <    ClearBlobCache;
887 <    FBlobStreamList.Free;
888 <    FreeMem(FBufferCache);
889 <    FBufferCache := nil;
890 <    FreeMem(FOldBufferCache);
891 <    FOldBufferCache := nil;
892 <    FCacheSize := 0;
893 <    FOldCacheSize := 0;
894 <    FMappedFieldPosition := nil;
895 <  end;
896 <  inherited Destroy;
897 < end;
898 <
899 < function TIBCustomDataSet.AdjustCurrentRecord(Buffer: Pointer; GetMode: TGetMode):
900 <                                             TGetResult;
901 < begin
902 <  while not IsVisible(Buffer) do
903 <  begin
904 <    if GetMode = gmPrior then
905 <    begin
906 <      Dec(FCurrentRecord);
907 <      if FCurrentRecord = -1 then
908 <      begin
909 <        result := grBOF;
910 <        exit;
911 <      end;
912 <      ReadRecordCache(FCurrentRecord, Buffer, False);
913 <    end
914 <    else begin
915 <      Inc(FCurrentRecord);
916 <      if (FCurrentRecord = FRecordCount) then
917 <      begin
918 <        if (not FQSelect.EOF) and (FQSelect.Next <> nil) then
919 <        begin
920 <          FetchCurrentRecordToBuffer(FQSelect, FCurrentRecord, Buffer);
921 <          Inc(FRecordCount);
922 <        end
923 <        else begin
924 <          result := grEOF;
925 <          exit;
926 <        end;
927 <      end
928 <      else
929 <        ReadRecordCache(FCurrentRecord, Buffer, False);
930 <    end;
931 <  end;
932 <  result := grOK;
933 < end;
934 <
935 < procedure TIBCustomDataSet.ApplyUpdates;
936 < var
937 <  {$IF FPC_FULLVERSION > 20602 }
938 <  CurBookmark: TBookmark;
939 <  {$ELSE}
940 <  CurBookmark: string;
941 <  {$ENDIF}
942 <  Buffer: PRecordData;
943 <  CurUpdateTypes: TIBUpdateRecordTypes;
944 <  UpdateAction: TIBUpdateAction;
945 <  UpdateKind: TUpdateKind;
946 <  bRecordsSkipped: Boolean;
947 <
948 <  procedure GetUpdateKind;
949 <  begin
950 <    case Buffer^.rdCachedUpdateStatus of
951 <      cusModified:
952 <        UpdateKind := ukModify;
953 <      cusInserted:
954 <        UpdateKind := ukInsert;
955 <      else
956 <        UpdateKind := ukDelete;
957 <    end;
958 <  end;
959 <
960 <  procedure ResetBufferUpdateStatus;
961 <  begin
962 <    case Buffer^.rdCachedUpdateStatus of
963 <      cusModified:
964 <      begin
965 <        PRecordData(Buffer)^.rdUpdateStatus := usUnmodified;
966 <        PRecordData(Buffer)^.rdCachedUpdateStatus := cusUnmodified;
967 <      end;
968 <      cusInserted:
969 <      begin
970 <        PRecordData(Buffer)^.rdUpdateStatus := usUnmodified;
971 <        PRecordData(Buffer)^.rdCachedUpdateStatus := cusUnmodified;
972 <      end;
973 <      cusDeleted:
974 <      begin
975 <        PRecordData(Buffer)^.rdUpdateStatus := usDeleted;
976 <        PRecordData(Buffer)^.rdCachedUpdateStatus := cusUnmodified;
977 <      end;
978 <    end;
979 <    WriteRecordCache(PRecordData(Buffer)^.rdRecordNumber, Pointer(Buffer));
980 <  end;
981 <
982 <  procedure UpdateUsingOnUpdateRecord;
983 <  begin
984 <    UpdateAction := uaFail;
985 <    try
986 <      FOnUpdateRecord(Self, UpdateKind, UpdateAction);
987 <    except
988 <      on E: Exception do
989 <      begin
990 <        if (E is EDatabaseError) and Assigned(FOnUpdateError) then
991 <          FOnUpdateError(Self, EIBError(E), UpdateKind, UpdateAction);
992 <        if UpdateAction = uaFail then
993 <            raise;
994 <      end;
995 <    end;
996 <  end;
997 <
998 <  procedure UpdateUsingUpdateObject;
999 <  begin
1000 <    try
1001 <      FUpdateObject.Apply(UpdateKind,PChar(Buffer));
1002 <      ResetBufferUpdateStatus;
1003 <    except
1004 <      on E: Exception do
1005 <        if (E is EDatabaseError) and Assigned(FOnUpdateError) then
1006 <          FOnUpdateError(Self, EIBError(E), UpdateKind, UpdateAction);
1007 <    end;
1008 <  end;
1009 <
1010 <  procedure UpdateUsingInternalquery;
1011 <  begin
1012 <    try
1013 <      case Buffer^.rdCachedUpdateStatus of
1014 <        cusModified:
1015 <          InternalPostRecord(FQModify, Buffer);
1016 <        cusInserted:
1017 <          InternalPostRecord(FQInsert, Buffer);
1018 <        cusDeleted:
1019 <          InternalDeleteRecord(FQDelete, Buffer);
1020 <      end;
1021 <    except
1022 <      on E: EIBError do begin
1023 <        UpdateAction := uaFail;
1024 <        if Assigned(FOnUpdateError) then
1025 <          FOnUpdateError(Self, E, UpdateKind, UpdateAction);
1026 <        case UpdateAction of
1027 <          uaFail: raise;
1028 <          uaAbort: SysUtils.Abort;
1029 <          uaSkip: bRecordsSkipped := True;
1030 <        end;
1031 <      end;
1032 <    end;
1033 <  end;
1034 <
1035 < begin
1036 <  if State in [dsEdit, dsInsert] then
1037 <    Post;
1038 <  FBase.CheckDatabase;
1039 <  FBase.CheckTransaction;
1040 <  DisableControls;
1041 <  CurBookmark := Bookmark;
1042 <  CurUpdateTypes := FUpdateRecordTypes;
1043 <  FUpdateRecordTypes := [cusModified, cusInserted, cusDeleted];
1044 <  try
1045 <    First;
1046 <    bRecordsSkipped := False;
1047 <    while not EOF do
1048 <    begin
1049 <      Buffer := PRecordData(GetActiveBuf);
1050 <      GetUpdateKind;
1051 <      UpdateAction := uaApply;
1052 <      if Assigned(FUpdateObject) or Assigned(FOnUpdateRecord) then
1053 <      begin
1054 <        if (Assigned(FOnUpdateRecord)) then
1055 <          UpdateUsingOnUpdateRecord
1056 <        else
1057 <          if Assigned(FUpdateObject) then
1058 <            UpdateUsingUpdateObject;
1059 <        case UpdateAction of
1060 <          uaFail:
1061 <            IBError(ibxeUserAbort, [nil]);
1062 <          uaAbort:
1063 <            SysUtils.Abort;
1064 <          uaApplied:
1065 <            ResetBufferUpdateStatus;
1066 <          uaSkip:
1067 <            bRecordsSkipped := True;
1068 <          uaRetry:
1069 <            Continue;
1070 <        end;
1071 <      end;
1072 <      if (not Assigned(FUpdateObject)) and (UpdateAction = UaApply) then
1073 <      begin
1074 <        UpdateUsingInternalquery;
1075 <        UpdateAction := uaApplied;
1076 <      end;
1077 <      Next;
1078 <    end;
1079 <    FUpdatesPending := bRecordsSkipped;
1080 <  finally
1081 <    FUpdateRecordTypes := CurUpdateTypes;
1082 <    Bookmark := CurBookmark;
1083 <    EnableControls;
1084 <  end;
1085 < end;
1086 <
1087 < procedure TIBCustomDataSet.InternalBatchInput(InputObject: TIBBatchInput);
1088 < begin
1089 <  FQSelect.BatchInput(InputObject);
1090 < end;
1091 <
1092 < procedure TIBCustomDataSet.InternalBatchOutput(OutputObject: TIBBatchOutput);
1093 < var
1094 <  Qry: TIBSQL;
1095 < begin
1096 <  Qry := TIBSQL.Create(Self);
1097 <  try
1098 <    Qry.Database := FBase.Database;
1099 <    Qry.Transaction := FBase.Transaction;
1100 <    Qry.SQL.Assign(FQSelect.SQL);
1101 <    Qry.BatchOutput(OutputObject);
1102 <  finally
1103 <    Qry.Free;
1104 <  end;
1105 < end;
1106 <
1107 < procedure TIBCustomDataSet.CancelUpdates;
1108 < var
1109 <  CurUpdateTypes: TIBUpdateRecordTypes;
1110 < begin
1111 <  if State in [dsEdit, dsInsert] then
1112 <    Post;
1113 <  if FCachedUpdates and FUpdatesPending then
1114 <  begin
1115 <    DisableControls;
1116 <    CurUpdateTypes := UpdateRecordTypes;
1117 <    UpdateRecordTypes := [cusModified, cusInserted, cusDeleted];
1118 <    try
1119 <      First;
1120 <      while not EOF do
1121 <      begin
1122 <        if UpdateStatus = usInserted then
1123 <          RevertRecord
1124 <        else
1125 <        begin
1126 <          RevertRecord;
1127 <          Next;
1128 <        end;
1129 <      end;
1130 <    finally
1131 <      UpdateRecordTypes := CurUpdateTypes;
1132 <      First;
1133 <      FUpdatesPending := False;
1134 <      EnableControls;
1135 <    end;
1136 <  end;
1137 < end;
1138 <
1139 < procedure TIBCustomDataSet.ActivateConnection;
1140 < begin
1141 <  if not Assigned(Database) then
1142 <    IBError(ibxeDatabaseNotAssigned, [nil]);
1143 <  if not Assigned(Transaction) then
1144 <    IBError(ibxeTransactionNotAssigned, [nil]);
1145 <  if not Database.Connected then Database.Open;
1146 < end;
1147 <
1148 < function TIBCustomDataSet.ActivateTransaction: Boolean;
1149 < begin
1150 <  Result := False;
1151 <  if not Assigned(Transaction) then
1152 <    IBError(ibxeTransactionNotAssigned, [nil]);
1153 <  if not Transaction.Active then
1154 <  begin
1155 <    Result := True;
1156 <    Transaction.StartTransaction;
1157 <    FDidActivate := True;
1158 <  end;
1159 < end;
1160 <
1161 < procedure TIBCustomDataSet.DeactivateTransaction;
1162 < var
1163 <  i: Integer;
1164 < begin
1165 <  if not Assigned(Transaction) then
1166 <    IBError(ibxeTransactionNotAssigned, [nil]);
1167 <  with Transaction do
1168 <  begin
1169 <    for i := 0 to SQLObjectCount - 1 do
1170 <    begin
1171 <      if (SQLObjects[i] <> nil) and ((SQLObjects[i]).owner is TDataSet) then
1172 <      begin
1173 <        if TDataSet(SQLObjects[i].owner).Active then
1174 <        begin
1175 <          FDidActivate := False;
1176 <          exit;
1177 <        end;
1178 <      end;
1179 <    end;
1180 <  end;
1181 <  FInternalPrepared := False;
1182 <  if Transaction.InTransaction then
1183 <    Transaction.Commit;
1184 <  FDidActivate := False;
1185 < end;
1186 <
1187 < procedure TIBCustomDataSet.CheckDatasetClosed;
1188 < begin
1189 <  if FOpen then
1190 <    IBError(ibxeDatasetOpen, [nil]);
1191 < end;
1192 <
1193 < procedure TIBCustomDataSet.CheckDatasetOpen;
1194 < begin
1195 <  if not FOpen then
1196 <    IBError(ibxeDatasetClosed, [nil]);
1197 < end;
1198 <
1199 < procedure TIBCustomDataSet.CheckNotUniDirectional;
1200 < begin
1201 <  if UniDirectional then
1202 <    IBError(ibxeDataSetUniDirectional, [nil]);
1203 < end;
1204 <
1205 < procedure TIBCustomDataSet.AdjustRecordOnInsert(Buffer: Pointer);
1206 < begin
1207 <  with PRecordData(Buffer)^ do
1208 <    if (State = dsInsert) and (not Modified) then
1209 <    begin
1210 <      rdRecordNumber := FRecordCount;
1211 <      FCurrentRecord := FRecordCount;
1212 <    end;
1213 < end;
1214 <
1215 < function TIBCustomDataSet.CanEdit: Boolean;
1216 < var
1217 <  Buff: PRecordData;
1218 < begin
1219 <  Buff := PRecordData(GetActiveBuf);
1220 <  result := (FQModify.SQL.Text <> '') or
1221 <    (Assigned(FUpdateObject) and (FUpdateObject.GetSQL(ukModify).Text <> '')) or
1222 <    ((Buff <> nil) and (Buff^.rdCachedUpdateStatus = cusInserted) and
1223 <      (FCachedUpdates));
1224 < end;
1225 <
1226 < function TIBCustomDataSet.CanInsert: Boolean;
1227 < begin
1228 <  result := (FQInsert.SQL.Text <> '') or
1229 <    (Assigned(FUpdateObject) and (FUpdateObject.GetSQL(ukInsert).Text <> ''));
1230 < end;
1231 <
1232 < function TIBCustomDataSet.CanDelete: Boolean;
1233 < begin
1234 <  if (FQDelete.SQL.Text <> '') or
1235 <    (Assigned(FUpdateObject) and (FUpdateObject.GetSQL(ukDelete).Text <> '')) then
1236 <    result := True
1237 <  else
1238 <    result := False;
1239 < end;
1240 <
1241 < function TIBCustomDataSet.CanRefresh: Boolean;
1242 < begin
1243 <  result := (FQRefresh.SQL.Text <> '') or
1244 <    (Assigned(FUpdateObject) and (FUpdateObject.RefreshSQL.Text <> ''));
1245 < end;
1246 <
1247 < procedure TIBCustomDataSet.CheckEditState;
1248 < begin
1249 <  case State of
1250 <    { Check all the wsEditMode types }
1251 <    dsEdit, dsInsert, dsSetKey, dsCalcFields, dsFilter,
1252 <    dsNewValue, dsInternalCalc :
1253 <    begin
1254 <      if (State in [dsEdit]) and (not CanEdit) then
1255 <        IBError(ibxeCannotUpdate, [nil]);
1256 <      if (State in [dsInsert]) and (not CanInsert) then
1257 <        IBError(ibxeCannotInsert, [nil]);
1258 <    end;
1259 <  else
1260 <    IBError(ibxeNotEditing, [])
1261 <  end;
1262 < end;
1263 <
1264 < procedure TIBCustomDataSet.ClearBlobCache;
1265 < var
1266 <  i: Integer;
1267 < begin
1268 <  for i := 0 to FBlobStreamList.Count - 1 do
1269 <  begin
1270 <    TIBBlobStream(FBlobStreamList[i]).Free;
1271 <    FBlobStreamList[i] := nil;
1272 <  end;
1273 <  FBlobStreamList.Pack;
1274 < end;
1275 <
1276 < procedure TIBCustomDataSet.CopyRecordBuffer(Source, Dest: Pointer);
1277 < begin
1278 <  Move(Source^, Dest^, FRecordBufferSize);
1279 < end;
1280 <
1281 < procedure TIBCustomDataSet.DoBeforeDatabaseDisconnect(Sender: TObject);
1282 < begin
1283 <  if Active then
1284 <    Active := False;
1285 <  FInternalPrepared := False;
1286 <  if Assigned(FBeforeDatabaseDisconnect) then
1287 <    FBeforeDatabaseDisconnect(Sender);
1288 < end;
1289 <
1290 < procedure TIBCustomDataSet.DoAfterDatabaseDisconnect(Sender: TObject);
1291 < begin
1292 <  if Assigned(FAfterDatabaseDisconnect) then
1293 <    FAfterDatabaseDisconnect(Sender);
1294 < end;
1295 <
1296 < procedure TIBCustomDataSet.DoDatabaseFree(Sender: TObject);
1297 < begin
1298 <  if Assigned(FDatabaseFree) then
1299 <    FDatabaseFree(Sender);
1300 < end;
1301 <
1302 < procedure TIBCustomDataSet.DoBeforeTransactionEnd(Sender: TObject);
1303 < begin
1304 <  if Active then
1305 <    Active := False;
1306 <  if FQSelect <> nil then
1307 <    FQSelect.FreeHandle;
1308 <  if FQDelete <> nil then
1309 <    FQDelete.FreeHandle;
1310 <  if FQInsert <> nil then
1311 <    FQInsert.FreeHandle;
1312 <  if FQModify <> nil then
1313 <    FQModify.FreeHandle;
1314 <  if FQRefresh <> nil then
1315 <    FQRefresh.FreeHandle;
1316 <  if Assigned(FBeforeTransactionEnd) then
1317 <    FBeforeTransactionEnd(Sender);
1318 < end;
1319 <
1320 < procedure TIBCustomDataSet.DoAfterTransactionEnd(Sender: TObject);
1321 < begin
1322 <  if Assigned(FAfterTransactionEnd) then
1323 <    FAfterTransactionEnd(Sender);
1324 < end;
1325 <
1326 < procedure TIBCustomDataSet.DoTransactionFree(Sender: TObject);
1327 < begin
1328 <  if Assigned(FTransactionFree) then
1329 <    FTransactionFree(Sender);
1330 < end;
1331 <
1332 < { Read the record from FQSelect.Current into the record buffer
1333 <  Then write the buffer to in memory cache }
1334 < procedure TIBCustomDataSet.FetchCurrentRecordToBuffer(Qry: TIBSQL;
1335 <  RecordNumber: Integer; Buffer: PChar);
1336 < var
1337 <  p: PRecordData;
1338 <  pbd: PBlobDataArray;
1339 <  i, j: Integer;
1340 <  LocalData: Pointer;
1341 <  LocalDate, LocalDouble: Double;
1342 <  LocalInt: Integer;
1343 <  LocalInt64: Int64;
1344 <  LocalCurrency: Currency;
1345 <  FieldsLoaded: Integer;
1346 <  temp: TIBXSQLVAR;
1347 < begin
1348 <  p := PRecordData(Buffer);
1349 <  { Make sure blob cache is empty }
1350 <  pbd := PBlobDataArray(Buffer + FBlobCacheOffset);
1351 <  if RecordNumber > -1 then
1352 <    for i := 0 to BlobFieldCount - 1 do
1353 <      pbd^[i] := nil;
1354 <  { Get record information }
1355 <  p^.rdBookmarkFlag := bfCurrent;
1356 <  p^.rdFieldCount := Qry.Current.Count;
1357 <  p^.rdRecordNumber := RecordNumber;
1358 <  p^.rdUpdateStatus := usUnmodified;
1359 <  p^.rdCachedUpdateStatus := cusUnmodified;
1360 <  p^.rdSavedOffset := $FFFFFFFF;
1361 <
1362 <  { Load up the fields }
1363 <  FieldsLoaded := FQSelect.Current.Count;
1364 <  j := 1;
1365 <  for i := 0 to Qry.Current.Count - 1 do
1366 <  begin
1367 <    if (Qry = FQSelect) then
1368 <      j := i + 1
1369 <    else begin
1370 <      if FieldsLoaded = 0 then
1371 <        break;
1372 <      j := FQSelect.FieldIndex[Qry.Current[i].Name] + 1;
1373 <      if j < 1 then
1374 <        continue
1375 <      else
1376 <        Dec(FieldsLoaded);
1377 <    end;
1378 <    with FQSelect.Current[j - 1].Data^ do
1379 <      if aliasname = 'IBX_INTERNAL_DBKEY' then {do not localize}
1380 <      begin
1381 <        if sqllen <= 8 then
1382 <          p^.rdDBKey := PIBDBKEY(Qry.Current[i].AsPointer)^;
1383 <        continue;
1384 <      end;
1385 <    if j > 0 then with p^ do
1386 <    begin
1387 <      rdFields[j].fdDataType :=
1388 <        Qry.Current[i].Data^.sqltype and (not 1);
1389 <      rdFields[j].fdDataScale :=
1390 <        Qry.Current[i].Data^.sqlscale;
1391 <      rdFields[j].fdNullable :=
1392 <        (Qry.Current[i].Data^.sqltype and 1 = 1);
1393 <      rdFields[j].fdIsNull :=
1394 <        (rdFields[j].fdNullable and (Qry.Current[i].Data^.sqlind^ = -1));
1395 <      LocalData := Qry.Current[i].Data^.sqldata;
1396 <      case rdFields[j].fdDataType of
1397 <        SQL_TIMESTAMP:
1398 <        begin
1399 <          rdFields[j].fdDataSize := SizeOf(TDateTime);
1400 <          if RecordNumber >= 0 then
1401 <            LocalDate := TimeStampToMSecs(DateTimeToTimeStamp(Qry.Current[i].AsDateTime));
1402 <          LocalData := PChar(@LocalDate);
1403 <        end;
1404 <        SQL_TYPE_DATE:
1405 <        begin
1406 <          rdFields[j].fdDataSize := SizeOf(TDateTime);
1407 <          if RecordNumber >= 0 then
1408 <            LocalInt := DateTimeToTimeStamp(Qry.Current[i].AsDateTime).Date;
1409 <          LocalData := PChar(@LocalInt);
1410 <        end;
1411 <        SQL_TYPE_TIME:
1412 <        begin
1413 <          rdFields[j].fdDataSize := SizeOf(TDateTime);
1414 <          if RecordNumber >= 0 then
1415 <            LocalInt := DateTimeToTimeStamp(Qry.Current[i].AsDateTime).Time;
1416 <          LocalData := PChar(@LocalInt);
1417 <        end;
1418 <        SQL_SHORT, SQL_LONG:
1419 <        begin
1420 <          if (rdFields[j].fdDataScale = 0) then
1421 <          begin
1422 <            rdFields[j].fdDataSize := SizeOf(Integer);
1423 <            if RecordNumber >= 0 then
1424 <              LocalInt := Qry.Current[i].AsLong;
1425 <            LocalData := PChar(@LocalInt);
1426 <          end
1427 <          else if (rdFields[j].fdDataScale >= (-4)) then
1428 <               begin
1429 <                 rdFields[j].fdDataSize := SizeOf(Currency);
1430 <                 if RecordNumber >= 0 then
1431 <                   LocalCurrency := Qry.Current[i].AsCurrency;
1432 <                 LocalData := PChar(@LocalCurrency);
1433 <               end
1434 <               else begin
1435 <                 rdFields[j].fdDataSize := SizeOf(Double);
1436 <                 if RecordNumber >= 0 then
1437 <                   LocalDouble := Qry.Current[i].AsDouble;
1438 <                LocalData := PChar(@LocalDouble);
1439 <              end;
1440 <        end;
1441 <        SQL_INT64:
1442 <        begin
1443 <          if (rdFields[j].fdDataScale = 0) then
1444 <          begin
1445 <            rdFields[j].fdDataSize := SizeOf(Int64);
1446 <            if RecordNumber >= 0 then
1447 <              LocalInt64 := Qry.Current[i].AsInt64;
1448 <            LocalData := PChar(@LocalInt64);
1449 <          end
1450 <          else if (rdFields[j].fdDataScale >= (-4)) then
1451 <               begin
1452 <                 rdFields[j].fdDataSize := SizeOf(Currency);
1453 <                 if RecordNumber >= 0 then
1454 <                   LocalCurrency := Qry.Current[i].AsCurrency;
1455 <                   LocalData := PChar(@LocalCurrency);
1456 <               end
1457 <               else begin
1458 <                  rdFields[j].fdDataSize := SizeOf(Double);
1459 <                  if RecordNumber >= 0 then
1460 <                    LocalDouble := Qry.Current[i].AsDouble;
1461 <                  LocalData := PChar(@LocalDouble);
1462 <               end
1463 <        end;
1464 <        SQL_DOUBLE, SQL_FLOAT, SQL_D_FLOAT:
1465 <        begin
1466 <          rdFields[j].fdDataSize := SizeOf(Double);
1467 <          if RecordNumber >= 0 then
1468 <            LocalDouble := Qry.Current[i].AsDouble;
1469 <          LocalData := PChar(@LocalDouble);
1470 <        end;
1471 <        SQL_VARYING:
1472 <        begin
1473 <          rdFields[j].fdDataSize := Qry.Current[i].Data^.sqllen;
1474 <          rdFields[j].fdDataLength := isc_vax_integer(Qry.Current[i].Data^.sqldata, 2);
1475 <          if RecordNumber >= 0 then
1476 <          begin
1477 <            if (rdFields[j].fdDataLength = 0) then
1478 <              LocalData := nil
1479 <            else
1480 <            begin
1481 <              temp :=  Qry.Current[i];
1482 <              LocalData := @temp.Data^.sqldata[2];
1483 < (*              LocalData := @Qry.Current[i].Data^.sqldata[2];*)
1484 <            end;
1485 <          end;
1486 <        end;
1487 <        else { SQL_TEXT, SQL_BLOB, SQL_ARRAY, SQL_QUAD }
1488 <        begin
1489 <          rdFields[j].fdDataSize := Qry.Current[i].Data^.sqllen;
1490 <          if (rdFields[j].fdDataType = SQL_TEXT) then
1491 <            rdFields[j].fdDataLength := rdFields[j].fdDataSize;
1492 <        end;
1493 <      end;
1494 <      if RecordNumber < 0 then
1495 <      begin
1496 <        rdFields[j].fdIsNull := True;
1497 <        rdFields[j].fdDataOfs := FRecordSize;
1498 <        Inc(FRecordSize, rdFields[j].fdDataSize);
1499 <      end
1500 <      else begin
1501 <        if rdFields[j].fdDataType = SQL_VARYING then
1502 <        begin
1503 <          if LocalData <> nil then
1504 <            Move(LocalData^, Buffer[rdFields[j].fdDataOfs], rdFields[j].fdDataLength)
1505 <        end
1506 <        else
1507 <          Move(LocalData^, Buffer[rdFields[j].fdDataOfs], rdFields[j].fdDataSize)
1508 <      end;
1509 <    end;
1510 <  end;
1511 <  WriteRecordCache(RecordNumber, PChar(p));
1512 < end;
1513 <
1514 < function TIBCustomDataSet.GetActiveBuf: PChar;
1515 < begin
1516 <  case State of
1517 <    dsBrowse:
1518 <      if IsEmpty then
1519 <        result := nil
1520 <      else
1521 <        result := ActiveBuffer;
1522 <    dsEdit, dsInsert:
1523 <      result := ActiveBuffer;
1524 <    dsCalcFields:
1525 <      result := CalcBuffer;
1526 <    dsFilter:
1527 <      result := FFilterBuffer;
1528 <    dsNewValue:
1529 <      result := ActiveBuffer;
1530 <    dsOldValue:
1531 <      if (PRecordData(ActiveBuffer)^.rdRecordNumber =
1532 <        PRecordData(FOldBuffer)^.rdRecordNumber) then
1533 <        result := FOldBuffer
1534 <      else
1535 <        result := ActiveBuffer;
1536 <  else if not FOpen then
1537 <    result := nil
1538 <  else
1539 <    result := ActiveBuffer;
1540 <  end;
1541 < end;
1542 <
1543 < function TIBCustomDataSet.CachedUpdateStatus: TCachedUpdateStatus;
1544 < begin
1545 <  if Active then
1546 <    result := PRecordData(GetActiveBuf)^.rdCachedUpdateStatus
1547 <  else
1548 <    result := cusUnmodified;
1549 < end;
1550 <
1551 < function TIBCustomDataSet.GetDatabase: TIBDatabase;
1552 < begin
1553 <  result := FBase.Database;
1554 < end;
1555 <
1556 < function TIBCustomDataSet.GetDBHandle: PISC_DB_HANDLE;
1557 < begin
1558 <  result := FBase.DBHandle;
1559 < end;
1560 <
1561 < function TIBCustomDataSet.GetDeleteSQL: TStrings;
1562 < begin
1563 <  result := FQDelete.SQL;
1564 < end;
1565 <
1566 < function TIBCustomDataSet.GetInsertSQL: TStrings;
1567 < begin
1568 <  result := FQInsert.SQL;
1569 < end;
1570 <
1571 < function TIBCustomDataSet.GetSQLParams: TIBXSQLDA;
1572 < begin
1573 <  if not FInternalPrepared then
1574 <    InternalPrepare;
1575 <  result := FQSelect.Params;
1576 < end;
1577 <
1578 < function TIBCustomDataSet.GetRefreshSQL: TStrings;
1579 < begin
1580 <  result := FQRefresh.SQL;
1581 < end;
1582 <
1583 < function TIBCustomDataSet.GetSelectSQL: TStrings;
1584 < begin
1585 <  result := FQSelect.SQL;
1586 < end;
1587 <
1588 < function TIBCustomDataSet.GetStatementType: TIBSQLTypes;
1589 < begin
1590 <  result := FQSelect.SQLType;
1591 < end;
1592 <
1593 < function TIBCustomDataSet.GetModifySQL: TStrings;
1594 < begin
1595 <  result := FQModify.SQL;
1596 < end;
1597 <
1598 < function TIBCustomDataSet.GetTransaction: TIBTransaction;
1599 < begin
1600 <  result := FBase.Transaction;
1601 < end;
1602 <
1603 < function TIBCustomDataSet.GetTRHandle: PISC_TR_HANDLE;
1604 < begin
1605 <  result := FBase.TRHandle;
1606 < end;
1607 <
1608 < procedure TIBCustomDataSet.InternalDeleteRecord(Qry: TIBSQL; Buff: Pointer);
1609 < begin
1610 <  if (Assigned(FUpdateObject) and (FUpdateObject.GetSQL(ukDelete).Text <> '')) then
1611 <    FUpdateObject.Apply(ukDelete,Buff)
1612 <  else
1613 <  begin
1614 <    SetInternalSQLParams(FQDelete, Buff);
1615 <    FQDelete.ExecQuery;
1616 <  end;
1617 <  with PRecordData(Buff)^ do
1618 <  begin
1619 <    rdUpdateStatus := usDeleted;
1620 <    rdCachedUpdateStatus := cusUnmodified;
1621 <  end;
1622 <  WriteRecordCache(PRecordData(Buff)^.rdRecordNumber, Buff);
1623 < end;
1624 <
1625 < function TIBCustomDataSet.InternalLocate(const KeyFields: string;
1626 <  const KeyValues: Variant; Options: TLocateOptions): Boolean;
1627 < var
1628 <  keyFieldList: TList;
1629 <  {$IF FPC_FULLVERSION >  20602 }
1630 <  CurBookmark: TBookmark;
1631 <  {$ELSE}
1632 <  CurBookmark: string;
1633 <  {$ENDIF}
1634 <  fieldValue: Variant;
1635 <  lookupValues: array of variant;
1636 <  i, fieldCount: Integer;
1637 <  fieldValueAsString: string;
1638 <  lookupValueAsString: string;
1639 < begin
1640 <  keyFieldList := TList.Create;
1641 <  try
1642 <    GetFieldList(keyFieldList, KeyFields);
1643 <    fieldCount := keyFieldList.Count;
1644 <    CurBookmark := Bookmark;
1645 <    result := false;
1646 <    SetLength(lookupValues, fieldCount);
1647 <    if not EOF then
1648 <    begin
1649 <      for i := 0 to fieldCount - 1 do  {expand key values into lookupValues array}
1650 <      begin
1651 <        if VarIsArray(KeyValues) then
1652 <          lookupValues[i] := KeyValues[i]
1653 <        else
1654 <        if i > 0 then
1655 <          lookupValues[i] := NULL
1656 <        else
1657 <          lookupValues[0] := KeyValues;
1658 <
1659 <        {convert to upper case is case insensitive search}
1660 <        if (TField(keyFieldList[i]).DataType = ftString) and
1661 <           not VarIsNull(lookupValues[i]) and (loCaseInsensitive in Options) then
1662 <            lookupValues[i] := UpperCase(lookupValues[i]);
1663 <      end;
1664 <    end;
1665 <    while not result and not EOF do   {search for a matching record}
1666 <    begin
1667 <      i := 0;
1668 <      result := true;
1669 <      while result and (i < fieldCount) do
1670 <      {see if all of the key fields matches}
1671 <      begin
1672 <        fieldValue := TField(keyFieldList[i]).Value;
1673 <        result := not (VarIsNull(fieldValue) xor VarIsNull(lookupValues[i]));
1674 <        if result and not VarIsNull(fieldValue) then
1675 <        begin
1676 <          try
1677 <            if TField(keyFieldList[i]).DataType = ftString then
1678 <            begin
1679 <              {strings need special handling because of the locate options that
1680 <               apply to them}
1681 <              fieldValueAsString := TField(keyFieldList[i]).AsString;
1682 <              lookupValueAsString := lookupValues[i];
1683 <              if (loCaseInsensitive in Options) then
1684 <                fieldValueAsString := UpperCase(fieldValueAsString);
1685 <
1686 <              if (loPartialKey in Options) then
1687 <                result := result and (Pos(lookupValueAsString, fieldValueAsString) = 1)
1688 <              else
1689 <                result := result and (fieldValueAsString = lookupValueAsString);
1690 <            end
1691 <            else
1692 <              result := result and (lookupValues[i] =
1693 <                             VarAsType(fieldValue, VarType(lookupValues[i])));
1694 <          except on EVariantError do
1695 <            result := False;
1696 <          end;
1697 <        end;
1698 <        Inc(i);
1699 <      end;
1700 <      if not result then
1701 <          Next;
1702 <    end;
1703 <    if not result then
1704 <      Bookmark := CurBookmark
1705 <    else
1706 <      CursorPosChanged;
1707 <  finally
1708 <    keyFieldList.Free;
1709 <    SetLength(lookupValues,0)
1710 <  end;
1711 < end;
1712 <
1713 < procedure TIBCustomDataSet.InternalPostRecord(Qry: TIBSQL; Buff: Pointer);
1714 < var
1715 <  i, j, k: Integer;
1716 <  pbd: PBlobDataArray;
1717 < begin
1718 <  pbd := PBlobDataArray(PChar(Buff) + FBlobCacheOffset);
1719 <  j := 0;
1720 <  for i := 0 to FieldCount - 1 do
1721 <    if Fields[i].IsBlob then
1722 <    begin
1723 <      k := FMappedFieldPosition[Fields[i].FieldNo -1];
1724 <      if pbd^[j] <> nil then
1725 <      begin
1726 <        pbd^[j].Finalize;
1727 <        PISC_QUAD(
1728 <          PChar(Buff) + PRecordData(Buff)^.rdFields[k].fdDataOfs)^ :=
1729 <          pbd^[j].BlobID;
1730 <        PRecordData(Buff)^.rdFields[k].fdIsNull := pbd^[j].Size = 0;
1731 <      end;
1732 <      Inc(j);
1733 <    end;
1734 <  if Assigned(FUpdateObject) then
1735 <  begin
1736 <    if (Qry = FQDelete) then
1737 <      FUpdateObject.Apply(ukDelete,Buff)
1738 <    else if (Qry = FQInsert) then
1739 <      FUpdateObject.Apply(ukInsert,Buff)
1740 <    else
1741 <      FUpdateObject.Apply(ukModify,Buff);
1742 <  end
1743 <  else begin
1744 <    SetInternalSQLParams(Qry, Buff);
1745 <    Qry.ExecQuery;
1746 <  end;
1747 <  PRecordData(Buff)^.rdUpdateStatus := usUnmodified;
1748 <  PRecordData(Buff)^.rdCachedUpdateStatus := cusUnmodified;
1749 <  SetModified(False);
1750 <  WriteRecordCache(PRecordData(Buff)^.rdRecordNumber, Buff);
1751 <  if (FForcedRefresh or FNeedsRefresh) and CanRefresh then
1752 <    InternalRefreshRow;
1753 < end;
1754 <
1755 < procedure TIBCustomDataSet.InternalRefreshRow;
1756 < var
1757 <  Buff: PChar;
1758 <  SetCursor: Boolean;
1759 <  ofs: DWORD;
1760 <  Qry: TIBSQL;
1761 < begin
1762 <  SetCursor := (GetCurrentThreadID = MainThreadID) and (Screen.Cursor = crDefault);
1763 <  if SetCursor then
1764 <    Screen.Cursor := crHourGlass;
1765 <  try
1766 <    Buff := GetActiveBuf;
1767 <    if CanRefresh then
1768 <    begin
1769 <      if Buff <> nil then
1770 <      begin
1771 <        if (Assigned(FUpdateObject) and (FUpdateObject.RefreshSQL.Text <> '')) then
1772 <        begin
1773 <          Qry := TIBSQL.Create(self);
1774 <          Qry.Database := Database;
1775 <          Qry.Transaction := Transaction;
1776 <          Qry.GoToFirstRecordOnExecute := False;
1777 <          Qry.SQL.Text := FUpdateObject.RefreshSQL.Text;
1778 <        end
1779 <        else
1780 <          Qry := FQRefresh;
1781 <        SetInternalSQLParams(Qry, Buff);
1782 <        Qry.ExecQuery;
1783 <        try
1784 <          if (Qry.SQLType = SQLExecProcedure) or
1785 <             (Qry.Next <> nil) then
1786 <          begin
1787 <            ofs := PRecordData(Buff)^.rdSavedOffset;
1788 <            FetchCurrentRecordToBuffer(Qry,
1789 <                                       PRecordData(Buff)^.rdRecordNumber,
1790 <                                       Buff);
1791 <            if FCachedUpdates and (ofs <> $FFFFFFFF) then
1792 <            begin
1793 <              PRecordData(Buff)^.rdSavedOffset := ofs;
1794 <              WriteRecordCache(PRecordData(Buff)^.rdRecordNumber, Buff);
1795 <              SaveOldBuffer(Buff);
1796 <            end;
1797 <          end;
1798 <        finally
1799 <          Qry.Close;
1800 <        end;
1801 <        if Qry <> FQRefresh then
1802 <          Qry.Free;
1803 <      end
1804 <    end
1805 <    else
1806 <      IBError(ibxeCannotRefresh, [nil]);
1807 <  finally
1808 <    if SetCursor and (Screen.Cursor = crHourGlass) then
1809 <      Screen.Cursor := crDefault;
1810 <  end;
1811 < end;
1812 <
1813 < procedure TIBCustomDataSet.InternalRevertRecord(RecordNumber: Integer);
1814 < var
1815 <  NewBuffer, OldBuffer: PRecordData;
1816 <
1817 < begin
1818 <  NewBuffer := nil;
1819 <  OldBuffer := nil;
1820 <  NewBuffer := PRecordData(AllocRecordBuffer);
1821 <  OldBuffer := PRecordData(AllocRecordBuffer);
1822 <  try
1823 <    ReadRecordCache(RecordNumber, PChar(NewBuffer), False);
1824 <    ReadRecordCache(RecordNumber, PChar(OldBuffer), True);
1825 <    case NewBuffer^.rdCachedUpdateStatus of
1826 <      cusInserted:
1827 <      begin
1828 <        NewBuffer^.rdCachedUpdateStatus := cusUninserted;
1829 <        Inc(FDeletedRecords);
1830 <      end;
1831 <      cusModified,
1832 <      cusDeleted:
1833 <      begin
1834 <        if (NewBuffer^.rdCachedUpdateStatus = cusDeleted) then
1835 <          Dec(FDeletedRecords);
1836 <        CopyRecordBuffer(OldBuffer, NewBuffer);
1837 <      end;
1838 <    end;
1839 <
1840 <    if State in dsEditModes then
1841 <      Cancel;
1842 <
1843 <    WriteRecordCache(RecordNumber, PChar(NewBuffer));
1844 <
1845 <    if (NewBuffer^.rdCachedUpdateStatus = cusUninserted ) then
1846 <      ReSync([]);
1847 <  finally
1848 <    FreeRecordBuffer(PChar(NewBuffer));
1849 <    FreeRecordBuffer(PChar(OldBuffer));
1850 <  end;
1851 < end;
1852 <
1853 < { A visible record is one that is not truly deleted,
1854 <  and it is also listed in the FUpdateRecordTypes set }
1855 <
1856 < function TIBCustomDataSet.IsVisible(Buffer: PChar): Boolean;
1857 < begin
1858 <  result := True;
1859 <  if not (State = dsOldValue) then
1860 <    result :=
1861 <      (PRecordData(Buffer)^.rdCachedUpdateStatus in FUpdateRecordTypes) and
1862 <      (not ((PRecordData(Buffer)^.rdCachedUpdateStatus = cusUnmodified) and
1863 <        (PRecordData(Buffer)^.rdUpdateStatus = usDeleted)));
1864 < end;
1865 <
1866 <
1867 < function TIBCustomDataSet.LocateNext(const KeyFields: string;
1868 <  const KeyValues: Variant; Options: TLocateOptions): Boolean;
1869 < begin
1870 <  DisableControls;
1871 <  try
1872 <    result := InternalLocate(KeyFields, KeyValues, Options);
1873 <  finally
1874 <    EnableControls;
1875 <  end;
1876 < end;
1877 <
1878 < procedure TIBCustomDataSet.InternalPrepare;
1879 < var
1880 <  SetCursor: Boolean;
1881 <  DidActivate: Boolean;
1882 < begin
1883 <  if FInternalPrepared then
1884 <    Exit;
1885 <  DidActivate := False;
1886 <  SetCursor := (GetCurrentThreadID = MainThreadID) and (Screen.Cursor = crDefault);
1887 <  if SetCursor then
1888 <    Screen.Cursor := crHourGlass;
1889 <  try
1890 <    ActivateConnection;
1891 <    DidActivate := ActivateTransaction;
1892 <    FBase.CheckDatabase;
1893 <    FBase.CheckTransaction;
1894 <    if FQSelect.SQL.Text <> '' then
1895 <    begin
1896 <      if not FQSelect.Prepared then
1897 <      begin
1898 <        FQSelect.ParamCheck := ParamCheck;
1899 <        FQSelect.Prepare;
1900 <      end;
1901 <      if (Trim(FQDelete.SQL.Text) <> '') and (not FQDelete.Prepared) then
1902 <        FQDelete.Prepare;
1903 <      if (Trim(FQInsert.SQL.Text) <> '') and (not FQInsert.Prepared) then
1904 <        FQInsert.Prepare;
1905 <      if (Trim(FQRefresh.SQL.Text) <> '') and (not FQRefresh.Prepared) then
1906 <        FQRefresh.Prepare;
1907 <      if (Trim(FQModify.SQL.Text) <> '') and (not FQModify.Prepared) then
1908 <        FQModify.Prepare;
1909 <      FInternalPrepared := True;
1910 <      InternalInitFieldDefs;
1911 <    end else
1912 <      IBError(ibxeEmptyQuery, [nil]);
1913 <  finally
1914 <    if DidActivate then
1915 <      DeactivateTransaction;
1916 <    if SetCursor and (Screen.Cursor = crHourGlass) then
1917 <      Screen.Cursor := crDefault;
1918 <  end;
1919 < end;
1920 <
1921 < procedure TIBCustomDataSet.RecordModified(Value: Boolean);
1922 < begin
1923 <  SetModified(Value);
1924 < end;
1925 <
1926 < procedure TIBCustomDataSet.RevertRecord;
1927 < var
1928 <  Buff: PRecordData;
1929 < begin
1930 <  if FCachedUpdates and FUpdatesPending then
1931 <  begin
1932 <    Buff := PRecordData(GetActiveBuf);
1933 <    InternalRevertRecord(Buff^.rdRecordNumber);
1934 <    ReadRecordCache(Buff^.rdRecordNumber, PChar(Buff), False);
1935 <    DataEvent(deRecordChange, 0);
1936 <  end;
1937 < end;
1938 <
1939 < procedure TIBCustomDataSet.SaveOldBuffer(Buffer: PChar);
1940 < var
1941 <  OldBuffer: Pointer;
1942 <  procedure CopyOldBuffer;
1943 <  begin
1944 <    CopyRecordBuffer(Buffer, OldBuffer);
1945 <    if BlobFieldCount > 0 then
1946 <      FillChar(PChar(OldBuffer)[FBlobCacheOffset], BlobFieldCount * SizeOf(TIBBlobStream),
1947 <               0);
1948 <  end;
1949 <
1950 < begin
1951 <  if (Buffer <> nil) and (PRecordData(Buffer)^.rdRecordNumber >= 0) then
1952 <  begin
1953 <    OldBuffer := AllocRecordBuffer;
1954 <    try
1955 <      if (PRecordData(Buffer)^.rdSavedOffset = $FFFFFFFF) then
1956 <      begin
1957 <        PRecordData(Buffer)^.rdSavedOffset := AdjustPosition(FOldBufferCache, 0,
1958 <                                                             FILE_END);
1959 <        CopyOldBuffer;
1960 <          WriteCache(FOldBufferCache, 0, FILE_CURRENT, OldBuffer);
1961 <          WriteCache(FBufferCache, PRecordData(Buffer)^.rdRecordNumber * FRecordBufferSize,
1962 <                     FILE_BEGIN, Buffer);
1963 <      end
1964 <      else begin
1965 <        CopyOldBuffer;
1966 <        WriteCache(FOldBufferCache, PRecordData(Buffer)^.rdSavedOffset, FILE_BEGIN,
1967 <                   OldBuffer);
1968 <      end;
1969 <    finally
1970 <      FreeRecordBuffer(PChar(OldBuffer));
1971 <    end;
1972 <  end;
1973 < end;
1974 <
1975 < procedure TIBCustomDataSet.SetBufferChunks(Value: Integer);
1976 < begin
1977 <  if (Value <= 0) then
1978 <    FBufferChunks := BufferCacheSize
1979 <  else
1980 <    FBufferChunks := Value;
1981 < end;
1982 <
1983 < procedure TIBCustomDataSet.SetDatabase(Value: TIBDatabase);
1984 < begin
1985 <  if (FBase.Database <> Value) then
1986 <  begin
1987 <    CheckDatasetClosed;
1988 <    FBase.Database := Value;
1989 <    FQDelete.Database := Value;
1990 <    FQInsert.Database := Value;
1991 <    FQRefresh.Database := Value;
1992 <    FQSelect.Database := Value;
1993 <    FQModify.Database := Value;
1994 <  end;
1995 < end;
1996 <
1997 < procedure TIBCustomDataSet.SetDeleteSQL(Value: TStrings);
1998 < begin
1999 <  if FQDelete.SQL.Text <> Value.Text then
2000 <  begin
2001 <    Disconnect;
2002 <    FQDelete.SQL.Assign(Value);
2003 <  end;
2004 < end;
2005 <
2006 < procedure TIBCustomDataSet.SetInsertSQL(Value: TStrings);
2007 < begin
2008 <  if FQInsert.SQL.Text <> Value.Text then
2009 <  begin
2010 <    Disconnect;
2011 <    FQInsert.SQL.Assign(Value);
2012 <  end;
2013 < end;
2014 <
2015 < procedure TIBCustomDataSet.SetInternalSQLParams(Qry: TIBSQL; Buffer: Pointer);
2016 < var
2017 <  i, j: Integer;
2018 <  cr, data: PChar;
2019 <  fn, st: string;
2020 <  OldBuffer: Pointer;
2021 <  ts: TTimeStamp;
2022 < begin
2023 <  if (Buffer = nil) then
2024 <    IBError(ibxeBufferNotSet, [nil]);
2025 <  if (not FInternalPrepared) then
2026 <    InternalPrepare;
2027 <  OldBuffer := nil;
2028 <  try
2029 <    for i := 0 to Qry.Params.Count - 1 do
2030 <    begin
2031 <      fn := Qry.Params[i].Name;
2032 <      if (Pos('OLD_', fn) = 1) then {mbcs ok}
2033 <      begin
2034 <        fn := Copy(fn, 5, Length(fn));
2035 <        if not Assigned(OldBuffer) then
2036 <        begin
2037 <          OldBuffer := AllocRecordBuffer;
2038 <          ReadRecordCache(PRecordData(Buffer)^.rdRecordNumber, OldBuffer, True);
2039 <        end;
2040 <        cr := OldBuffer;
2041 <      end
2042 <      else if (Pos('NEW_', fn) = 1) then {mbcs ok}
2043 <           begin
2044 <             fn := Copy(fn, 5, Length(fn));
2045 <             cr := Buffer;
2046 <            end
2047 <            else
2048 <             cr := Buffer;
2049 <      j := FQSelect.FieldIndex[fn] + 1;
2050 <      if (j > 0) then
2051 <        with PRecordData(cr)^ do
2052 <        begin
2053 <          if Qry.Params[i].name = 'IBX_INTERNAL_DBKEY' then {do not localize}
2054 <          begin
2055 <            PIBDBKey(Qry.Params[i].AsPointer)^ := rdDBKey;
2056 <            continue;
2057 <          end;
2058 <          if rdFields[j].fdIsNull then
2059 <            Qry.Params[i].IsNull := True
2060 <          else begin
2061 <            Qry.Params[i].IsNull := False;
2062 <            data := cr + rdFields[j].fdDataOfs;
2063 <            case rdFields[j].fdDataType of
2064 <              SQL_TEXT, SQL_VARYING:
2065 <              begin
2066 <                SetString(st, data, rdFields[j].fdDataLength);
2067 <                Qry.Params[i].AsString := st;
2068 <              end;
2069 <            SQL_FLOAT, SQL_DOUBLE, SQL_D_FLOAT:
2070 <              Qry.Params[i].AsDouble := PDouble(data)^;
2071 <            SQL_SHORT, SQL_LONG:
2072 <            begin
2073 <              if rdFields[j].fdDataScale = 0 then
2074 <                Qry.Params[i].AsLong := PLong(data)^
2075 <              else if rdFields[j].fdDataScale >= (-4) then
2076 <                Qry.Params[i].AsCurrency := PCurrency(data)^
2077 <              else
2078 <                Qry.Params[i].AsDouble := PDouble(data)^;
2079 <            end;
2080 <            SQL_INT64:
2081 <            begin
2082 <              if rdFields[j].fdDataScale = 0 then
2083 <                Qry.Params[i].AsInt64 := PInt64(data)^
2084 <              else if rdFields[j].fdDataScale >= (-4) then
2085 <                Qry.Params[i].AsCurrency := PCurrency(data)^
2086 <              else
2087 <                Qry.Params[i].AsDouble := PDouble(data)^;
2088 <            end;
2089 <            SQL_BLOB, SQL_ARRAY, SQL_QUAD:
2090 <              Qry.Params[i].AsQuad := PISC_QUAD(data)^;
2091 <            SQL_TYPE_DATE:
2092 <            begin
2093 <              ts.Date := PInt(data)^;
2094 <              ts.Time := 0;
2095 <              Qry.Params[i].AsDate :=
2096 <                TimeStampToDateTime(ts);
2097 <            end;
2098 <            SQL_TYPE_TIME:
2099 <            begin
2100 <              ts.Date := 0;
2101 <              ts.Time := PInt(data)^;
2102 <              Qry.Params[i].AsTime :=
2103 <                TimeStampToDateTime(ts);
2104 <            end;
2105 <            SQL_TIMESTAMP:
2106 <              Qry.Params[i].AsDateTime :=
2107 <                       TimeStampToDateTime(MSecsToTimeStamp(trunc(PDouble(data)^)));
2108 <          end;
2109 <        end;
2110 <      end;
2111 <    end;
2112 <  finally
2113 <    if (OldBuffer <> nil) then
2114 <      FreeRecordBuffer(PChar(OldBuffer));
2115 <  end;
2116 < end;
2117 <
2118 < procedure TIBCustomDataSet.SetRefreshSQL(Value: TStrings);
2119 < begin
2120 <  if FQRefresh.SQL.Text <> Value.Text then
2121 <  begin
2122 <    Disconnect;
2123 <    FQRefresh.SQL.Assign(Value);
2124 <  end;
2125 < end;
2126 <
2127 < procedure TIBCustomDataSet.SetSelectSQL(Value: TStrings);
2128 < begin
2129 <  if FQSelect.SQL.Text <> Value.Text then
2130 <  begin
2131 <    Disconnect;
2132 <    FQSelect.SQL.Assign(Value);
2133 <  end;
2134 < end;
2135 <
2136 < procedure TIBCustomDataSet.SetModifySQL(Value: TStrings);
2137 < begin
2138 <  if FQModify.SQL.Text <> Value.Text then
2139 <  begin
2140 <    Disconnect;
2141 <    FQModify.SQL.Assign(Value);
2142 <  end;
2143 < end;
2144 <
2145 < procedure TIBCustomDataSet.SetTransaction(Value: TIBTransaction);
2146 < begin
2147 <  if (FBase.Transaction <> Value) then
2148 <  begin
2149 <    CheckDatasetClosed;
2150 <    FBase.Transaction := Value;
2151 <    FQDelete.Transaction := Value;
2152 <    FQInsert.Transaction := Value;
2153 <    FQRefresh.Transaction := Value;
2154 <    FQSelect.Transaction := Value;
2155 <    FQModify.Transaction := Value;
2156 <  end;
2157 < end;
2158 <
2159 < procedure TIBCustomDataSet.SetUniDirectional(Value: Boolean);
2160 < begin
2161 <  CheckDatasetClosed;
2162 <  FUniDirectional := Value;
2163 < end;
2164 <
2165 < procedure TIBCustomDataSet.SetUpdateRecordTypes(Value: TIBUpdateRecordTypes);
2166 < begin
2167 <  FUpdateRecordTypes := Value;
2168 <  if Active then
2169 <    First;
2170 < end;
2171 <
2172 < procedure TIBCustomDataSet.RefreshParams;
2173 < var
2174 <  DataSet: TDataSet;
2175 < begin
2176 <  DisableControls;
2177 <  try
2178 <    if FDataLink.DataSource <> nil then
2179 <    begin
2180 <      DataSet := FDataLink.DataSource.DataSet;
2181 <      if DataSet <> nil then
2182 <        if DataSet.Active and (DataSet.State <> dsSetKey) then
2183 <        begin
2184 <          Close;
2185 <          Open;
2186 <        end;
2187 <    end;
2188 <  finally
2189 <    EnableControls;
2190 <  end;
2191 < end;
2192 <
2193 <
2194 < procedure TIBCustomDataSet.SQLChanging(Sender: TObject);
2195 < begin
2196 <  if FOpen then
2197 <    InternalClose;
2198 <  if FInternalPrepared then
2199 <    InternalUnPrepare;
2200 < end;
2201 <
2202 < { I can "undelete" uninserted records (make them "inserted" again).
2203 <  I can "undelete" cached deleted (the deletion hasn't yet occurred) }
2204 < procedure TIBCustomDataSet.Undelete;
2205 < var
2206 <  Buff: PRecordData;
2207 < begin
2208 <  CheckActive;
2209 <  Buff := PRecordData(GetActiveBuf);
2210 <  with Buff^ do
2211 <  begin
2212 <    if rdCachedUpdateStatus = cusUninserted then
2213 <    begin
2214 <      rdCachedUpdateStatus := cusInserted;
2215 <      Dec(FDeletedRecords);
2216 <    end
2217 <    else if (rdUpdateStatus = usDeleted) and
2218 <            (rdCachedUpdateStatus = cusDeleted) then
2219 <    begin
2220 <      rdCachedUpdateStatus := cusUnmodified;
2221 <      rdUpdateStatus := usUnmodified;
2222 <      Dec(FDeletedRecords);
2223 <    end;
2224 <    WriteRecordCache(rdRecordNumber, PChar(Buff));
2225 <  end;
2226 < end;
2227 <
2228 < function TIBCustomDataSet.UpdateStatus: TUpdateStatus;
2229 < begin
2230 <  if Active then
2231 <    if GetActiveBuf <> nil then
2232 <      result := PRecordData(GetActiveBuf)^.rdUpdateStatus
2233 <    else
2234 <      result := usUnmodified
2235 <  else
2236 <    result := usUnmodified;
2237 < end;
2238 <
2239 < function TIBCustomDataSet.IsSequenced: Boolean;
2240 < begin
2241 <  Result := Assigned( FQSelect ) and FQSelect.EOF;
2242 < end;
2243 <
2244 < function TIBCustomDataSet.ParamByName(ParamName: String): TIBXSQLVAR;
2245 < begin
2246 <  ActivateConnection;
2247 <  ActivateTransaction;
2248 <  if not FInternalPrepared then
2249 <    InternalPrepare;
2250 <  Result := Params.ByName(ParamName);
2251 < end;
2252 <
2253 < {Beware: the parameter FCache is used as an identifier to determine which
2254 < cache is being operated on and is not referenced in the computation.
2255 < The result is an adjusted offset into the identified cache, either the
2256 < Buffer Cache or the old Buffer Cache.}
2257 <
2258 < function TIBCustomDataSet.AdjustPosition(FCache: PChar; Offset: DWORD;
2259 <                                        Origin: Integer): DWORD;
2260 < var
2261 <  OldCacheSize: Integer;
2262 < begin
2263 <  if (FCache = FBufferCache) then
2264 <  begin
2265 <    case Origin of
2266 <      FILE_BEGIN:    FBPos := Offset;
2267 <      FILE_CURRENT:  FBPos := FBPos + Offset;
2268 <      FILE_END:      FBPos := DWORD(FBEnd) + Offset;
2269 <    end;
2270 <    OldCacheSize := FCacheSize;
2271 <    while (FBPos >= DWORD(FCacheSize)) do
2272 <      Inc(FCacheSize, FBufferChunkSize);
2273 <    if FCacheSize > OldCacheSize then
2274 <      IBAlloc(FBufferCache, FCacheSize, FCacheSize);
2275 <    result := FBPos;
2276 <  end
2277 <  else begin
2278 <    case Origin of
2279 <      FILE_BEGIN:    FOBPos := Offset;
2280 <      FILE_CURRENT:  FOBPos := FOBPos + Offset;
2281 <      FILE_END:      FOBPos := DWORD(FOBEnd) + Offset;
2282 <    end;
2283 <    OldCacheSize := FOldCacheSize;
2284 <    while (FBPos >= DWORD(FOldCacheSize)) do
2285 <      Inc(FOldCacheSize, FBufferChunkSize);
2286 <    if FOldCacheSize > OldCacheSize then
2287 <      IBAlloc(FOldBufferCache, FOldCacheSize, FOldCacheSize);
2288 <    result := FOBPos;
2289 <  end;
2290 < end;
2291 <
2292 < procedure TIBCustomDataSet.ReadCache(FCache: PChar; Offset: DWORD; Origin: Integer;
2293 <                                    Buffer: PChar);
2294 < var
2295 <  pCache: PChar;
2296 <  AdjustedOffset: DWORD;
2297 <  bOld: Boolean;
2298 < begin
2299 <  bOld := (FCache = FOldBufferCache);
2300 <  AdjustedOffset := AdjustPosition(FCache, Offset, Origin);
2301 <  if not bOld then
2302 <    pCache := FBufferCache + AdjustedOffset
2303 <  else
2304 <    pCache := FOldBufferCache + AdjustedOffset;
2305 <  Move(pCache^, Buffer^, DWORD(FRecordBufferSize));
2306 <  AdjustPosition(FCache, FRecordBufferSize, FILE_CURRENT);
2307 < end;
2308 <
2309 < procedure TIBCustomDataSet.ReadRecordCache(RecordNumber: Integer; Buffer: PChar;
2310 <                                          ReadOldBuffer: Boolean);
2311 < begin
2312 <  if FUniDirectional then
2313 <    RecordNumber := RecordNumber mod UniCache;
2314 <  if (ReadOldBuffer) then
2315 <  begin
2316 <    ReadRecordCache(RecordNumber, Buffer, False);
2317 <    if FCachedUpdates and
2318 <      (PRecordData(Buffer)^.rdSavedOffset <> $FFFFFFFF) then
2319 <      ReadCache(FOldBufferCache, PRecordData(Buffer)^.rdSavedOffset, FILE_BEGIN,
2320 <                Buffer)
2321 <    else
2322 <      if ReadOldBuffer and
2323 <         (PRecordData(FOldBuffer)^.rdRecordNumber = RecordNumber) then
2324 <         CopyRecordBuffer( FOldBuffer, Buffer )
2325 <  end
2326 <  else
2327 <    ReadCache(FBufferCache, RecordNumber * FRecordBufferSize, FILE_BEGIN, Buffer);
2328 < end;
2329 <
2330 < procedure TIBCustomDataSet.WriteCache(FCache: PChar; Offset: DWORD; Origin: Integer;
2331 <                                     Buffer: PChar);
2332 < var
2333 <  pCache: PChar;
2334 <  AdjustedOffset: DWORD;
2335 <  bOld: Boolean;
2336 <  dwEnd: DWORD;
2337 < begin
2338 <  bOld := (FCache = FOldBufferCache);
2339 <  AdjustedOffset := AdjustPosition(FCache, Offset, Origin);
2340 <  if not bOld then
2341 <    pCache := FBufferCache + AdjustedOffset
2342 <  else
2343 <    pCache := FOldBufferCache + AdjustedOffset;
2344 <  Move(Buffer^, pCache^, FRecordBufferSize);
2345 <  dwEnd := AdjustPosition(FCache, FRecordBufferSize, FILE_CURRENT);
2346 <  if not bOld then
2347 <  begin
2348 <    if (dwEnd > FBEnd) then
2349 <      FBEnd := dwEnd;
2350 <  end
2351 <  else begin
2352 <    if (dwEnd > FOBEnd) then
2353 <      FOBEnd := dwEnd;
2354 <  end;
2355 < end;
2356 <
2357 < procedure TIBCustomDataSet.WriteRecordCache(RecordNumber: Integer; Buffer: PChar);
2358 < begin
2359 <  if RecordNumber >= 0 then
2360 <  begin
2361 <    if FUniDirectional then
2362 <      RecordNumber := RecordNumber mod UniCache;
2363 <    WriteCache(FBufferCache, RecordNumber * FRecordBufferSize, FILE_BEGIN, Buffer);
2364 <  end;
2365 < end;
2366 <
2367 < function TIBCustomDataSet.AllocRecordBuffer: PChar;
2368 < begin
2369 <  result := nil;
2370 <  IBAlloc(result, FRecordBufferSize, FRecordBufferSize);
2371 <  Move(FModelBuffer^, result^, FRecordBufferSize);
2372 < end;
2373 <
2374 < function TIBCustomDataSet.CreateBlobStream(Field: TField; Mode: TBlobStreamMode): TStream;
2375 < var
2376 <  pb: PBlobDataArray;
2377 <  fs: TIBBlobStream;
2378 <  Buff: PChar;
2379 <  bTr, bDB: Boolean;
2380 < begin
2381 <  Buff := GetActiveBuf;
2382 <  if Buff = nil then
2383 <  begin
2384 <    fs := TIBBlobStream.Create;
2385 <    fs.Mode := bmReadWrite;
2386 <    FBlobStreamList.Add(Pointer(fs));
2387 <    result := TIBDSBlobStream.Create(Field, fs, Mode);
2388 <    exit;
2389 <  end;
2390 <  pb := PBlobDataArray(Buff + FBlobCacheOffset);
2391 <  if pb^[Field.Offset] = nil then
2392 <  begin
2393 <    AdjustRecordOnInsert(Buff);
2394 <    pb^[Field.Offset] := TIBBlobStream.Create;
2395 <    fs := pb^[Field.Offset];
2396 <    FBlobStreamList.Add(Pointer(fs));
2397 <    fs.Mode := bmReadWrite;
2398 <    fs.Database := Database;
2399 <    fs.Transaction := Transaction;
2400 <    fs.BlobID :=
2401 <      PISC_QUAD(@Buff[PRecordData(Buff)^.rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdDataOfs])^;
2402 <    if (CachedUpdates) then
2403 <    begin
2404 <      bTr := not Transaction.InTransaction;
2405 <      bDB := not Database.Connected;
2406 <      if bDB then
2407 <        Database.Open;
2408 <      if bTr then
2409 <        Transaction.StartTransaction;
2410 <      fs.Seek(0, soFromBeginning);
2411 <      if bTr then
2412 <        Transaction.Commit;
2413 <      if bDB then
2414 <        Database.Close;
2415 <    end;
2416 <    WriteRecordCache(PRecordData(Buff)^.rdRecordNumber, Pointer(Buff));
2417 <  end else
2418 <    fs := pb^[Field.Offset];
2419 <  result := TIBDSBlobStream.Create(Field, fs, Mode);
2420 < end;
2421 <
2422 < function TIBCustomDataSet.CompareBookmarks(Bookmark1, Bookmark2: TBookmark): Integer;
2423 < const
2424 <  CMPLess = -1;
2425 <  CMPEql  =  0;
2426 <  CMPGtr  =  1;
2427 <  RetCodes: array[Boolean, Boolean] of ShortInt = ((2, CMPLess),
2428 <                                                   (CMPGtr, CMPEql));
2429 < begin
2430 <  result := RetCodes[Bookmark1 = nil, Bookmark2 = nil];
2431 <
2432 <  if Result = 2 then
2433 <  begin
2434 <    if PInteger(Bookmark1)^ < PInteger(Bookmark2)^ then
2435 <      Result := CMPLess
2436 <    else
2437 <    if PInteger(Bookmark1)^ > PInteger(Bookmark2)^ then
2438 <      Result := CMPGtr
2439 <    else
2440 <      Result := CMPEql;
2441 <  end;
2442 < end;
2443 <
2444 < procedure TIBCustomDataSet.DoBeforeDelete;
2445 < var
2446 <  Buff: PRecordData;
2447 < begin
2448 <  if not CanDelete then
2449 <    IBError(ibxeCannotDelete, [nil]);
2450 <  Buff := PRecordData(GetActiveBuf);
2451 <  if FCachedUpdates and
2452 <    (Buff^.rdCachedUpdateStatus in [cusUnmodified]) then
2453 <    SaveOldBuffer(PChar(Buff));
2454 <  inherited DoBeforeDelete;
2455 < end;
2456 <
2457 < procedure TIBCustomDataSet.DoBeforeEdit;
2458 < var
2459 <  Buff: PRecordData;
2460 < begin
2461 <  Buff := PRecordData(GetActiveBuf);
2462 <  if not(CanEdit or (FQModify.SQL.Count <> 0) or
2463 <    (FCachedUpdates and Assigned(FOnUpdateRecord))) then
2464 <    IBError(ibxeCannotUpdate, [nil]);
2465 <  if FCachedUpdates and (Buff^.rdCachedUpdateStatus in [cusUnmodified, cusInserted]) then
2466 <    SaveOldBuffer(PChar(Buff));
2467 <  CopyRecordBuffer(GetActiveBuf, FOldBuffer);
2468 <  inherited DoBeforeEdit;
2469 < end;
2470 <
2471 < procedure TIBCustomDataSet.DoBeforeInsert;
2472 < begin
2473 <  if not CanInsert then
2474 <    IBError(ibxeCannotInsert, [nil]);
2475 <  inherited DoBeforeInsert;
2476 < end;
2477 <
2478 < procedure TIBCustomDataSet.DoAfterInsert;
2479 < begin
2480 <  if GeneratorField.ApplyOnEvent = gaeOnNewRecord then
2481 <    GeneratorField.Apply;
2482 <  inherited DoAfterInsert;
2483 < end;
2484 <
2485 < procedure TIBCustomDataSet.DoBeforePost;
2486 < begin
2487 <  inherited DoBeforePost;
2488 <  if (State = dsInsert) and
2489 <     (GeneratorField.ApplyOnEvent = gaeOnPostRecord) then
2490 <     GeneratorField.Apply
2491 < end;
2492 <
2493 < procedure TIBCustomDataSet.FetchAll;
2494 < var
2495 <  SetCursor: Boolean;
2496 <  {$IF FPC_FULLVERSION >  20602 }
2497 <  CurBookmark: TBookmark;
2498 <  {$ELSE}
2499 <  CurBookmark: string;
2500 <  {$ENDIF}
2501 < begin
2502 <  SetCursor := (GetCurrentThreadID = MainThreadID) and (Screen.Cursor = crDefault);
2503 <  if SetCursor then
2504 <    Screen.Cursor := crHourGlass;
2505 <  try
2506 <    if FQSelect.EOF or not FQSelect.Open then
2507 <      exit;
2508 <    DisableControls;
2509 <    try
2510 <      CurBookmark := Bookmark;
2511 <      Last;
2512 <      Bookmark := CurBookmark;
2513 <    finally
2514 <      EnableControls;
2515 <    end;
2516 <  finally
2517 <    if SetCursor and (Screen.Cursor = crHourGlass) then
2518 <      Screen.Cursor := crDefault;
2519 <  end;
2520 < end;
2521 <
2522 < procedure TIBCustomDataSet.FreeRecordBuffer(var Buffer: PChar);
2523 < begin
2524 <  FreeMem(Buffer);
2525 <  Buffer := nil;
2526 < end;
2527 <
2528 < procedure TIBCustomDataSet.GetBookmarkData(Buffer: PChar; Data: Pointer);
2529 < begin
2530 <  Move(PRecordData(Buffer)^.rdRecordNumber, Data^, BookmarkSize);
2531 < end;
2532 <
2533 < function TIBCustomDataSet.GetBookmarkFlag(Buffer: PChar): TBookmarkFlag;
2534 < begin
2535 <  result := PRecordData(Buffer)^.rdBookmarkFlag;
2536 < end;
2537 <
2538 < function TIBCustomDataSet.GetCanModify: Boolean;
2539 < begin
2540 <  result := (FQInsert.SQL.Text <> '') or
2541 <    (FQModify.SQL.Text <> '') or
2542 <    (FQDelete.SQL.Text <> '') or
2543 <    (Assigned(FUpdateObject));
2544 < end;
2545 <
2546 < function TIBCustomDataSet.GetCurrentRecord(Buffer: PChar): Boolean;
2547 < begin
2548 <  if not IsEmpty and (GetBookmarkFlag(ActiveBuffer) = bfCurrent) then
2549 <  begin
2550 <    UpdateCursorPos;
2551 <    ReadRecordCache(PRecordData(ActiveBuffer)^.rdRecordNumber, Buffer, False);
2552 <    result := True;
2553 <  end
2554 <  else
2555 <    result := False;
2556 < end;
2557 <
2558 < function TIBCustomDataSet.GetDataSource: TDataSource;
2559 < begin
2560 <  if FDataLink = nil then
2561 <    result := nil
2562 <  else
2563 <    result := FDataLink.DataSource;
2564 < end;
2565 <
2566 < function TIBCustomDataSet.GetFieldClass(FieldType: TFieldType): TFieldClass;
2567 < begin
2568 <  Result := DefaultFieldClasses[FieldType];
2569 < end;
2570 <
2571 < function TIBCustomDataSet.GetFieldData(FieldNo: Integer; Buffer: Pointer): Boolean;
2572 < begin
2573 <  result := GetFieldData(FieldByNumber(FieldNo), buffer);
2574 < end;
2575 <
2576 < function TIBCustomDataSet.InternalGetFieldData(Field: TField; Buffer: Pointer): Boolean;
2577 < var
2578 <  Buff, Data: PChar;
2579 <  CurrentRecord: PRecordData;
2580 < begin
2581 <  result := False;
2582 <  Buff := GetActiveBuf;
2583 <  if (Buff = nil) or
2584 <     (not IsVisible(Buff)) or not assigned(Field.DataSet) then
2585 <    exit;
2586 <  { The intention here is to stuff the buffer with the data for the
2587 <   referenced field for the current record }
2588 <  CurrentRecord := PRecordData(Buff);
2589 <  if (Field.FieldNo < 0) then
2590 <  begin
2591 <    Inc(Buff, FRecordSize + Field.Offset);
2592 <    result := Boolean(Buff[0]);
2593 <    if result and (Buffer <> nil) then
2594 <      Move(Buff[1], Buffer^, Field.DataSize);
2595 <  end
2596 <  else if (FMappedFieldPosition[Field.FieldNo - 1] > 0) and
2597 <     (FMappedFieldPosition[Field.FieldNo - 1] <= CurrentRecord^.rdFieldCount) then
2598 <  begin
2599 <    result := not CurrentRecord^.rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdIsNull;
2600 <    if result and (Buffer <> nil) then
2601 <      with CurrentRecord^.rdFields[FMappedFieldPosition[Field.FieldNo - 1]] do
2602 <      begin
2603 <        Data := Buff + CurrentRecord^.rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdDataOfs;
2604 <        if (fdDataType = SQL_VARYING) or (fdDataType = SQL_TEXT) then
2605 <        begin
2606 <          if fdDataLength <= Field.Size then
2607 <          begin
2608 <            Move(Data^, Buffer^, fdDataLength);
2609 <            PChar(Buffer)[fdDataLength] := #0;
2610 <          end
2611 <          else
2612 <            IBError(ibxeFieldSizeError,[Field.FieldName])
2613 <        end
2614 <        else
2615 <          Move(Data^, Buffer^, Field.DataSize);
2616 <      end;
2617 <  end;
2618 < end;
2619 <
2620 < { GetRecNo and SetRecNo both operate off of 1-based indexes as
2621 < opposed to 0-based indexes.
2622 < This is because we want LastRecordNumber/RecordCount = 1 }
2623 <
2624 < function TIBCustomDataSet.GetRecNo: Integer;
2625 < begin
2626 <  if GetActiveBuf = nil then
2627 <    result := 0
2628 <  else
2629 <    result := PRecordData(GetActiveBuf)^.rdRecordNumber + 1;
2630 < end;
2631 <
2632 < function TIBCustomDataSet.GetRecord(Buffer: PChar; GetMode: TGetMode;
2633 <  DoCheck: Boolean): TGetResult;
2634 < var
2635 <  Accept: Boolean;
2636 <  SaveState: TDataSetState;
2637 < begin
2638 <  Result := grOK;
2639 <  if Filtered and Assigned(OnFilterRecord) then
2640 <  begin
2641 <    Accept := False;
2642 <    SaveState := SetTempState(dsFilter);
2643 <    while not Accept do
2644 <    begin
2645 <      Result := InternalGetRecord(Buffer, GetMode, DoCheck);
2646 <      if Result <> grOK then
2647 <        break;
2648 <      FFilterBuffer := Buffer;
2649 <      try
2650 <        Accept := True;
2651 <        OnFilterRecord(Self, Accept);
2652 <        if not Accept and (GetMode = gmCurrent) then
2653 <          GetMode := gmPrior;
2654 <      except
2655 < //        Application.HandleException(Self);
2656 <      end;
2657 <    end;
2658 <    RestoreState(SaveState);
2659 <  end
2660 <  else
2661 <    Result := InternalGetRecord(Buffer, GetMode, DoCheck);
2662 < end;
2663 <
2664 < function TIBCustomDataSet.InternalGetRecord(Buffer: PChar; GetMode: TGetMode;
2665 <  DoCheck: Boolean): TGetResult;
2666 < begin
2667 <  result := grError;
2668 <  case GetMode of
2669 <    gmCurrent: begin
2670 <      if (FCurrentRecord >= 0) then begin
2671 <        if FCurrentRecord < FRecordCount then
2672 <          ReadRecordCache(FCurrentRecord, Buffer, False)
2673 <        else begin
2674 <          while (not FQSelect.EOF) and
2675 <                (FQSelect.Next <> nil) and
2676 <                (FCurrentRecord >= FRecordCount) do begin
2677 <            FetchCurrentRecordToBuffer(FQSelect, FRecordCount, Buffer);
2678 <            Inc(FRecordCount);
2679 <          end;
2680 <          FCurrentRecord := FRecordCount - 1;
2681 <          if (FCurrentRecord >= 0) then
2682 <            ReadRecordCache(FCurrentRecord, Buffer, False);
2683 <        end;
2684 <        result := grOk;
2685 <      end else
2686 <        result := grBOF;
2687 <    end;
2688 <    gmNext: begin
2689 <      result := grOk;
2690 <      if FCurrentRecord = FRecordCount then
2691 <        result := grEOF
2692 <      else if FCurrentRecord = FRecordCount - 1 then begin
2693 <        if (not FQSelect.EOF) then begin
2694 <          FQSelect.Next;
2695 <          Inc(FCurrentRecord);
2696 <        end;
2697 <        if (FQSelect.EOF) then begin
2698 <          result := grEOF;
2699 <        end else begin
2700 <          Inc(FRecordCount);
2701 <          FetchCurrentRecordToBuffer(FQSelect, FCurrentRecord, Buffer);
2702 <        end;
2703 <      end else if (FCurrentRecord < FRecordCount) then begin
2704 <        Inc(FCurrentRecord);
2705 <        ReadRecordCache(FCurrentRecord, Buffer, False);
2706 <      end;
2707 <    end;
2708 <    else { gmPrior }
2709 <    begin
2710 <      if (FCurrentRecord = 0) then begin
2711 <        Dec(FCurrentRecord);
2712 <        result := grBOF;
2713 <      end else if (FCurrentRecord > 0) and
2714 <                  (FCurrentRecord <= FRecordCount) then begin
2715 <        Dec(FCurrentRecord);
2716 <        ReadRecordCache(FCurrentRecord, Buffer, False);
2717 <        result := grOk;
2718 <      end else if (FCurrentRecord = -1) then
2719 <        result := grBOF;
2720 <    end;
2721 <  end;
2722 <  if result = grOk then
2723 <    result := AdjustCurrentRecord(Buffer, GetMode);
2724 <  if result = grOk then with PRecordData(Buffer)^ do begin
2725 <    rdBookmarkFlag := bfCurrent;
2726 <    GetCalcFields(Buffer);
2727 <  end else if (result = grEOF) then begin
2728 <    CopyRecordBuffer(FModelBuffer, Buffer);
2729 <    PRecordData(Buffer)^.rdBookmarkFlag := bfEOF;
2730 <  end else if (result = grBOF) then begin
2731 <    CopyRecordBuffer(FModelBuffer, Buffer);
2732 <    PRecordData(Buffer)^.rdBookmarkFlag := bfBOF;
2733 <  end else if (result = grError) then begin
2734 <    CopyRecordBuffer(FModelBuffer, Buffer);
2735 <    PRecordData(Buffer)^.rdBookmarkFlag := bfEOF;
2736 <  end;;
2737 < end;
2738 <
2739 < function TIBCustomDataSet.GetRecordCount: Integer;
2740 < begin
2741 <  result := FRecordCount - FDeletedRecords;
2742 < end;
2743 <
2744 < function TIBCustomDataSet.GetRecordSize: Word;
2745 < begin
2746 <  result := FRecordBufferSize;
2747 < end;
2748 <
2749 < procedure TIBCustomDataSet.InternalAddRecord(Buffer: Pointer; Append: Boolean);
2750 < begin
2751 <  CheckEditState;
2752 <  begin
2753 <     { When adding records, we *always* append.
2754 <       Insertion is just too costly }
2755 <    AdjustRecordOnInsert(Buffer);
2756 <    with PRecordData(Buffer)^ do
2757 <    begin
2758 <      rdUpdateStatus := usInserted;
2759 <      rdCachedUpdateStatus := cusInserted;
2760 <    end;
2761 <    if not CachedUpdates then
2762 <      InternalPostRecord(FQInsert, Buffer)
2763 <    else begin
2764 <      WriteRecordCache(FCurrentRecord, Buffer);
2765 <      FUpdatesPending := True;
2766 <    end;
2767 <    Inc(FRecordCount);
2768 <    InternalSetToRecord(Buffer);
2769 <  end
2770 < end;
2771 <
2772 < procedure TIBCustomDataSet.InternalCancel;
2773 < var
2774 <  Buff: PChar;
2775 <  CurRec: Integer;
2776 < begin
2777 <  inherited InternalCancel;
2778 <  Buff := GetActiveBuf;
2779 <  if Buff <> nil then begin
2780 <    CurRec := FCurrentRecord;
2781 <    AdjustRecordOnInsert(Buff);
2782 <    if (State = dsEdit) then begin
2783 <      CopyRecordBuffer(FOldBuffer, Buff);
2784 <      WriteRecordCache(PRecordData(Buff)^.rdRecordNumber, Buff);
2785 <    end else begin
2786 <      CopyRecordBuffer(FModelBuffer, Buff);
2787 <      PRecordData(Buff)^.rdUpdateStatus := usDeleted;
2788 <      PRecordData(Buff)^.rdCachedUpdateStatus := cusUnmodified;
2789 <      PRecordData(Buff)^.rdBookmarkFlag := bfEOF;
2790 <      FCurrentRecord := CurRec;
2791 <    end;
2792 <  end;
2793 < end;
2794 <
2795 <
2796 < procedure TIBCustomDataSet.InternalClose;
2797 < begin
2798 <  if FDidActivate then
2799 <    DeactivateTransaction;
2800 <  FQSelect.Close;
2801 <  ClearBlobCache;
2802 <  FreeRecordBuffer(FModelBuffer);
2803 <  FreeRecordBuffer(FOldBuffer);
2804 <  FCurrentRecord := -1;
2805 <  FOpen := False;
2806 <  FRecordCount := 0;
2807 <  FDeletedRecords := 0;
2808 <  FRecordSize := 0;
2809 <  FBPos := 0;
2810 <  FOBPos := 0;
2811 <  FCacheSize := 0;
2812 <  FOldCacheSize := 0;
2813 <  FBEnd := 0;
2814 <  FOBEnd := 0;
2815 <  FreeMem(FBufferCache);
2816 <  FBufferCache := nil;
2817 <  FreeMem(FOldBufferCache);
2818 <  FOldBufferCache := nil;
2819 <  BindFields(False);
2820 <  if DefaultFields then DestroyFields;
2821 < end;
2822 <
2823 < procedure TIBCustomDataSet.InternalDelete;
2824 < var
2825 <  Buff: PChar;
2826 <  SetCursor: Boolean;
2827 < begin
2828 <  SetCursor := (GetCurrentThreadID = MainThreadID) and (Screen.Cursor = crDefault);
2829 <  if SetCursor then
2830 <    Screen.Cursor := crHourGlass;
2831 <  try
2832 <    Buff := GetActiveBuf;
2833 <    if CanDelete then
2834 <    begin
2835 <      if not CachedUpdates then
2836 <        InternalDeleteRecord(FQDelete, Buff)
2837 <      else
2838 <      begin
2839 <        with PRecordData(Buff)^ do
2840 <        begin
2841 <          if rdCachedUpdateStatus = cusInserted then
2842 <            rdCachedUpdateStatus := cusUninserted
2843 <          else begin
2844 <            rdUpdateStatus := usDeleted;
2845 <            rdCachedUpdateStatus := cusDeleted;
2846 <          end;
2847 <        end;
2848 <        WriteRecordCache(PRecordData(Buff)^.rdRecordNumber, Buff);
2849 <      end;
2850 <      Inc(FDeletedRecords);
2851 <      FUpdatesPending := True;
2852 <    end else
2853 <      IBError(ibxeCannotDelete, [nil]);
2854 <  finally
2855 <    if SetCursor and (Screen.Cursor = crHourGlass) then
2856 <      Screen.Cursor := crDefault;
2857 <  end;
2858 < end;
2859 <
2860 < procedure TIBCustomDataSet.InternalFirst;
2861 < begin
2862 <  FCurrentRecord := -1;
2863 < end;
2864 <
2865 < procedure TIBCustomDataSet.InternalGotoBookmark(Bookmark: Pointer);
2866 < begin
2867 <  FCurrentRecord := PInteger(Bookmark)^;
2868 < end;
2869 <
2870 < procedure TIBCustomDataSet.InternalHandleException;
2871 < begin
2872 <  Application.HandleException(Self)
2873 < end;
2874 <
2875 < procedure TIBCustomDataSet.InternalInitFieldDefs;
2876 < const
2877 <  DefaultSQL = 'Select F.RDB$COMPUTED_BLR, ' + {do not localize}
2878 <               'F.RDB$DEFAULT_VALUE, R.RDB$FIELD_NAME ' + {do not localize}
2879 <               'from RDB$RELATION_FIELDS R, RDB$FIELDS F ' + {do not localize}
2880 <               'where R.RDB$RELATION_NAME = :RELATION ' +  {do not localize}
2881 <               'and R.RDB$FIELD_SOURCE = F.RDB$FIELD_NAME '+ {do not localize}
2882 <               'and ((not F.RDB$COMPUTED_BLR is NULL) or ' + {do not localize}
2883 <               '     (not F.RDB$DEFAULT_VALUE is NULL)) '; {do not localize}
2884 < var
2885 <  FieldType: TFieldType;
2886 <  FieldSize: Word;
2887 <  FieldNullable : Boolean;
2888 <  i, FieldPosition, FieldPrecision: Integer;
2889 <  FieldAliasName: string;
2890 <  RelationName, FieldName: string;
2891 <  Query : TIBSQL;
2892 <  FieldIndex: Integer;
2893 <  FRelationNodes : TRelationNode;
2894 <
2895 <  function Add_Node(Relation, Field : String) : TRelationNode;
2896 <  var
2897 <    FField : TFieldNode;
2898 <  begin
2899 <    if FRelationNodes.RelationName = '' then
2900 <      Result := FRelationNodes
2901 <    else
2902 <    begin
2903 <      Result := TRelationNode.Create;
2904 <      Result.NextRelation := FRelationNodes;
2905 <    end;
2906 <    Result.RelationName := Relation;
2907 <    FRelationNodes := Result;
2908 <    Query.Params[0].AsString := Relation;
2909 <    Query.ExecQuery;
2910 <    while not Query.Eof do
2911 <    begin
2912 <      FField := TFieldNode.Create;
2913 <      FField.FieldName := Query.Fields[2].AsString;
2914 <      FField.DEFAULT_VALUE := not Query.Fields[1].IsNull;
2915 <      FField.COMPUTED_BLR := not Query.Fields[0].IsNull;
2916 <      FField.NextField := Result.FieldNodes;
2917 <      Result.FieldNodes := FField;
2918 <      Query.Next;
2919 <    end;
2920 <    Query.Close;
2921 <  end;
2922 <
2923 <  function Has_COMPUTED_BLR(Relation, Field : String) : Boolean;
2924 <  var
2925 <    FRelation : TRelationNode;
2926 <    FField : TFieldNode;
2927 <  begin
2928 <    FRelation := FRelationNodes;
2929 <    while Assigned(FRelation) and
2930 <         (FRelation.RelationName <> Relation) do
2931 <      FRelation := FRelation.NextRelation;
2932 <    if not Assigned(FRelation) then
2933 <      FRelation := Add_Node(Relation, Field);
2934 <    Result := false;
2935 <    FField := FRelation.FieldNodes;
2936 <    while Assigned(FField) do
2937 <      if FField.FieldName = Field then
2938 <      begin
2939 <        Result := Ffield.COMPUTED_BLR;
2940 <        Exit;
2941 <      end
2942 <      else
2943 <        FField := Ffield.NextField;
2944 <  end;
2945 <
2946 <  function Has_DEFAULT_VALUE(Relation, Field : String) : Boolean;
2947 <  var
2948 <    FRelation : TRelationNode;
2949 <    FField : TFieldNode;
2950 <  begin
2951 <    FRelation := FRelationNodes;
2952 <    while Assigned(FRelation) and
2953 <         (FRelation.RelationName <> Relation) do
2954 <      FRelation := FRelation.NextRelation;
2955 <    if not Assigned(FRelation) then
2956 <      FRelation := Add_Node(Relation, Field);
2957 <    Result := false;
2958 <    FField := FRelation.FieldNodes;
2959 <    while Assigned(FField) do
2960 <      if FField.FieldName = Field then
2961 <      begin
2962 <        Result := Ffield.DEFAULT_VALUE;
2963 <        Exit;
2964 <      end
2965 <      else
2966 <        FField := Ffield.NextField;
2967 <  end;
2968 <
2969 <  Procedure FreeNodes;
2970 <  var
2971 <    FRelation : TRelationNode;
2972 <    FField : TFieldNode;
2973 <  begin
2974 <    while Assigned(FRelationNodes) do
2975 <    begin
2976 <      While Assigned(FRelationNodes.FieldNodes) do
2977 <      begin
2978 <        FField := FRelationNodes.FieldNodes.NextField;
2979 <        FRelationNodes.FieldNodes.Free;
2980 <        FRelationNodes.FieldNodes := FField;
2981 <      end;
2982 <      FRelation := FRelationNodes.NextRelation;
2983 <      FRelationNodes.Free;
2984 <      FRelationNodes := FRelation;
2985 <    end;
2986 <  end;
2987 <
2988 < begin
2989 <  if not InternalPrepared then
2990 <  begin
2991 <    InternalPrepare;
2992 <    exit;
2993 <  end;
2994 <  FRelationNodes := TRelationNode.Create;
2995 <  FNeedsRefresh := False;
2996 <  Database.InternalTransaction.StartTransaction;
2997 <  Query := TIBSQL.Create(self);
2998 <  try
2999 <    Query.Database := DataBase;
3000 <    Query.Transaction := Database.InternalTransaction;
3001 <    FieldDefs.BeginUpdate;
3002 <    FieldDefs.Clear;
3003 <    FieldIndex := 0;
3004 <    if (Length(FMappedFieldPosition) < FQSelect.Current.Count) then
3005 <      SetLength(FMappedFieldPosition, FQSelect.Current.Count);
3006 <    Query.SQL.Text := DefaultSQL;
3007 <    Query.Prepare;
3008 <    for i := 0 to FQSelect.Current.Count - 1 do
3009 <      with FQSelect.Current[i].Data^ do
3010 <      begin
3011 <        { Get the field name }
3012 <        SetString(FieldAliasName, aliasname, aliasname_length);
3013 <        SetString(RelationName, relname, relname_length);
3014 <        SetString(FieldName, sqlname, sqlname_length);
3015 <        FieldSize := 0;
3016 <        FieldPrecision := 0;
3017 <        FieldNullable := FQSelect.Current[i].IsNullable;
3018 <        case sqltype and not 1 of
3019 <          { All VARCHAR's must be converted to strings before recording
3020 <           their values }
3021 <          SQL_VARYING, SQL_TEXT:
3022 <          begin
3023 <            FieldSize := sqllen;
3024 <            FieldType := ftString;
3025 <          end;
3026 <          { All Doubles/Floats should be cast to doubles }
3027 <          SQL_DOUBLE, SQL_FLOAT:
3028 <            FieldType := ftFloat;
3029 <          SQL_SHORT:
3030 <          begin
3031 <            if (sqlscale = 0) then
3032 <              FieldType := ftSmallInt
3033 <            else begin
3034 <              FieldType := ftBCD;
3035 <              FieldPrecision := 4;
3036 <              FieldSize := -sqlscale;
3037 <            end;
3038 <          end;
3039 <          SQL_LONG:
3040 <          begin
3041 <            if (sqlscale = 0) then
3042 <              FieldType := ftInteger
3043 <            else if (sqlscale >= (-4)) then
3044 <            begin
3045 <              FieldType := ftBCD;
3046 <              FieldPrecision := 9;
3047 <              FieldSize := -sqlscale;
3048 <            end
3049 <            else
3050 <            if Database.SQLDialect = 1 then
3051 <              FieldType := ftFloat
3052 <            else
3053 <            if (FieldCount > i) and (Fields[i] is TFloatField) then
3054 <              FieldType := ftFloat
3055 <            else
3056 <            begin
3057 <              FieldType := ftFMTBCD;
3058 <              FieldPrecision := 9;
3059 <              FieldSize := -sqlscale;
3060 <            end;
3061 <          end;
3062 <
3063 <          SQL_INT64:
3064 <          begin
3065 <            if (sqlscale = 0) then
3066 <              FieldType := ftLargeInt
3067 <            else if (sqlscale >= (-4)) then
3068 <            begin
3069 <              FieldType := ftBCD;
3070 <              FieldPrecision := 18;
3071 <              FieldSize := -sqlscale;
3072 <            end
3073 <            else
3074 <              FieldType := ftFloat
3075 <          end;
3076 <          SQL_TIMESTAMP: FieldType := ftDateTime;
3077 <          SQL_TYPE_TIME: FieldType := ftTime;
3078 <          SQL_TYPE_DATE: FieldType := ftDate;
3079 <          SQL_BLOB:
3080 <          begin
3081 <            FieldSize := sizeof (TISC_QUAD);
3082 <            if (sqlsubtype = 1) then
3083 <              FieldType := ftmemo
3084 <            else
3085 <              FieldType := ftBlob;
3086 <          end;
3087 <          SQL_ARRAY:
3088 <          begin
3089 <            FieldSize := sizeof (TISC_QUAD);
3090 <            FieldType := ftUnknown;
3091 <          end;
3092 <          else
3093 <            FieldType := ftUnknown;
3094 <        end;
3095 <        FieldPosition := i + 1;
3096 <        if (FieldType <> ftUnknown) and (FieldAliasName <> 'IBX_INTERNAL_DBKEY') then {do not localize}
3097 <        begin
3098 <          FMappedFieldPosition[FieldIndex] := FieldPosition;
3099 <          Inc(FieldIndex);
3100 <          with FieldDefs.AddFieldDef do
3101 <          begin
3102 <            Name := FieldAliasName;
3103 < (*           FieldNo := FieldPosition;*)
3104 <            DataType := FieldType;
3105 <            Size := FieldSize;
3106 <            Precision := FieldPrecision;
3107 <            Required := not FieldNullable;
3108 <            InternalCalcField := False;
3109 <            if (FieldName <> '') and (RelationName <> '') then
3110 <            begin
3111 <              if Has_COMPUTED_BLR(RelationName, FieldName) then
3112 <              begin
3113 <                Attributes := [faReadOnly];
3114 <                InternalCalcField := True;
3115 <                FNeedsRefresh := True;
3116 <              end
3117 <              else
3118 <              begin
3119 <                if Has_DEFAULT_VALUE(RelationName, FieldName) then
3120 <                begin
3121 <                  if not FieldNullable then
3122 <                    Attributes := [faRequired];
3123 <                end
3124 <                else
3125 <                  FNeedsRefresh := True;
3126 <              end;
3127 <            end;
3128 <          end;
3129 <        end;
3130 <      end;
3131 <  finally
3132 <    Query.free;
3133 <    FreeNodes;
3134 <    Database.InternalTransaction.Commit;
3135 <    FieldDefs.EndUpdate;
3136 <  end;
3137 < end;
3138 <
3139 < procedure TIBCustomDataSet.InternalInitRecord(Buffer: PChar);
3140 < begin
3141 <  CopyRecordBuffer(FModelBuffer, Buffer);
3142 < end;
3143 <
3144 < procedure TIBCustomDataSet.InternalLast;
3145 < var
3146 <  Buffer: PChar;
3147 < begin
3148 <  if (FQSelect.EOF) then
3149 <    FCurrentRecord := FRecordCount
3150 <  else begin
3151 <    Buffer := AllocRecordBuffer;
3152 <    try
3153 <      while FQSelect.Next <> nil do
3154 <      begin
3155 <        FetchCurrentRecordToBuffer(FQSelect, FRecordCount, Buffer);
3156 <        Inc(FRecordCount);
3157 <      end;
3158 <      FCurrentRecord := FRecordCount;
3159 <    finally
3160 <      FreeRecordBuffer(Buffer);
3161 <    end;
3162 <  end;
3163 < end;
3164 <
3165 < procedure TIBCustomDataSet.InternalSetParamsFromCursor;
3166 < var
3167 <  i: Integer;
3168 <  cur_param: TIBXSQLVAR;
3169 <  cur_field: TField;
3170 <  s: TStream;
3171 < begin
3172 <  if FQSelect.SQL.Text = '' then
3173 <    IBError(ibxeEmptyQuery, [nil]);
3174 <  if not FInternalPrepared then
3175 <    InternalPrepare;
3176 <  if (SQLParams.Count > 0) and (DataSource <> nil) and (DataSource.DataSet <> nil) then
3177 <  begin
3178 <    for i := 0 to SQLParams.Count - 1 do
3179 <    begin
3180 <      cur_field := DataSource.DataSet.FindField(SQLParams[i].Name);
3181 <      cur_param := SQLParams[i];
3182 <      if (cur_field <> nil) then begin
3183 <        if (cur_field.IsNull) then
3184 <          cur_param.IsNull := True
3185 <        else case cur_field.DataType of
3186 <          ftString:
3187 <            cur_param.AsString := cur_field.AsString;
3188 <          ftBoolean, ftSmallint, ftWord:
3189 <            cur_param.AsShort := cur_field.AsInteger;
3190 <          ftInteger:
3191 <            cur_param.AsLong := cur_field.AsInteger;
3192 <          ftLargeInt:
3193 <            cur_param.AsInt64 := TLargeIntField(cur_field).AsLargeInt;
3194 <          ftFloat, ftCurrency:
3195 <           cur_param.AsDouble := cur_field.AsFloat;
3196 <          ftBCD:
3197 <            cur_param.AsCurrency := cur_field.AsCurrency;
3198 <          ftDate:
3199 <            cur_param.AsDate := cur_field.AsDateTime;
3200 <          ftTime:
3201 <            cur_param.AsTime := cur_field.AsDateTime;
3202 <          ftDateTime:
3203 <            cur_param.AsDateTime := cur_field.AsDateTime;
3204 <          ftBlob, ftMemo:
3205 <          begin
3206 <            s := nil;
3207 <            try
3208 <              s := DataSource.DataSet.
3209 <                     CreateBlobStream(cur_field, bmRead);
3210 <              cur_param.LoadFromStream(s);
3211 <            finally
3212 <              s.free;
3213 <            end;
3214 <          end;
3215 <          else
3216 <            IBError(ibxeNotSupported, [nil]);
3217 <        end;
3218 <      end;
3219 <    end;
3220 <  end;
3221 < end;
3222 <
3223 < procedure TIBCustomDataSet.ReQuery;
3224 < begin
3225 <  FQSelect.Close;
3226 <  ClearBlobCache;
3227 <  FCurrentRecord := -1;
3228 <  FRecordCount := 0;
3229 <  FDeletedRecords := 0;
3230 <  FBPos := 0;
3231 <  FOBPos := 0;
3232 <  FBEnd := 0;
3233 <  FOBEnd := 0;
3234 <  FQSelect.Close;
3235 <  FQSelect.ExecQuery;
3236 <  FOpen := FQSelect.Open;
3237 <  First;
3238 < end;
3239 <
3240 < procedure TIBCustomDataSet.InternalOpen;
3241 < var
3242 <  SetCursor: Boolean;
3243 <
3244 <  function RecordDataLength(n: Integer): Long;
3245 <  begin
3246 <    result := SizeOf(TRecordData) + ((n - 1) * SizeOf(TFieldData));
3247 <  end;
3248 <
3249 < begin
3250 <  SetCursor := (GetCurrentThreadID = MainThreadID) and (Screen.Cursor = crDefault);
3251 <  if SetCursor then
3252 <    Screen.Cursor := crHourGlass;
3253 <  try
3254 <    ActivateConnection;
3255 <    ActivateTransaction;
3256 <    if FQSelect.SQL.Text = '' then
3257 <      IBError(ibxeEmptyQuery, [nil]);
3258 <    if not FInternalPrepared then
3259 <      InternalPrepare;
3260 <   if FQSelect.SQLType = SQLSelect then
3261 <   begin
3262 <      if DefaultFields then
3263 <        CreateFields;
3264 <      BindFields(True);
3265 <      FCurrentRecord := -1;
3266 <      FQSelect.ExecQuery;
3267 <      FOpen := FQSelect.Open;
3268 <
3269 <      { Initialize offsets, buffer sizes, etc...
3270 <        1. Initially FRecordSize is just the "RecordDataLength".
3271 <        2. Allocate a "model" buffer and do a dummy fetch
3272 <        3. After the dummy fetch, FRecordSize will be appropriately
3273 <           adjusted to reflect the additional "weight" of the field
3274 <           data.
3275 <        4. Set up the FCalcFieldsOffset, FBlobCacheOffset and FRecordBufferSize.
3276 <        5. Now, with the BufferSize available, allocate memory for chunks of records
3277 <        6. Re-allocate the model buffer, accounting for the new
3278 <           FRecordBufferSize.
3279 <        7. Finally, calls to AllocRecordBuffer will work!.
3280 <       }
3281 <      {Step 1}
3282 <      FRecordSize := RecordDataLength(FQSelect.Current.Count);
3283 <      {Step 2, 3}
3284 <      IBAlloc(FModelBuffer, 0, FRecordSize);
3285 <      FetchCurrentRecordToBuffer(FQSelect, -1, FModelBuffer);
3286 <      {Step 4}
3287 <      FCalcFieldsOffset := FRecordSize;
3288 <      FBlobCacheOffset := FCalcFieldsOffset + CalcFieldsSize;
3289 <      FRecordBufferSize := (FBlobCacheOffset + (BlobFieldCount * SizeOf(TIBBlobStream)));
3290 <      {Step 5}
3291 <      if UniDirectional then
3292 <        FBufferChunkSize := FRecordBufferSize * UniCache
3293 <      else
3294 <        FBufferChunkSize := FRecordBufferSize * BufferChunks;
3295 <      IBAlloc(FBufferCache, FBufferChunkSize, FBufferChunkSize);
3296 <      if FCachedUpdates or (csReading in ComponentState) then
3297 <        IBAlloc(FOldBufferCache, FBufferChunkSize, FBufferChunkSize);
3298 <      FBPos := 0;
3299 <      FOBPos := 0;
3300 <      FBEnd := 0;
3301 <      FOBEnd := 0;
3302 <      FCacheSize := FBufferChunkSize;
3303 <      FOldCacheSize := FBufferChunkSize;
3304 <      {Step 6}
3305 <      IBAlloc(FModelBuffer, RecordDataLength(FQSelect.Current.Count),
3306 <                             FRecordBufferSize);
3307 <      {Step 7}
3308 <      FOldBuffer := AllocRecordBuffer;
3309 <    end
3310 <    else
3311 <      FQSelect.ExecQuery;
3312 <  finally
3313 <    if SetCursor and (Screen.Cursor = crHourGlass) then
3314 <      Screen.Cursor := crDefault;
3315 <  end;
3316 < end;
3317 <
3318 < procedure TIBCustomDataSet.InternalPost;
3319 < var
3320 <  Qry: TIBSQL;
3321 <  Buff: PChar;
3322 <  SetCursor: Boolean;
3323 <  bInserting: Boolean;
3324 < begin
3325 <  SetCursor := (GetCurrentThreadID = MainThreadID) and (Screen.Cursor = crDefault);
3326 <  if SetCursor then
3327 <    Screen.Cursor := crHourGlass;
3328 <  try
3329 <    Buff := GetActiveBuf;
3330 <    CheckEditState;
3331 <    AdjustRecordOnInsert(Buff);
3332 <    if (State = dsInsert) then
3333 <    begin
3334 <      bInserting := True;
3335 <      Qry := FQInsert;
3336 <      PRecordData(Buff)^.rdUpdateStatus := usInserted;
3337 <      PRecordData(Buff)^.rdCachedUpdateStatus := cusInserted;
3338 <      WriteRecordCache(FRecordCount, Buff);
3339 <      FCurrentRecord := FRecordCount;
3340 <    end
3341 <    else begin
3342 <      bInserting := False;
3343 <      Qry := FQModify;
3344 <      if PRecordData(Buff)^.rdCachedUpdateStatus = cusUnmodified then
3345 <      begin
3346 <        PRecordData(Buff)^.rdUpdateStatus := usModified;
3347 <        PRecordData(Buff)^.rdCachedUpdateStatus := cusModified;
3348 <      end
3349 <      else if PRecordData(Buff)^.
3350 <                    rdCachedUpdateStatus = cusUninserted then
3351 <            begin
3352 <              PRecordData(Buff)^.rdCachedUpdateStatus := cusInserted;
3353 <              Dec(FDeletedRecords);
3354 <            end;
3355 <    end;
3356 <    if (not CachedUpdates) then
3357 <      InternalPostRecord(Qry, Buff)
3358 <    else begin
3359 <      WriteRecordCache(PRecordData(Buff)^.rdRecordNumber, Buff);
3360 <      FUpdatesPending := True;
3361 <    end;
3362 <    if bInserting then
3363 <      Inc(FRecordCount);
3364 <  finally
3365 <    if SetCursor and (Screen.Cursor = crHourGlass) then
3366 <      Screen.Cursor := crDefault;
3367 <  end;
3368 < end;
3369 <
3370 < procedure TIBCustomDataSet.InternalRefresh;
3371 < begin
3372 <  inherited InternalRefresh;
3373 <  InternalRefreshRow;
3374 < end;
3375 <
3376 < procedure TIBCustomDataSet.InternalSetToRecord(Buffer: PChar);
3377 < begin
3378 <  InternalGotoBookmark(@(PRecordData(Buffer)^.rdRecordNumber));
3379 < end;
3380 <
3381 < function TIBCustomDataSet.IsCursorOpen: Boolean;
3382 < begin
3383 <  result := FOpen;
3384 < end;
3385 <
3386 < function TIBCustomDataSet.Locate(const KeyFields: string; const KeyValues: Variant;
3387 <                                 Options: TLocateOptions): Boolean;
3388 < var
3389 <  {$IF FPC_FULLVERSION >  20602 }
3390 <  CurBookmark: TBookmark;
3391 <  {$ELSE}
3392 <  CurBookmark: string;
3393 <  {$ENDIF}
3394 < begin
3395 <  DisableControls;
3396 <  try
3397 <    CurBookmark := Bookmark;
3398 <    First;
3399 <    result := InternalLocate(KeyFields, KeyValues, Options);
3400 <    if not result then
3401 <      Bookmark := CurBookmark;
3402 <  finally
3403 <    EnableControls;
3404 <  end;
3405 < end;
3406 <
3407 < function TIBCustomDataSet.Lookup(const KeyFields: string; const KeyValues: Variant;
3408 <                                 const ResultFields: string): Variant;
3409 < var
3410 <  fl: TList;
3411 <  {$IF FPC_FULLVERSION >  20602 }
3412 <  CurBookmark: TBookmark;
3413 <  {$ELSE}
3414 <  CurBookmark: string;
3415 <  {$ENDIF}
3416 < begin
3417 <  DisableControls;
3418 <  fl := TList.Create;
3419 <  CurBookmark := Bookmark;
3420 <  try
3421 <    First;
3422 <    if InternalLocate(KeyFields, KeyValues, []) then
3423 <    begin
3424 <      if (ResultFields <> '') then
3425 <        result := FieldValues[ResultFields]
3426 <      else
3427 <        result := NULL;
3428 <    end
3429 <    else
3430 <      result := Null;
3431 <  finally
3432 <    Bookmark := CurBookmark;
3433 <    fl.Free;
3434 <    EnableControls;
3435 <  end;
3436 < end;
3437 <
3438 < procedure TIBCustomDataSet.SetBookmarkData(Buffer: PChar; Data: Pointer);
3439 < begin
3440 <  PRecordData(Buffer)^.rdRecordNumber := PInteger(Data)^;
3441 < end;
3442 <
3443 < procedure TIBCustomDataSet.SetBookmarkFlag(Buffer: PChar; Value: TBookmarkFlag);
3444 < begin
3445 <  PRecordData(Buffer)^.rdBookmarkFlag := Value;
3446 < end;
3447 <
3448 < procedure TIBCustomDataSet.SetCachedUpdates(Value: Boolean);
3449 < begin
3450 <  if not Value and FCachedUpdates then
3451 <    CancelUpdates;
3452 <  if (not (csReading in ComponentState)) and Value then
3453 <    CheckDatasetClosed;
3454 <  FCachedUpdates := Value;
3455 < end;
3456 <
3457 < procedure TIBCustomDataSet.SetDataSource(Value: TDataSource);
3458 < begin
3459 <  if IsLinkedTo(Value) then
3460 <    IBError(ibxeCircularReference, [nil]);
3461 <  if FDataLink <> nil then
3462 <    FDataLink.DataSource := Value;
3463 < end;
3464 <
3465 < procedure TIBCustomDataSet.InternalSetFieldData(Field: TField; Buffer: Pointer);
3466 < var
3467 <  Buff, TmpBuff: PChar;
3468 < begin
3469 <  Buff := GetActiveBuf;
3470 <  if Field.FieldNo < 0 then
3471 <  begin
3472 <    TmpBuff := Buff + FRecordSize + Field.Offset;
3473 <    Boolean(TmpBuff[0]) := LongBool(Buffer);
3474 <    if Boolean(TmpBuff[0]) then
3475 <      Move(Buffer^, TmpBuff[1], Field.DataSize);
3476 <    WriteRecordCache(PRecordData(Buff)^.rdRecordNumber, Buff);
3477 <  end
3478 <  else begin
3479 <    CheckEditState;
3480 <    with PRecordData(Buff)^ do
3481 <    begin
3482 <      { If inserting, Adjust record position }
3483 <      AdjustRecordOnInsert(Buff);
3484 <      if (FMappedFieldPosition[Field.FieldNo - 1] > 0) and
3485 <         (FMappedFieldPosition[Field.FieldNo - 1] <= rdFieldCount) then
3486 <      begin
3487 <        Field.Validate(Buffer);
3488 <        if (Buffer = nil) or
3489 <           (Field is TIBStringField) and (PChar(Buffer)[0] = #0) then
3490 <          rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdIsNull := True
3491 <        else begin
3492 <          Move(Buffer^, Buff[rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdDataOfs],
3493 <                 rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdDataSize);
3494 <          if (rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdDataType = SQL_TEXT) or
3495 <             (rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdDataType = SQL_VARYING) then
3496 <            rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdDataLength := StrLen(PChar(Buffer));
3497 <          rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdIsNull := False;
3498 <          if rdUpdateStatus = usUnmodified then
3499 <          begin
3500 <            if CachedUpdates then
3501 <            begin
3502 <              FUpdatesPending := True;
3503 <              if State = dsInsert then
3504 <                rdCachedUpdateStatus := cusInserted
3505 <              else if State = dsEdit then
3506 <                rdCachedUpdateStatus := cusModified;
3507 <            end;
3508 <
3509 <            if State = dsInsert then
3510 <              rdUpdateStatus := usInserted
3511 <            else
3512 <              rdUpdateStatus := usModified;
3513 <          end;
3514 <          WriteRecordCache(rdRecordNumber, Buff);
3515 <          SetModified(True);
3516 <        end;
3517 <      end;
3518 <    end;
3519 <  end;
3520 <  if not (State in [dsCalcFields, dsFilter, dsNewValue]) then
3521 <      DataEvent(deFieldChange, PtrInt(Field));
3522 < end;
3523 <
3524 < procedure TIBCustomDataSet.SetRecNo(Value: Integer);
3525 < begin
3526 <  CheckBrowseMode;
3527 <  if (Value < 1) then
3528 <    Value := 1
3529 <  else if Value > FRecordCount then
3530 <  begin
3531 <    InternalLast;
3532 <    Value := Min(FRecordCount, Value);
3533 <  end;
3534 <  if (Value <> RecNo) then
3535 <  begin
3536 <    DoBeforeScroll;
3537 <    FCurrentRecord := Value - 1;
3538 <    Resync([]);
3539 <    DoAfterScroll;
3540 <  end;
3541 < end;
3542 <
3543 < procedure TIBCustomDataSet.Disconnect;
3544 < begin
3545 < Close;
3546 < InternalUnPrepare;
3547 < end;
3548 <
3549 < procedure TIBCustomDataSet.SetUpdateMode(const Value: TUpdateMode);
3550 < begin
3551 <  if not CanModify then
3552 <    IBError(ibxeCannotUpdate, [nil])
3553 <  else
3554 <    FUpdateMode := Value;
3555 < end;
3556 <
3557 <
3558 < procedure TIBCustomDataSet.SetUpdateObject(Value: TIBDataSetUpdateObject);
3559 < begin
3560 <  if Value <> FUpdateObject then
3561 <  begin
3562 <    if Assigned(FUpdateObject) and (FUpdateObject.DataSet = Self) then
3563 <      FUpdateObject.DataSet := nil;
3564 <    FUpdateObject := Value;
3565 <    if Assigned(FUpdateObject) then
3566 <    begin
3567 <      if Assigned(FUpdateObject.DataSet) and
3568 <        (FUpdateObject.DataSet <> Self) then
3569 <        FUpdateObject.DataSet.UpdateObject := nil;
3570 <      FUpdateObject.DataSet := Self;
3571 <    end;
3572 <  end;
3573 < end;
3574 <
3575 < function TIBCustomDataSet.ConstraintsStored: Boolean;
3576 < begin
3577 <  Result := Constraints.Count > 0;
3578 < end;
3579 <
3580 < procedure TIBCustomDataSet.ClearCalcFields(Buffer: PChar);
3581 < begin
3582 < FillChar(Buffer[FRecordSize], CalcFieldsSize, 0);
3583 < end;
3584 <
3585 <
3586 < procedure TIBCustomDataSet.InternalUnPrepare;
3587 < begin
3588 <  if FInternalPrepared then
3589 <  begin
3590 <    CheckDatasetClosed;
3591 <    FieldDefs.Clear;
3592 <    FInternalPrepared := False;
3593 <  end;
3594 < end;
3595 <
3596 < procedure TIBCustomDataSet.InternalExecQuery;
3597 < var
3598 <  DidActivate: Boolean;
3599 <  SetCursor: Boolean;
3600 < begin
3601 <  DidActivate := False;
3602 <  SetCursor := (GetCurrentThreadID = MainThreadID) and (Screen.Cursor = crDefault);
3603 <  if SetCursor then
3604 <    Screen.Cursor := crHourGlass;
3605 <  try
3606 <    ActivateConnection;
3607 <    DidActivate := ActivateTransaction;
3608 <    if FQSelect.SQL.Text = '' then
3609 <      IBError(ibxeEmptyQuery, [nil]);
3610 <    if not FInternalPrepared then
3611 <      InternalPrepare;
3612 <    if FQSelect.SQLType = SQLSelect then
3613 <    begin
3614 <      IBError(ibxeIsASelectStatement, [nil]);
3615 <    end
3616 <    else
3617 <      FQSelect.ExecQuery;
3618 <  finally
3619 <    if DidActivate then
3620 <      DeactivateTransaction;
3621 <    if SetCursor and (Screen.Cursor = crHourGlass) then
3622 <      Screen.Cursor := crDefault;
3623 <  end;
3624 < end;
3625 <
3626 < function TIBCustomDataSet.GetSelectStmtHandle: TISC_STMT_HANDLE;
3627 < begin
3628 <  Result := FQSelect.Handle;
3629 < end;
3630 <
3631 < procedure TIBCustomDataSet.InitRecord(Buffer: PChar);
3632 < begin
3633 <  inherited InitRecord(Buffer);
3634 <  with PRecordData(Buffer)^ do
3635 <  begin
3636 <    rdUpdateStatus := TUpdateStatus(usInserted);
3637 <    rdBookMarkFlag := bfInserted;
3638 <    rdRecordNumber := -1;
3639 <  end;
3640 < end;
3641 <
3642 < procedure TIBCustomDataSet.InternalInsert;
3643 < begin
3644 <  CursorPosChanged;
3645 < end;
3646 <
3647 < { TIBDataSet IProviderSupport }
3648 <
3649 < (*procedure TIBCustomDataSet.PSEndTransaction(Commit: Boolean);
3650 < begin
3651 <  if Commit then
3652 <    Transaction.Commit else
3653 <    Transaction.Rollback;
3654 < end;
3655 <
3656 < function TIBCustomDataSet.PSExecuteStatement(const ASQL: string; AParams: TParams;
3657 <  ResultSet: Pointer = nil): Integer;
3658 < var
3659 <  FQuery: TIBQuery;
3660 < begin
3661 <  if Assigned(ResultSet) then
3662 <  begin
3663 <    TDataSet(ResultSet^) := TIBQuery.Create(nil);
3664 <    with TIBQuery(ResultSet^) do
3665 <    begin
3666 <      SQL.Text := ASQL;
3667 <      Params.Assign(AParams);
3668 <      Open;
3669 <      Result := RowsAffected;
3670 <    end;
3671 <  end
3672 <  else
3673 <  begin
3674 <    FQuery := TIBQuery.Create(nil);
3675 <    try
3676 <      FQuery.Database := Database;
3677 <      FQuery.Transaction := Transaction;
3678 <      FQuery.GenerateParamNames := True;
3679 <      FQuery.SQL.Text := ASQL;
3680 <      FQuery.Params.Assign(AParams);
3681 <      FQuery.ExecSQL;
3682 <      Result := FQuery.RowsAffected;
3683 <    finally
3684 <      FQuery.Free;
3685 <    end;
3686 <  end;
3687 < end;
3688 <
3689 < function TIBCustomDataSet.PSGetQuoteChar: string;
3690 < begin
3691 <  if Database.SQLDialect = 3 then
3692 <    Result := '"' else
3693 <    Result := '';
3694 < end;
3695 <
3696 < function TIBCustomDataSet.PSGetUpdateException(E: Exception; Prev: EUpdateError): EUpdateError;
3697 < var
3698 <  PrevErr: Integer;
3699 < begin
3700 <  if Prev <> nil then
3701 <    PrevErr := Prev.ErrorCode else
3702 <    PrevErr := 0;
3703 <  if E is EIBError then
3704 <    with EIBError(E) do
3705 <      Result := EUpdateError.Create(E.Message, '', SQLCode, PrevErr, E) else
3706 <      Result := inherited PSGetUpdateException(E, Prev);
3707 < end;
3708 <
3709 < function TIBCustomDataSet.PSInTransaction: Boolean;
3710 < begin
3711 <  Result := Transaction.InTransaction;
3712 < end;
3713 <
3714 < function TIBCustomDataSet.PSIsSQLBased: Boolean;
3715 < begin
3716 <  Result := True;
3717 < end;
3718 <
3719 < function TIBCustomDataSet.PSIsSQLSupported: Boolean;
3720 < begin
3721 <  Result := True;
3722 < end;
3723 <
3724 < procedure TIBCustomDataSet.PSReset;
3725 < begin
3726 <  inherited PSReset;
3727 <  if Active then
3728 <  begin
3729 <    Close;
3730 <    Open;
3731 <  end;
3732 < end;
3733 <
3734 < function TIBCustomDataSet.PSUpdateRecord(UpdateKind: TUpdateKind; Delta: TDataSet): Boolean;
3735 < var
3736 <  UpdateAction: TIBUpdateAction;
3737 <  SQL: string;
3738 <  Params: TParams;
3739 <
3740 <  procedure AssignParams(DataSet: TDataSet; Params: TParams);
3741 <  var
3742 <    I: Integer;
3743 <    Old: Boolean;
3744 <    Param: TParam;
3745 <    PName: string;
3746 <    Field: TField;
3747 <    Value: Variant;
3748 <  begin
3749 <    for I := 0 to Params.Count - 1 do
3750 <    begin
3751 <      Param := Params[I];
3752 <      PName := Param.Name;
3753 <      Old := CompareText(Copy(PName, 1, 4), 'OLD_') = 0; {do not localize}
3754 <      if Old then System.Delete(PName, 1, 4);
3755 <      Field := DataSet.FindField(PName);
3756 <      if not Assigned(Field) then Continue;
3757 <      if Old then Param.AssignFieldValue(Field, Field.OldValue) else
3758 <      begin
3759 <        Value := Field.NewValue;
3760 <        if VarIsEmpty(Value) then Value := Field.OldValue;
3761 <        Param.AssignFieldValue(Field, Value);
3762 <      end;
3763 <    end;
3764 <  end;
3765 <
3766 < begin
3767 <  Result := False;
3768 <  if Assigned(OnUpdateRecord) then
3769 <  begin
3770 <    UpdateAction := uaFail;
3771 <    if Assigned(FOnUpdateRecord) then
3772 <    begin
3773 <      FOnUpdateRecord(Delta, UpdateKind, UpdateAction);
3774 <      Result := UpdateAction = uaApplied;
3775 <    end;
3776 <  end
3777 <  else if Assigned(FUpdateObject) then
3778 <  begin
3779 <    SQL := FUpdateObject.GetSQL(UpdateKind).Text;
3780 <    if SQL <> '' then
3781 <    begin
3782 <      Params := TParams.Create;
3783 <      try
3784 <        Params.ParseSQL(SQL, True);
3785 <        AssignParams(Delta, Params);
3786 <        if PSExecuteStatement(SQL, Params) = 0 then
3787 <          IBError(ibxeNoRecordsAffected, [nil]);
3788 <        Result := True;
3789 <      finally
3790 <        Params.Free;
3791 <      end;
3792 <    end;
3793 <  end;
3794 < end;
3795 <
3796 < procedure TIBCustomDataSet.PSStartTransaction;
3797 < begin
3798 <  ActivateConnection;
3799 <  Transaction.StartTransaction;
3800 < end;
3801 <
3802 < function TIBCustomDataSet.PSGetTableName: string;
3803 < begin
3804 < //  if not FInternalPrepared then
3805 < //    InternalPrepare;
3806 <  { It is possible for the FQSelectSQL to be unprepared
3807 <    with FInternalPreprepared being true (see DoBeforeTransactionEnd).
3808 <    So check the Prepared of the SelectSQL instead }
3809 <  if not FQSelect.Prepared then
3810 <    FQSelect.Prepare;
3811 <  Result := FQSelect.UniqueRelationName;
3812 < end;*)
3813 <
3814 < procedure TIBDataSet.BatchInput(InputObject: TIBBatchInput);
3815 < begin
3816 <  InternalBatchInput(InputObject);
3817 < end;
3818 <
3819 < procedure TIBDataSet.BatchOutput(OutputObject: TIBBatchOutput);
3820 < begin
3821 <  InternalBatchOutput(OutputObject);
3822 < end;
3823 <
3824 < procedure TIBDataSet.ExecSQL;
3825 < begin
3826 <  InternalExecQuery;
3827 < end;
3828 <
3829 < procedure TIBDataSet.Prepare;
3830 < begin
3831 <  InternalPrepare;
3832 < end;
3833 <
3834 < procedure TIBDataSet.UnPrepare;
3835 < begin
3836 <  InternalUnPrepare;
3837 < end;
3838 <
3839 < function TIBDataSet.GetPrepared: Boolean;
3840 < begin
3841 <  Result := InternalPrepared;
3842 < end;
3843 <
3844 < procedure TIBDataSet.InternalOpen;
3845 < begin
3846 <  ActivateConnection;
3847 <  ActivateTransaction;
3848 <  InternalSetParamsFromCursor;
3849 <  Inherited InternalOpen;
3850 < end;
3851 <
3852 < procedure TIBDataSet.SetFiltered(Value: Boolean);
3853 < begin
3854 <  if(Filtered <> Value) then
3855 <  begin
3856 <    inherited SetFiltered(value);
3857 <    if Active then
3858 <    begin
3859 <      Close;
3860 <      Open;
3861 <    end;
3862 <  end
3863 <  else
3864 <    inherited SetFiltered(value);
3865 < end;
3866 <
3867 < function TIBCustomDataSet.BookmarkValid(Bookmark: TBookmark): Boolean;
3868 < begin
3869 <  Result := false;
3870 <  if not Assigned(Bookmark) then
3871 <    exit;
3872 <  Result := PInteger(Bookmark)^ < FRecordCount;
3873 < end;
3874 <
3875 < function TIBCustomDataSet.GetFieldData(Field: TField;
3876 <  Buffer: Pointer): Boolean;
3877 < {$IFDEF TBCDFIELD_IS_BCD}
3878 < var
3879 <  lTempCurr : System.Currency;
3880 < begin
3881 <  if (Field.DataType = ftBCD) and (Buffer <> nil) then
3882 <  begin
3883 <    Result := InternalGetFieldData(Field, @lTempCurr);
3884 <    if Result then
3885 <      CurrToBCD(lTempCurr, TBCD(Buffer^), 32, Field.Size);
3886 <  end
3887 <  else
3888 < {$ELSE}
3889 < begin
3890 < {$ENDIF}
3891 <    Result := InternalGetFieldData(Field, Buffer);
3892 < end;
3893 <
3894 < function TIBCustomDataSet.GetFieldData(Field: TField; Buffer: Pointer;
3895 <  NativeFormat: Boolean): Boolean;
3896 < begin
3897 <  if (Field.DataType = ftBCD) and not NativeFormat then
3898 <    Result := InternalGetFieldData(Field, Buffer)
3899 <  else
3900 <    Result := inherited GetFieldData(Field, Buffer, NativeFormat);
3901 < end;
3902 <
3903 < procedure TIBCustomDataSet.SetFieldData(Field: TField; Buffer: Pointer);
3904 < {$IFDEF TDBDFIELD_IS_BCD}
3905 < var
3906 <  lTempCurr : System.Currency;
3907 < begin
3908 <  if (Field.DataType = ftBCD) and (Buffer <> nil) then
3909 <  begin
3910 <    BCDToCurr(TBCD(Buffer^), lTempCurr);
3911 <    InternalSetFieldData(Field, @lTempCurr);
3912 <  end
3913 <  else
3914 < {$ELSE}
3915 < begin
3916 < {$ENDIF}
3917 <    InternalSetFieldData(Field, Buffer);
3918 < end;
3919 <
3920 < procedure TIBCustomDataSet.SetFieldData(Field: TField; Buffer: Pointer;
3921 <  NativeFormat: Boolean);
3922 < begin
3923 <  if (not NativeFormat) and (Field.DataType = ftBCD) then
3924 <    InternalSetfieldData(Field, Buffer)
3925 <  else
3926 <    inherited SetFieldData(Field, buffer, NativeFormat);
3927 < end;
3928 <
3929 < { TIBDataSetUpdateObject }
3930 <
3931 < constructor TIBDataSetUpdateObject.Create(AOwner: TComponent);
3932 < begin
3933 <  inherited Create(AOwner);
3934 <  FRefreshSQL := TStringList.Create;
3935 < end;
3936 <
3937 < destructor TIBDataSetUpdateObject.Destroy;
3938 < begin
3939 <  FRefreshSQL.Free;
3940 <  inherited Destroy;
3941 < end;
3942 <
3943 < procedure TIBDataSetUpdateObject.SetRefreshSQL(Value: TStrings);
3944 < begin
3945 <  FRefreshSQL.Assign(Value);
3946 < end;
3947 <
3948 < procedure TIBDataSetUpdateObject.InternalSetParams(Query: TIBSQL; buff: PChar);
3949 < begin
3950 <  if not Assigned(DataSet) then Exit;
3951 <  DataSet.SetInternalSQLParams(Query, buff);
3952 < end;
3953 <
3954 < { TIBDSBlobStream }
3955 < constructor TIBDSBlobStream.Create(AField: TField; ABlobStream: TIBBlobStream;
3956 <                                    Mode: TBlobStreamMode);
3957 < begin
3958 <  FField := AField;
3959 <  FBlobStream := ABlobStream;
3960 <  FBlobStream.Seek(0, soFromBeginning);
3961 <  if (Mode = bmWrite) then
3962 <    FBlobStream.Truncate;
3963 < end;
3964 <
3965 < function TIBDSBlobStream.Read(var Buffer; Count: Longint): Longint;
3966 < begin
3967 <  result := FBlobStream.Read(Buffer, Count);
3968 < end;
3969 <
3970 < function TIBDSBlobStream.Seek(Offset: Longint; Origin: Word): Longint;
3971 < begin
3972 <  result := FBlobStream.Seek(Offset, Origin);
3973 < end;
3974 <
3975 < procedure TIBDSBlobStream.SetSize(NewSize: Longint);
3976 < begin
3977 <  FBlobStream.SetSize(NewSize);
3978 < end;
3979 <
3980 < function TIBDSBlobStream.Write(const Buffer; Count: Longint): Longint;
3981 < begin
3982 <  if not (FField.DataSet.State in [dsEdit, dsInsert]) then
3983 <    IBError(ibxeNotEditing, [nil]);
3984 <  TIBCustomDataSet(FField.DataSet).RecordModified(True);
3985 <  TBlobField(FField).Modified := true;
3986 <  result := FBlobStream.Write(Buffer, Count);
3987 <  TIBCustomDataSet(FField.DataSet).DataEvent(deFieldChange, PtrInt(FField));
3988 < end;
3989 <
3990 < { TIBGenerator }
3991 <
3992 < procedure TIBGenerator.SetIncrement(const AValue: integer);
3993 < begin
3994 <  if AValue < 0 then
3995 <     raise Exception.Create('A Generator Increment cannot be negative');
3996 <  FIncrement := AValue
3997 < end;
3998 <
3999 < function TIBGenerator.GetNextValue(ADatabase: TIBDatabase;
4000 <  ATransaction: TIBTransaction): integer;
4001 < begin
4002 <  with TIBSQL.Create(nil) do
4003 <  try
4004 <    Database := ADatabase;
4005 <    Transaction := ATransaction;
4006 <    if not assigned(Database) then
4007 <       IBError(ibxeCannotSetDatabase,[]);
4008 <    if not assigned(Transaction) then
4009 <       IBError(ibxeCannotSetTransaction,[]);
4010 <    with Transaction do
4011 <      if not InTransaction then StartTransaction;
4012 <    SQL.Text := Format('Select Gen_ID(%s,%d) as ID From RDB$Database',[FGeneratorName,Increment]);
4013 <    Prepare;
4014 <    ExecQuery;
4015 <    try
4016 <      Result := FieldByName('ID').AsInteger
4017 <    finally
4018 <      Close
4019 <    end;
4020 <  finally
4021 <    Free
4022 <  end;
4023 < end;
4024 <
4025 < constructor TIBGenerator.Create(Owner: TIBCustomDataSet);
4026 < begin
4027 <  FOwner := Owner;
4028 <  FIncrement := 1;
4029 < end;
4030 <
4031 <
4032 < procedure TIBGenerator.Apply;
4033 < begin
4034 <  if (FGeneratorName <> '') and (FFieldName <> '') and Owner.FieldByName(FFieldName).IsNull then
4035 <    Owner.FieldByName(FFieldName).AsInteger := GetNextValue(Owner.Database,Owner.Transaction);
4036 < end;
4037 <
4038 < end.
1 > {************************************************************************}
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                                                 }
31 > {                                                                        }
32 > {************************************************************************}
33 >
34 > unit IBCustomDataSet;
35 >
36 > {$Mode Delphi}
37 >
38 > {$IFDEF DELPHI}
39 > {$DEFINE TDBDFIELD_IS_BCD}
40 > {$ENDIF}
41 >
42 > interface
43 >
44 > uses
45 > {$IFDEF WINDOWS }
46 >  Windows,
47 > {$ELSE}
48 >  unix,
49 > {$ENDIF}
50 >  SysUtils, Classes, Forms, Controls, IBDatabase,
51 >  IBExternals, IB, IBHeader,  IBSQL, Db,
52 >  IBUtils, IBBlob;
53 >
54 > const
55 >  BufferCacheSize    =  1000;  { Allocate cache in this many record chunks}
56 >  UniCache           =  2;     { Uni-directional cache is 2 records big }
57 >
58 > type
59 >  TIBCustomDataSet = class;
60 >  TIBDataSet = class;
61 >
62 >  { TIBDataSetUpdateObject }
63 >
64 >  TIBDataSetUpdateObject = class(TComponent)
65 >  private
66 >    FRefreshSQL: TStrings;
67 >    procedure SetRefreshSQL(value: TStrings);
68 >  protected
69 >    function GetDataSet: TIBCustomDataSet; virtual; abstract;
70 >    procedure SetDataSet(ADataSet: TIBCustomDataSet); virtual; abstract;
71 >    procedure Apply(UpdateKind: TUpdateKind; buff: PChar); virtual; abstract;
72 >    function GetSQL(UpdateKind: TUpdateKind): TStrings; virtual; abstract;
73 >    procedure InternalSetParams(Query: TIBSQL; buff: PChar);
74 >    property DataSet: TIBCustomDataSet read GetDataSet write SetDataSet;
75 >  public
76 >    constructor Create(AOwner: TComponent); override;
77 >    destructor Destroy; override;
78 >  published
79 >    property RefreshSQL: TStrings read FRefreshSQL write SetRefreshSQL;
80 >  end;
81 >
82 >  TBlobDataArray = array[0..0] of TIBBlobStream;
83 >  PBlobDataArray = ^TBlobDataArray;
84 >
85 >  { TIBCustomDataSet }
86 >  TFieldData = record
87 >    fdDataType: Short;
88 >    fdDataScale: Short;
89 >    fdNullable: Boolean;
90 >    fdIsNull: Boolean;
91 >    fdDataSize: Short;
92 >    fdDataLength: Short;
93 >    fdDataOfs: Integer;
94 >  end;
95 >  PFieldData = ^TFieldData;
96 >
97 >  TCachedUpdateStatus = (
98 >                         cusUnmodified, cusModified, cusInserted,
99 >                         cusDeleted, cusUninserted
100 >                        );
101 >  TIBDBKey = record
102 >    DBKey: array[0..7] of Byte;
103 >  end;
104 >  PIBDBKey = ^TIBDBKey;
105 >
106 >  TRecordData = record
107 >    rdBookmarkFlag: TBookmarkFlag;
108 >    rdFieldCount: Short;
109 >    rdRecordNumber: Integer;
110 >    rdCachedUpdateStatus: TCachedUpdateStatus;
111 >    rdUpdateStatus: TUpdateStatus;
112 >    rdSavedOffset: DWORD;
113 >    rdDBKey: TIBDBKey;
114 >    rdFields: array[1..1] of TFieldData;
115 >  end;
116 >  PRecordData = ^TRecordData;
117 >
118 >  { TIBStringField allows us to have strings longer than 8196 }
119 >
120 >  TIBStringField = class(TStringField)
121 >  public
122 >    constructor create(AOwner: TComponent); override;
123 >    class procedure CheckTypeSize(Value: Integer); override;
124 >    function GetAsString: string; override;
125 >    function GetAsVariant: Variant; override;
126 >    function GetValue(var Value: string): Boolean;
127 >    procedure SetAsString(const Value: string); override;
128 >  end;
129 >
130 >  { TIBBCDField }
131 >  {  Actually, there is no BCD involved in this type,
132 >     instead it deals with currency types.
133 >     In IB, this is an encapsulation of Numeric (x, y)
134 >     where x < 18 and y <= 4.
135 >     Note: y > 4 will default to Floats
136 >  }
137 >  TIBBCDField = class(TBCDField)
138 >  protected
139 >    class procedure CheckTypeSize(Value: Integer); override;
140 >    function GetAsCurrency: Currency; override;
141 >    function GetAsString: string; override;
142 >    function GetAsVariant: Variant; override;
143 >    function GetDataSize: Integer; override;
144 >  public
145 >    constructor Create(AOwner: TComponent); override;
146 >  published
147 >    property Size default 8;
148 >  end;
149 >
150 >  TIBDataLink = class(TDetailDataLink)
151 >  private
152 >    FDataSet: TIBCustomDataSet;
153 >  protected
154 >    procedure ActiveChanged; override;
155 >    procedure RecordChanged(Field: TField); override;
156 >    function GetDetailDataSet: TDataSet; override;
157 >    procedure CheckBrowseMode; override;
158 >  public
159 >    constructor Create(ADataSet: TIBCustomDataSet);
160 >    destructor Destroy; override;
161 >  end;
162 >
163 >  TIBGeneratorApplyOnEvent = (gaeOnNewRecord,gaeOnPostRecord);
164 >
165 >  { TIBGenerator }
166 >
167 >  TIBGenerator = class(TPersistent)
168 >  private
169 >    FOwner: TIBCustomDataSet;
170 >    FApplyOnEvent: TIBGeneratorApplyOnEvent;
171 >    FFieldName: string;
172 >    FGeneratorName: string;
173 >    FIncrement: integer;
174 >    procedure SetIncrement(const AValue: integer);
175 >  protected
176 >    function GetNextValue(ADatabase: TIBDatabase; ATransaction: TIBTransaction): integer;
177 >  public
178 >    constructor Create(Owner: TIBCustomDataSet);
179 >    procedure Apply;
180 >    property Owner: TIBCustomDataSet read FOwner;
181 >  published
182 >    property Generator: string read FGeneratorName write FGeneratorName;
183 >    property Field: string read FFieldName write FFieldName;
184 >    property Increment: integer read FIncrement write SetIncrement default 1;
185 >    property ApplyOnEvent: TIBGeneratorApplyOnEvent read FApplyOnEvent write FApplyOnEvent;
186 >  end;
187 >
188 >  { TIBCustomDataSet }
189 >  TIBUpdateAction = (uaFail, uaAbort, uaSkip, uaRetry, uaApply, uaApplied);
190 >
191 >  TIBUpdateErrorEvent = procedure(DataSet: TDataSet; E: EDatabaseError;
192 >                                 UpdateKind: TUpdateKind; var UpdateAction: TIBUpdateAction)
193 >                                 of object;
194 >  TIBUpdateRecordEvent = procedure(DataSet: TDataSet; UpdateKind: TUpdateKind;
195 >                                   var UpdateAction: TIBUpdateAction) of object;
196 >
197 >  TIBUpdateRecordTypes = set of TCachedUpdateStatus;
198 >
199 >  TIBCustomDataSet = class(TDataset)
200 >  private
201 >    FGeneratorField: TIBGenerator;
202 >    FNeedsRefresh: Boolean;
203 >    FForcedRefresh: Boolean;
204 >    FDidActivate: Boolean;
205 >    FIBLoaded: Boolean;
206 >    FBase: TIBBase;
207 >    FBlobCacheOffset: Integer;
208 >    FBlobStreamList: TList;
209 >    FBufferChunks: Integer;
210 >    FBufferCache,
211 >    FOldBufferCache: PChar;
212 >    FBufferChunkSize,
213 >    FCacheSize,
214 >    FOldCacheSize: Integer;
215 >    FFilterBuffer: PChar;
216 >    FBPos,
217 >    FOBPos,
218 >    FBEnd,
219 >    FOBEnd: DWord;
220 >    FCachedUpdates: Boolean;
221 >    FCalcFieldsOffset: Integer;
222 >    FCurrentRecord: Long;
223 >    FDeletedRecords: Long;
224 >    FModelBuffer,
225 >    FOldBuffer: PChar;
226 >    FOpen: Boolean;
227 >    FInternalPrepared: Boolean;
228 >    FQDelete,
229 >    FQInsert,
230 >    FQRefresh,
231 >    FQSelect,
232 >    FQModify: TIBSQL;
233 >    FRecordBufferSize: Integer;
234 >    FRecordCount: Integer;
235 >    FRecordSize: Integer;
236 >    FUniDirectional: Boolean;
237 >    FUpdateMode: TUpdateMode;
238 >    FUpdateObject: TIBDataSetUpdateObject;
239 >    FParamCheck: Boolean;
240 >    FUpdatesPending: Boolean;
241 >    FUpdateRecordTypes: TIBUpdateRecordTypes;
242 >    FMappedFieldPosition: array of Integer;
243 >    FDataLink: TIBDataLink;
244 >
245 >    FBeforeDatabaseDisconnect,
246 >    FAfterDatabaseDisconnect,
247 >    FDatabaseFree: TNotifyEvent;
248 >    FOnUpdateError: TIBUpdateErrorEvent;
249 >    FOnUpdateRecord: TIBUpdateRecordEvent;
250 >    FBeforeTransactionEnd,
251 >    FAfterTransactionEnd,
252 >    FTransactionFree: TNotifyEvent;
253 >
254 >    function GetSelectStmtHandle: TISC_STMT_HANDLE;
255 >    procedure SetUpdateMode(const Value: TUpdateMode);
256 >    procedure SetUpdateObject(Value: TIBDataSetUpdateObject);
257 >
258 >    function AdjustCurrentRecord(Buffer: Pointer; GetMode: TGetMode): TGetResult;
259 >    procedure AdjustRecordOnInsert(Buffer: Pointer);
260 >    function CanEdit: Boolean;
261 >    function CanInsert: Boolean;
262 >    function CanDelete: Boolean;
263 >    function CanRefresh: Boolean;
264 >    procedure CheckEditState;
265 >    procedure ClearBlobCache;
266 >    procedure CopyRecordBuffer(Source, Dest: Pointer);
267 >    procedure DoBeforeDatabaseDisconnect(Sender: TObject);
268 >    procedure DoAfterDatabaseDisconnect(Sender: TObject);
269 >    procedure DoDatabaseFree(Sender: TObject);
270 >    procedure DoBeforeTransactionEnd(Sender: TObject);
271 >    procedure DoAfterTransactionEnd(Sender: TObject);
272 >    procedure DoTransactionFree(Sender: TObject);
273 >    procedure FetchCurrentRecordToBuffer(Qry: TIBSQL; RecordNumber: Integer;
274 >                                         Buffer: PChar);
275 >    function GetDatabase: TIBDatabase;
276 >    function GetDBHandle: PISC_DB_HANDLE;
277 >    function GetDeleteSQL: TStrings;
278 >    function GetInsertSQL: TStrings;
279 >    function GetSQLParams: TIBXSQLDA;
280 >    function GetRefreshSQL: TStrings;
281 >    function GetSelectSQL: TStrings;
282 >    function GetStatementType: TIBSQLTypes;
283 >    function GetModifySQL: TStrings;
284 >    function GetTransaction: TIBTransaction;
285 >    function GetTRHandle: PISC_TR_HANDLE;
286 >    procedure InternalDeleteRecord(Qry: TIBSQL; Buff: Pointer); virtual;
287 >    function InternalLocate(const KeyFields: string; const KeyValues: Variant;
288 >                            Options: TLocateOptions): Boolean; virtual;
289 >    procedure InternalPostRecord(Qry: TIBSQL; Buff: Pointer); virtual;
290 >    procedure InternalRevertRecord(RecordNumber: Integer); virtual;
291 >    function IsVisible(Buffer: PChar): Boolean;
292 >    procedure SaveOldBuffer(Buffer: PChar);
293 >    procedure SetBufferChunks(Value: Integer);
294 >    procedure SetDatabase(Value: TIBDatabase);
295 >    procedure SetDeleteSQL(Value: TStrings);
296 >    procedure SetInsertSQL(Value: TStrings);
297 >    procedure SetInternalSQLParams(Qry: TIBSQL; Buffer: Pointer);
298 >    procedure SetRefreshSQL(Value: TStrings);
299 >    procedure SetSelectSQL(Value: TStrings);
300 >    procedure SetModifySQL(Value: TStrings);
301 >    procedure SetTransaction(Value: TIBTransaction);
302 >    procedure SetUpdateRecordTypes(Value: TIBUpdateRecordTypes);
303 >    procedure SetUniDirectional(Value: Boolean);
304 >    procedure RefreshParams;
305 >    procedure SQLChanging(Sender: TObject); virtual;
306 >    function AdjustPosition(FCache: PChar; Offset: DWORD;
307 >                            Origin: Integer): DWORD;
308 >    procedure ReadCache(FCache: PChar; Offset: DWORD; Origin: Integer;
309 >                       Buffer: PChar);
310 >    procedure ReadRecordCache(RecordNumber: Integer; Buffer: PChar;
311 >                              ReadOldBuffer: Boolean);
312 >    procedure WriteCache(FCache: PChar; Offset: DWORD; Origin: Integer;
313 >                        Buffer: PChar);
314 >    procedure WriteRecordCache(RecordNumber: Integer; Buffer: PChar);
315 >    function InternalGetRecord(Buffer: PChar; GetMode: TGetMode;
316 >                       DoCheck: Boolean): TGetResult; virtual;
317 >
318 >  protected
319 >    procedure ActivateConnection;
320 >    function ActivateTransaction: Boolean;
321 >    procedure DeactivateTransaction;
322 >    procedure CheckDatasetClosed;
323 >    procedure CheckDatasetOpen;
324 >    function GetActiveBuf: PChar;
325 >    procedure InternalBatchInput(InputObject: TIBBatchInput); virtual;
326 >    procedure InternalBatchOutput(OutputObject: TIBBatchOutput); virtual;
327 >    procedure InternalPrepare; virtual;
328 >    procedure InternalUnPrepare; virtual;
329 >    procedure InternalExecQuery; virtual;
330 >    procedure InternalRefreshRow; virtual;
331 >    procedure InternalSetParamsFromCursor; virtual;
332 >    procedure CheckNotUniDirectional;
333 >
334 > (*    { IProviderSupport }
335 >    procedure PSEndTransaction(Commit: Boolean); override;
336 >    function PSExecuteStatement(const ASQL: string; AParams: TParams;
337 >      ResultSet: Pointer = nil): Integer; override;
338 >    function PsGetTableName: string; override;
339 >    function PSGetQuoteChar: string; override;
340 >    function PSGetUpdateException(E: Exception; Prev: EUpdateError): EUpdateError; override;
341 >    function PSInTransaction: Boolean; override;
342 >    function PSIsSQLBased: Boolean; override;
343 >    function PSIsSQLSupported: Boolean; override;
344 >    procedure PSStartTransaction; override;
345 >    procedure PSReset; override;
346 >    function PSUpdateRecord(UpdateKind: TUpdateKind; Delta: TDataSet): Boolean; override;
347 > *)
348 >    { TDataSet support }
349 >    procedure InternalInsert; override;
350 >    procedure InitRecord(Buffer: PChar); override;
351 >    procedure Disconnect; virtual;
352 >    function ConstraintsStored: Boolean;
353 >    procedure ClearCalcFields(Buffer: PChar); override;
354 >    function AllocRecordBuffer: PChar; override;
355 >    procedure DoBeforeDelete; override;
356 >    procedure DoBeforeEdit; override;
357 >    procedure DoBeforeInsert; override;
358 >    procedure DoAfterInsert; override;
359 >    procedure DoBeforePost; override;
360 >    procedure FreeRecordBuffer(var Buffer: PChar); override;
361 >    procedure GetBookmarkData(Buffer: PChar; Data: Pointer); override;
362 >    function GetBookmarkFlag(Buffer: PChar): TBookmarkFlag; override;
363 >    function GetCanModify: Boolean; override;
364 >    function GetDataSource: TDataSource; override;
365 >    function GetFieldClass(FieldType: TFieldType): TFieldClass; override;
366 >    function GetRecNo: Integer; override;
367 >    function GetRecord(Buffer: PChar; GetMode: TGetMode;
368 >                       DoCheck: Boolean): TGetResult; override;
369 >    function GetRecordCount: Integer; override;
370 >    function GetRecordSize: Word; override;
371 >    procedure InternalAddRecord(Buffer: Pointer; Append: Boolean); override;
372 >    procedure InternalCancel; override;
373 >    procedure InternalClose; override;
374 >    procedure InternalDelete; override;
375 >    procedure InternalFirst; override;
376 >    function InternalGetFieldData(Field: TField; Buffer: Pointer): Boolean; virtual;
377 >    procedure InternalGotoBookmark(Bookmark: Pointer); override;
378 >    procedure InternalHandleException; override;
379 >    procedure InternalInitFieldDefs; override;
380 >    procedure InternalInitRecord(Buffer: PChar); override;
381 >    procedure InternalLast; override;
382 >    procedure InternalOpen; override;
383 >    procedure InternalPost; override;
384 >    procedure InternalRefresh; override;
385 >    procedure InternalSetFieldData(Field: TField; Buffer: Pointer); virtual;
386 >    procedure InternalSetToRecord(Buffer: PChar); override;
387 >    function IsCursorOpen: Boolean; override;
388 >    procedure ReQuery;
389 >    procedure SetBookmarkFlag(Buffer: PChar; Value: TBookmarkFlag); override;
390 >    procedure SetBookmarkData(Buffer: PChar; Data: Pointer); override;
391 >    procedure SetCachedUpdates(Value: Boolean);
392 >    procedure SetDataSource(Value: TDataSource);
393 >    procedure SetFieldData(Field : TField; Buffer : Pointer); override;
394 >    procedure SetFieldData(Field : TField; Buffer : Pointer;
395 >      NativeFormat : Boolean); overload; override;
396 >    procedure SetRecNo(Value: Integer); override;
397 >
398 >  protected
399 >    {Likely to be made public by descendant classes}
400 >    property SQLParams: TIBXSQLDA read GetSQLParams;
401 >    property Params: TIBXSQLDA read GetSQLParams;
402 >    property InternalPrepared: Boolean read FInternalPrepared;
403 >    property QDelete: TIBSQL read FQDelete;
404 >    property QInsert: TIBSQL read FQInsert;
405 >    property QRefresh: TIBSQL read FQRefresh;
406 >    property QSelect: TIBSQL read FQSelect;