ViewVC Help
View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing
root/public/ibx/trunk/runtime/IBCustomDataSet.pas
(Generate patch)

Comparing ibx/trunk/runtime/IBCustomDataSet.pas (file contents):
Revision 7 by tony, Sun Aug 5 18:28:19 2012 UTC vs.
Revision 17 by tony, Sat Dec 28 19:22:24 2013 UTC

# 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 > 20600 }
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 > 20600 }
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 > 20600 }
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 > 20600 }
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 > 20600 }
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 <> '')  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;
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 >= 20700 }
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 >= 20700 }
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 >= 20700 }
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 >= 20700 }
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 >= 20700 }
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.

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines