[ViewVC] Diff of: public/ibx/trunk/runtime/IBCustomDataSet.pas

Comparing ibx/trunk/runtime/IBCustomDataSet.pas (file contents):
Revision 5 by tony, Fri Feb 18 16:26:16 2011 UTC vs.
Revision 106 by tony, Thu Jan 18 14:37:35 2018 UTC

#	Line 24 \| Line 24
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 - 2015 }
31	+	{ }
32		{************************************************************************}
33
34		unit IBCustomDataSet;
35
36	+	{$R-}
37	+
38	+	{$IFDEF FPC}
39		{$Mode Delphi}
40	+	{$codepage UTF8}
41	+	{$ENDIF}
42	+
43	+	{$IFDEF DELPHI}
44	+	{$DEFINE TDBDFIELD_IS_BCD}
45	+	{$ENDIF}
46
47		interface
48
49		uses
50	<	{$IFDEF LINUX }
37	<	unix,
38	<	{$ELSE}
50	>	{$IFDEF WINDOWS }
51		Windows,
52	+	{$ELSE}
53	+	unix,
54		{$ENDIF}
55	<	SysUtils, Classes, Forms, Controls, IBDatabase,
56	<	IBExternals, IB, IBHeader, IBSQL, Db,
43	<	IBUtils, IBBlob;
55	>	SysUtils, Classes, IBDatabase, IBExternals, IB, IBSQL, Db,
56	>	IBUtils, IBBlob, IBSQLParser, IBDatabaseInfo;
57
58		const
59		BufferCacheSize = 1000; { Allocate cache in this many record chunks}
#	Line 50 \| Line 63 \| type
63		TIBCustomDataSet = class;
64		TIBDataSet = class;
65
66	+	{ TIBDataSetUpdateObject }
67	+
68		TIBDataSetUpdateObject = class(TComponent)
69		private
70		FRefreshSQL: TStrings;
#	Line 57 \| Line 72 \| type
72		protected
73		function GetDataSet: TIBCustomDataSet; virtual; abstract;
74		procedure SetDataSet(ADataSet: TIBCustomDataSet); virtual; abstract;
75	<	procedure Apply(UpdateKind: TUpdateKind); virtual; abstract;
75	>	procedure Apply(UpdateKind: TUpdateKind; buff: PChar); virtual; abstract;
76		function GetSQL(UpdateKind: TUpdateKind): TStrings; virtual; abstract;
77	+	procedure InternalSetParams(Params: ISQLParams; buff: PChar); overload;
78	+	procedure InternalSetParams(Query: TIBSQL; buff: PChar); overload;
79	+	procedure UpdateRecordFromQuery(QryResults: IResults; Buffer: PChar);
80		property DataSet: TIBCustomDataSet read GetDataSet write SetDataSet;
81		public
82		constructor Create(AOwner: TComponent); override;
#	Line 69 \| Line 87 \| type
87
88		TBlobDataArray = array[0..0] of TIBBlobStream;
89		PBlobDataArray = ^TBlobDataArray;
90	+	TIBArrayField = class;
91
92	<	{ TIBCustomDataSet }
93	<	TFieldData = record
94	<	fdDataType: Short;
95	<	fdDataScale: Short;
96	<	fdNullable: Boolean;
97	<	fdIsNull: Boolean;
98	<	fdDataSize: Short;
99	<	fdDataLength: Short;
100	<	fdDataOfs: Integer;
92	>	{ TIBArray }
93	>
94	>	{Wrapper class to support array cache in TIBCustomDataset and event handling}
95	>
96	>	TIBArray = class
97	>	private
98	>	FArray: IArray;
99	>	FRecNo: integer;
100	>	FField: TIBArrayField;
101	>	procedure EventHandler(Sender: IArray; Reason: TArrayEventReason);
102	>	public
103	>	constructor Create(aField: TIBArrayField; anArray: IArray);
104	>	destructor Destroy; override;
105	>	property ArrayIntf: IArray read FArray;
106		end;
107	<	PFieldData = ^TFieldData;
107	>
108	>	TArrayDataArray = array [0..0] of TIBArray;
109	>	PArrayDataArray = ^TArrayDataArray;
110	>
111	>	{ TIBCustomDataSet }
112
113		TCachedUpdateStatus = (
114		cusUnmodified, cusModified, cusInserted,
#	Line 91 \| Line 119 \| type
119		end;
120		PIBDBKey = ^TIBDBKey;
121
122	+	PFieldData = ^TFieldData;
123	+	TFieldData = record
124	+	fdIsNull: Boolean;
125	+	fdDataLength: Short;
126	+	end;
127	+
128	+	PColumnData = ^TColumnData;
129	+	TColumnData = record
130	+	fdDataType: Short;
131	+	fdDataScale: Short;
132	+	fdNullable: Boolean;
133	+	fdDataSize: Short;
134	+	fdDataOfs: Integer;
135	+	fdCodePage: TSystemCodePage;
136	+	end;
137	+
138	+	PFieldColumns = ^TFieldColumns;
139	+	TFieldColumns = array[1..1] of TColumnData;
140	+
141		TRecordData = record
142		rdBookmarkFlag: TBookmarkFlag;
143		rdFieldCount: Short;
144	<	rdRecordNumber: Long;
144	>	rdRecordNumber: Integer;
145		rdCachedUpdateStatus: TCachedUpdateStatus;
146		rdUpdateStatus: TUpdateStatus;
147		rdSavedOffset: DWORD;
#	Line 103 \| Line 150 \| type
150		end;
151		PRecordData = ^TRecordData;
152
153	+	{ TIBArrayField }
154	+
155	+	TIBArrayField = class(TField)
156	+	private
157	+	FArrayBounds: TArrayBounds;
158	+	FArrayDimensions: integer;
159	+	FRelationName: string;
160	+	FCacheOffset: word;
161	+	function GetArrayID: TISC_QUAD;
162	+	function GetArrayIntf: IArray;
163	+	procedure SetArrayIntf(AValue: IArray);
164	+	protected
165	+	class procedure CheckTypeSize(AValue: Longint); override;
166	+	function GetAsString: string; override;
167	+	function GetDataSize: Integer; override;
168	+	procedure Bind(Binding: Boolean); override;
169	+	public
170	+	constructor Create(AOwner: TComponent); override;
171	+	function CreateArray: IArray;
172	+	property ArrayID: TISC_QUAD read GetArrayID;
173	+	property ArrayIntf: IArray read GetArrayIntf write SetArrayIntf;
174	+	property ArrayDimensions: integer read FArrayDimensions write FArrayDimensions;
175	+	property ArrayBounds: TArrayBounds read FArrayBounds write FArrayBounds;
176	+	end;
177	+
178		{ TIBStringField allows us to have strings longer than 8196 }
179
180		TIBStringField = class(TStringField)
181	+	private
182	+	FCharacterSetName: RawByteString;
183	+	FCharacterSetSize: integer;
184	+	FAutoFieldSize: boolean;
185	+	FCodePage: TSystemCodePage;
186	+	FDataSize: integer;
187	+	protected
188	+	procedure Bind(Binding: Boolean); override;
189	+	function GetDataSize: Integer; override;
190		public
191	<	constructor create(AOwner: TComponent); override;
191	>	constructor Create(aOwner: TComponent); override;
192		class procedure CheckTypeSize(Value: Integer); override;
193		function GetAsString: string; override;
194		function GetAsVariant: Variant; override;
195		function GetValue(var Value: string): Boolean;
196		procedure SetAsString(const Value: string); override;
197	+	property CharacterSetName: RawByteString read FCharacterSetName write FCharacterSetName;
198	+	property CharacterSetSize: integer read FCharacterSetSize write FCharacterSetSize;
199	+	property CodePage: TSystemCodePage read FCodePage write FCodePage;
200	+	published
201	+	property AutoFieldSize: boolean read FAutoFieldSize write FAutoFieldSize default true;
202		end;
203
204		{ TIBBCDField }
#	Line 123 \| Line 209 \| type
209		Note: y > 4 will default to Floats
210		}
211		TIBBCDField = class(TBCDField)
212	+	private
213	+	FIdentityColumn: boolean;
214		protected
215	+	procedure Bind(Binding: Boolean); override;
216		class procedure CheckTypeSize(Value: Integer); override;
217		function GetAsCurrency: Currency; override;
218		function GetAsString: string; override;
#	Line 131 \| Line 220 \| type
220		function GetDataSize: Integer; override;
221		public
222		constructor Create(AOwner: TComponent); override;
223	+	property IdentityColumn: boolean read FIdentityColumn;
224		published
225		property Size default 8;
226		end;
227
228	+	{The following integer field types extend the built in versions to enable IBX appplications
229	+	to check for an Identity column}
230	+
231	+	{ TIBSmallintField }
232	+
233	+	TIBSmallintField = class(TSmallintField)
234	+	private
235	+	FIdentityColumn: boolean;
236	+	protected
237	+	procedure Bind(Binding: Boolean); override;
238	+	public
239	+	property IdentityColumn: boolean read FIdentityColumn;
240	+	end;
241	+
242	+	{ TIBIntegerField }
243	+
244	+	TIBIntegerField = class(TIntegerField)
245	+	private
246	+	FIdentityColumn: boolean;
247	+	protected
248	+	procedure Bind(Binding: Boolean); override;
249	+	public
250	+	property IdentityColumn: boolean read FIdentityColumn;
251	+	end;
252	+
253	+	{ TIBLargeIntField }
254	+
255	+	TIBLargeIntField = class(TLargeIntField)
256	+	private
257	+	FIdentityColumn: boolean;
258	+	protected
259	+	procedure Bind(Binding: Boolean); override;
260	+	public
261	+	property IdentityColumn: boolean read FIdentityColumn;
262	+	end;
263	+
264	+	{TIBMemoField}
265	+	{Allows us to show truncated text in DBGrids and anything else that uses
266	+	DisplayText}
267	+
268	+	TIBMemoField = class(TMemoField)
269	+	private
270	+	FCharacterSetName: RawByteString;
271	+	FCharacterSetSize: integer;
272	+	FDisplayTextAsClassName: boolean;
273	+	function GetTruncatedText: string;
274	+	protected
275	+	procedure Bind(Binding: Boolean); override;
276	+	function GetAsString: string; override;
277	+	function GetDefaultWidth: Longint; override;
278	+	procedure GetText(var AText: string; ADisplayText: Boolean); override;
279	+	procedure SetAsString(const AValue: string); override;
280	+	public
281	+	constructor Create(AOwner: TComponent); override;
282	+	property CharacterSetName: RawByteString read FCharacterSetName write FCharacterSetName;
283	+	property CharacterSetSize: integer read FCharacterSetSize write FCharacterSetSize;
284	+	published
285	+	property DisplayTextAsClassName: boolean read FDisplayTextAsClassName
286	+	write FDisplayTextAsClassName;
287	+	private
288	+	FCodePage: TSystemCodePage;
289	+	FFCodePage: TSystemCodePage;
290	+	public
291	+	property CodePage: TSystemCodePage read FFCodePage write FFCodePage;
292	+	end;
293	+
294		TIBDataLink = class(TDetailDataLink)
295		private
296		FDataSet: TIBCustomDataSet;
#	Line 159 \| Line 315 \| type
315		FFieldName: string;
316		FGeneratorName: string;
317		FIncrement: integer;
318	<	function GetSelectSQL: string;
318	>	FQuery: TIBSQL;
319	>	function GetDatabase: TIBDatabase;
320	>	function GetTransaction: TIBTransaction;
321	>	procedure SetDatabase(AValue: TIBDatabase);
322	>	procedure SetGeneratorName(AValue: string);
323		procedure SetIncrement(const AValue: integer);
324	+	procedure SetTransaction(AValue: TIBTransaction);
325	+	procedure SetQuerySQL;
326		protected
327	<	function GetNextValue(ADatabase: TIBDatabase; ATransaction: TIBTransaction): integer;
327	>	function GetNextValue: integer;
328		public
329		constructor Create(Owner: TIBCustomDataSet);
330	+	destructor Destroy; override;
331		procedure Apply;
332		property Owner: TIBCustomDataSet read FOwner;
333	<	property SelectSQL: string read GetSelectSQL;
333	>	property Database: TIBDatabase read GetDatabase write SetDatabase;
334	>	property Transaction: TIBTransaction read GetTransaction write SetTransaction;
335		published
336	<	property GeneratorName: string read FGeneratorName write FGeneratorName;
337	<	property FieldName: string read FFieldName write FFieldName;
336	>	property Generator: string read FGeneratorName write SetGeneratorName;
337	>	property Field: string read FFieldName write FFieldName;
338		property Increment: integer read FIncrement write SetIncrement default 1;
339		property ApplyOnEvent: TIBGeneratorApplyOnEvent read FApplyOnEvent write FApplyOnEvent;
340		end;
341
342	+	{TIBControlLink - Allows IB Aware controls to react to dataset state changes}
343	+
344	+	TIBControlLink = class
345	+	private
346	+	FTIBDataSet: TIBCustomDataSet;
347	+	procedure SetIBDataSet(AValue: TIBCustomDataSet);
348	+	protected
349	+	procedure UpdateSQL(Sender: TObject); virtual;
350	+	procedure UpdateParams(Sender: TObject); virtual;
351	+	public
352	+	destructor Destroy; override;
353	+	property IBDataSet: TIBCustomDataSet read FTIBDataSet write SetIBDataSet;
354	+	end;
355	+
356	+	TIBAutoCommit = (acDisabled, acCommitRetaining);
357	+
358		{ TIBCustomDataSet }
359	+
360		TIBUpdateAction = (uaFail, uaAbort, uaSkip, uaRetry, uaApply, uaApplied);
361
362		TIBUpdateErrorEvent = procedure(DataSet: TDataSet; E: EDatabaseError;
363	<	UpdateKind: TUpdateKind; var UpdateAction: TIBUpdateAction)
363	>	UpdateKind: TUpdateKind; var TheUpdateAction: TIBUpdateAction)
364		of object;
365		TIBUpdateRecordEvent = procedure(DataSet: TDataSet; UpdateKind: TUpdateKind;
366		var UpdateAction: TIBUpdateAction) of object;
367
368		TIBUpdateRecordTypes = set of TCachedUpdateStatus;
369
370	+	TDataSetCloseAction = (dcDiscardChanges, dcSaveChanges);
371	+
372	+	TOnValidatePost = procedure (Sender: TObject; var CancelPost: boolean) of object;
373	+
374		TIBCustomDataSet = class(TDataset)
375		private
376	<	FGenerator: TIBGenerator;
376	>	FAllowAutoActivateTransaction: Boolean;
377	>	FArrayFieldCount: integer;
378	>	FArrayCacheOffset: integer;
379	>	FAutoCommit: TIBAutoCommit;
380	>	FGenerateParamNames: Boolean;
381	>	FGeneratorField: TIBGenerator;
382		FNeedsRefresh: Boolean;
383		FForcedRefresh: Boolean;
384		FDidActivate: Boolean;
195	–	FIBLoaded: Boolean;
385		FBase: TIBBase;
386		FBlobCacheOffset: Integer;
387		FBlobStreamList: TList;
388	+	FArrayList: TList;
389		FBufferChunks: Integer;
390		FBufferCache,
391		FOldBufferCache: PChar;
#	Line 213 \| Line 403 \| type
403		FDeletedRecords: Long;
404		FModelBuffer,
405		FOldBuffer: PChar;
406	+	FOnValidatePost: TOnValidatePost;
407		FOpen: Boolean;
408		FInternalPrepared: Boolean;
409		FQDelete,
#	Line 220 \| Line 411 \| type
411		FQRefresh,
412		FQSelect,
413		FQModify: TIBSQL;
414	+	FDatabaseInfo: TIBDatabaseInfo;
415		FRecordBufferSize: Integer;
416		FRecordCount: Integer;
417		FRecordSize: Integer;
418	+	FDataSetCloseAction: TDataSetCloseAction;
419		FUniDirectional: Boolean;
420		FUpdateMode: TUpdateMode;
421		FUpdateObject: TIBDataSetUpdateObject;
#	Line 240 \| Line 433 \| type
433		FBeforeTransactionEnd,
434		FAfterTransactionEnd,
435		FTransactionFree: TNotifyEvent;
436	<
437	<	function GetSelectStmtHandle: TISC_STMT_HANDLE;
436	>	FAliasNameMap: array of string;
437	>	FAliasNameList: array of string;
438	>	FBaseSQLSelect: TStrings;
439	>	FParser: TSelectSQLParser;
440	>	FCloseAction: TTransactionAction;
441	>	FInTransactionEnd: boolean;
442	>	FIBLinks: TList;
443	>	FFieldColumns: PFieldColumns;
444	>	procedure ColumnDataToBuffer(QryResults: IResults; ColumnIndex,
445	>	FieldIndex: integer; Buffer: PChar);
446	>	procedure InitModelBuffer(Qry: TIBSQL; Buffer: PChar);
447	>	function GetSelectStmtIntf: IStatement;
448		procedure SetUpdateMode(const Value: TUpdateMode);
449		procedure SetUpdateObject(Value: TIBDataSetUpdateObject);
450
#	Line 253 \| Line 456 \| type
456		function CanRefresh: Boolean;
457		procedure CheckEditState;
458		procedure ClearBlobCache;
459	+	procedure ClearArrayCache;
460	+	procedure ClearIBLinks;
461		procedure CopyRecordBuffer(Source, Dest: Pointer);
462		procedure DoBeforeDatabaseDisconnect(Sender: TObject);
463		procedure DoAfterDatabaseDisconnect(Sender: TObject);
464		procedure DoDatabaseFree(Sender: TObject);
465	<	procedure DoBeforeTransactionEnd(Sender: TObject);
465	>	procedure DoBeforeTransactionEnd(Sender: TObject; Action: TTransactionAction);
466		procedure DoAfterTransactionEnd(Sender: TObject);
467		procedure DoTransactionFree(Sender: TObject);
468		procedure FetchCurrentRecordToBuffer(Qry: TIBSQL; RecordNumber: Integer;
469		Buffer: PChar);
470		function GetDatabase: TIBDatabase;
266	–	function GetDBHandle: PISC_DB_HANDLE;
471		function GetDeleteSQL: TStrings;
472		function GetInsertSQL: TStrings;
473	<	function GetSQLParams: TIBXSQLDA;
473	>	function GetSQLParams: ISQLParams;
474		function GetRefreshSQL: TStrings;
475		function GetSelectSQL: TStrings;
476	<	function GetStatementType: TIBSQLTypes;
476	>	function GetStatementType: TIBSQLStatementTypes;
477		function GetModifySQL: TStrings;
478		function GetTransaction: TIBTransaction;
479	<	function GetTRHandle: PISC_TR_HANDLE;
479	>	function GetParser: TSelectSQLParser;
480		procedure InternalDeleteRecord(Qry: TIBSQL; Buff: Pointer); virtual;
481		function InternalLocate(const KeyFields: string; const KeyValues: Variant;
482		Options: TLocateOptions): Boolean; virtual;
483		procedure InternalPostRecord(Qry: TIBSQL; Buff: Pointer); virtual;
484		procedure InternalRevertRecord(RecordNumber: Integer); virtual;
485		function IsVisible(Buffer: PChar): Boolean;
486	+	procedure RegisterIBLink(Sender: TIBControlLink);
487	+	procedure UnRegisterIBLink(Sender: TIBControlLink);
488		procedure SaveOldBuffer(Buffer: PChar);
489		procedure SetBufferChunks(Value: Integer);
490		procedure SetDatabase(Value: TIBDatabase);
491		procedure SetDeleteSQL(Value: TStrings);
492		procedure SetInsertSQL(Value: TStrings);
493	<	procedure SetInternalSQLParams(Qry: TIBSQL; Buffer: Pointer);
493	>	procedure SetInternalSQLParams(Params: ISQLParams; Buffer: Pointer);
494		procedure SetRefreshSQL(Value: TStrings);
495		procedure SetSelectSQL(Value: TStrings);
496		procedure SetModifySQL(Value: TStrings);
497		procedure SetTransaction(Value: TIBTransaction);
498		procedure SetUpdateRecordTypes(Value: TIBUpdateRecordTypes);
499		procedure SetUniDirectional(Value: Boolean);
500	+	procedure UpdateRecordFromQuery(QryResults: IResults; Buffer: PChar);
501		procedure RefreshParams;
295	–	procedure SQLChanging(Sender: TObject); virtual;
502		function AdjustPosition(FCache: PChar; Offset: DWORD;
503	<	Origin: Integer): Integer;
503	>	Origin: Integer): DWORD;
504		procedure ReadCache(FCache: PChar; Offset: DWORD; Origin: Integer;
505		Buffer: PChar);
506		procedure ReadRecordCache(RecordNumber: Integer; Buffer: PChar;
#	Line 311 \| Line 517 \| type
517		procedure DeactivateTransaction;
518		procedure CheckDatasetClosed;
519		procedure CheckDatasetOpen;
520	+	function CreateParser: TSelectSQLParser; virtual;
521	+	procedure FieldDefsFromQuery(SourceQuery: TIBSQL);
522		function GetActiveBuf: PChar;
523		procedure InternalBatchInput(InputObject: TIBBatchInput); virtual;
524		procedure InternalBatchOutput(OutputObject: TIBBatchOutput); virtual;
#	Line 320 \| Line 528 \| type
528		procedure InternalRefreshRow; virtual;
529		procedure InternalSetParamsFromCursor; virtual;
530		procedure CheckNotUniDirectional;
531	+	procedure SQLChanging(Sender: TObject); virtual;
532	+	procedure SQLChanged(Sender: TObject); virtual;
533
534	<	(* { IProviderSupport }
534	>	{ IProviderSupport }
535		procedure PSEndTransaction(Commit: Boolean); override;
536		function PSExecuteStatement(const ASQL: string; AParams: TParams;
537		ResultSet: Pointer = nil): Integer; override;
#	Line 334 \| Line 544 \| type
544		procedure PSStartTransaction; override;
545		procedure PSReset; override;
546		function PSUpdateRecord(UpdateKind: TUpdateKind; Delta: TDataSet): Boolean; override;
547	<	*)
547	>
548		{ TDataSet support }
549		procedure InternalInsert; override;
550		procedure InitRecord(Buffer: PChar); override;
#	Line 343 \| Line 553 \| type
553		procedure ClearCalcFields(Buffer: PChar); override;
554		function AllocRecordBuffer: PChar; override;
555		procedure DoBeforeDelete; override;
556	+	procedure DoAfterDelete; override;
557		procedure DoBeforeEdit; override;
558	+	procedure DoAfterEdit; override;
559		procedure DoBeforeInsert; override;
560		procedure DoAfterInsert; override;
561	+	procedure DoBeforeClose; override;
562	+	procedure DoBeforeOpen; override;
563		procedure DoBeforePost; override;
564	+	procedure DoAfterPost; override;
565		procedure FreeRecordBuffer(var Buffer: PChar); override;
566		procedure GetBookmarkData(Buffer: PChar; Data: Pointer); override;
567		function GetBookmarkFlag(Buffer: PChar): TBookmarkFlag; override;
568		function GetCanModify: Boolean; override;
569		function GetDataSource: TDataSource; override;
570	+	function GetDBAliasName(FieldNo: integer): string;
571	+	function GetFieldDefFromAlias(aliasName: string): TFieldDef;
572		function GetFieldClass(FieldType: TFieldType): TFieldClass; override;
573		function GetRecNo: Integer; override;
574		function GetRecord(Buffer: PChar; GetMode: TGetMode;
575		DoCheck: Boolean): TGetResult; override;
576		function GetRecordCount: Integer; override;
577		function GetRecordSize: Word; override;
578	+	procedure InternalAutoCommit;
579		procedure InternalAddRecord(Buffer: Pointer; Append: Boolean); override;
580		procedure InternalCancel; override;
581		procedure InternalClose; override;
#	Line 375 \| Line 593 \| type
593		procedure InternalSetFieldData(Field: TField; Buffer: Pointer); virtual;
594		procedure InternalSetToRecord(Buffer: PChar); override;
595		function IsCursorOpen: Boolean; override;
596	+	procedure Loaded; override;
597		procedure ReQuery;
598		procedure SetBookmarkFlag(Buffer: PChar; Value: TBookmarkFlag); override;
599		procedure SetBookmarkData(Buffer: PChar; Data: Pointer); override;
600		procedure SetCachedUpdates(Value: Boolean);
601		procedure SetDataSource(Value: TDataSource);
602	+	procedure SetGenerateParamNames(AValue: Boolean); virtual;
603		procedure SetFieldData(Field : TField; Buffer : Pointer); override;
604		procedure SetFieldData(Field : TField; Buffer : Pointer;
605		NativeFormat : Boolean); overload; override;
#	Line 387 \| Line 607 \| type
607
608		protected
609		{Likely to be made public by descendant classes}
610	<	property SQLParams: TIBXSQLDA read GetSQLParams;
611	<	property Params: TIBXSQLDA read GetSQLParams;
610	>	property AutoCommit: TIBAutoCommit read FAutoCommit write FAutoCommit default acDisabled;
611	>	property SQLParams: ISQLParams read GetSQLParams;
612	>	property Params: ISQLParams read GetSQLParams;
613		property InternalPrepared: Boolean read FInternalPrepared;
614		property QDelete: TIBSQL read FQDelete;
615		property QInsert: TIBSQL read FQInsert;
616		property QRefresh: TIBSQL read FQRefresh;
617		property QSelect: TIBSQL read FQSelect;
618		property QModify: TIBSQL read FQModify;
619	<	property StatementType: TIBSQLTypes read GetStatementType;
620	<	property SelectStmtHandle: TISC_STMT_HANDLE read GetSelectStmtHandle;
619	>	property StatementType: TIBSQLStatementTypes read GetStatementType;
620	>	property SelectStmtHandle: IStatement read GetSelectStmtIntf;
621
622		{Likely to be made published by descendant classes}
623		property BufferChunks: Integer read FBufferChunks write SetBufferChunks;
624		property CachedUpdates: Boolean read FCachedUpdates write SetCachedUpdates;
625		property UniDirectional: Boolean read FUniDirectional write SetUniDirectional default False;
626	<	property Generator: TIBGenerator read FGenerator write FGenerator;
626	>	property GeneratorField: TIBGenerator read FGeneratorField write FGeneratorField;
627		property DeleteSQL: TStrings read GetDeleteSQL write SetDeleteSQL;
628		property InsertSQL: TStrings read GetInsertSQL write SetInsertSQL;
629		property RefreshSQL: TStrings read GetRefreshSQL write SetRefreshSQL;
#	Line 410 \| Line 631 \| type
631		property ModifySQL: TStrings read GetModifySQL write SetModifySQL;
632		property UpdateMode: TUpdateMode read FUpdateMode write SetUpdateMode default upWhereAll;
633		property ParamCheck: Boolean read FParamCheck write FParamCheck default True;
634	+	property Parser: TSelectSQLParser read GetParser;
635	+	property BaseSQLSelect: TStrings read FBaseSQLSelect;
636
637		property BeforeDatabaseDisconnect: TNotifyEvent read FBeforeDatabaseDisconnect
638		write FBeforeDatabaseDisconnect;
#	Line 423 \| Line 646 \| type
646		write FAfterTransactionEnd;
647		property TransactionFree: TNotifyEvent read FTransactionFree
648		write FTransactionFree;
649	+	property OnValidatePost: TOnValidatePost read FOnValidatePost write FOnValidatePost;
650
651		public
652		constructor Create(AOwner: TComponent); override;
#	Line 430 \| Line 654 \| type
654		procedure ApplyUpdates;
655		function CachedUpdateStatus: TCachedUpdateStatus;
656		procedure CancelUpdates;
657	+	function GetFieldPosition(AliasName: string): integer;
658		procedure FetchAll;
659		function LocateNext(const KeyFields: string; const KeyValues: Variant;
660		Options: TLocateOptions): Boolean;
661		procedure RecordModified(Value: Boolean);
662		procedure RevertRecord;
663		procedure Undelete;
664	+	procedure ResetParser; virtual;
665	+	function HasParser: boolean;
666
667		{ TDataSet support methods }
668		function BookmarkValid(Bookmark: TBookmark): Boolean; override;
669		function CompareBookmarks(Bookmark1, Bookmark2: TBookmark): Integer; override;
670		function CreateBlobStream(Field: TField; Mode: TBlobStreamMode): TStream; override;
671	+	function GetArray(Field: TIBArrayField): IArray;
672	+	procedure SetArrayIntf(AnArray: IArray; Field: TIBArrayField);
673		function GetCurrentRecord(Buffer: PChar): Boolean; override;
674		function GetFieldData(Field : TField; Buffer : Pointer) : Boolean; overload; override;
675		function GetFieldData(FieldNo: Integer; Buffer: Pointer): Boolean; overload; (override;)
676		function GetFieldData(Field : TField; Buffer : Pointer;
677		NativeFormat : Boolean) : Boolean; overload; override;
678	+	property GenerateParamNames: Boolean read FGenerateParamNames write SetGenerateParamNames;
679		function Locate(const KeyFields: string; const KeyValues: Variant;
680		Options: TLocateOptions): Boolean; override;
681		function Lookup(const KeyFields: string; const KeyValues: Variant;
682		const ResultFields: string): Variant; override;
683		function UpdateStatus: TUpdateStatus; override;
684		function IsSequenced: Boolean; override;
685	<
686	<	property DBHandle: PISC_DB_HANDLE read GetDBHandle;
687	<	property TRHandle: PISC_TR_HANDLE read GetTRHandle;
685	>	procedure Post; override;
686	>	function ParamByName(ParamName: String): ISQLParam;
687	>	property ArrayFieldCount: integer read FArrayFieldCount;
688		property UpdateObject: TIBDataSetUpdateObject read FUpdateObject write SetUpdateObject;
689		property UpdatesPending: Boolean read FUpdatesPending;
690		property UpdateRecordTypes: TIBUpdateRecordTypes read FUpdateRecordTypes
691		write SetUpdateRecordTypes;
692	+	property DataSetCloseAction: TDataSetCloseAction
693	+	read FDataSetCloseAction write FDataSetCloseAction;
694
695		published
696	+	property AllowAutoActivateTransaction: Boolean read FAllowAutoActivateTransaction
697	+	write FAllowAutoActivateTransaction;
698		property Database: TIBDatabase read GetDatabase write SetDatabase;
699		property Transaction: TIBTransaction read GetTransaction
700		write SetTransaction;
#	Line 497 \| Line 731 \| type
731		write FOnUpdateRecord;
732		end;
733
734	<	TIBDataSet = class(TIBCustomDataSet)
734	>	TIBParserDataSet = class(TIBCustomDataSet)
735	>	public
736	>	property Parser;
737	>	end;
738	>
739	>	TIBDataSet = class(TIBParserDataSet)
740		private
741		function GetPrepared: Boolean;
742
#	Line 522 \| Line 761 \| type
761		property QModify;
762		property StatementType;
763		property SelectStmtHandle;
764	+	property BaseSQLSelect;
765
766		published
767		{ TIBCustomDataSet }
768	+	property AutoCommit;
769		property BufferChunks;
770		property CachedUpdates;
771		property DeleteSQL;
#	Line 532 \| Line 773 \| type
773		property RefreshSQL;
774		property SelectSQL;
775		property ModifySQL;
776	<	property Generator;
776	>	property GeneratorField;
777	>	property GenerateParamNames;
778		property ParamCheck;
779		property UniDirectional;
780		property Filtered;
781	+	property DataSetCloseAction;
782
783		property BeforeDatabaseDisconnect;
784		property AfterDatabaseDisconnect;
#	Line 571 \| Line 814 \| type
814		property OnFilterRecord;
815		property OnNewRecord;
816		property OnPostError;
817	+	property OnValidatePost;
818		end;
819
820		{ TIBDSBlobStream }
821		TIBDSBlobStream = class(TStream)
822	+	private
823	+	FHasWritten: boolean;
824		protected
825		FField: TField;
826		FBlobStream: TIBBlobStream;
827	+	function GetSize: Int64; override;
828		public
829		constructor Create(AField: TField; ABlobStream: TIBBlobStream;
830		Mode: TBlobStreamMode);
831	+	destructor Destroy; override;
832		function Read(var Buffer; Count: Longint): Longint; override;
833		function Seek(Offset: Longint; Origin: Word): Longint; override;
834		procedure SetSize(NewSize: Longint); override;
835		function Write(const Buffer; Count: Longint): Longint; override;
836		end;
837
838	+	{Extended Field Def for character set info}
839	+
840	+	{ TIBFieldDef }
841	+
842	+	TIBFieldDef = class(TFieldDef)
843	+	private
844	+	FArrayBounds: TArrayBounds;
845	+	FArrayDimensions: integer;
846	+	FCharacterSetName: RawByteString;
847	+	FCharacterSetSize: integer;
848	+	FCodePage: TSystemCodePage;
849	+	FIdentityColumn: boolean;
850	+	FRelationName: string;
851	+	FDataSize: integer;
852	+	published
853	+	property CharacterSetName: RawByteString read FCharacterSetName write FCharacterSetName;
854	+	property CharacterSetSize: integer read FCharacterSetSize write FCharacterSetSize;
855	+	property CodePage: TSystemCodePage read FCodePage write FCodePage;
856	+	property DataSize: integer read FDataSize write FDataSize;
857	+	property RelationName: string read FRelationName write FRelationName;
858	+	property ArrayDimensions: integer read FArrayDimensions write FArrayDimensions;
859	+	property ArrayBounds: TArrayBounds read FArrayBounds write FArrayBounds;
860	+	property IdentityColumn: boolean read FIdentityColumn write FIdentityColumn default false;
861	+	end;
862	+
863		const
864		DefaultFieldClasses: array[TFieldType] of TFieldClass = (
865		nil, { ftUnknown }
866		TIBStringField, { ftString }
867	<	TSmallintField, { ftSmallint }
868	<	TIntegerField, { ftInteger }
867	>	TIBSmallintField, { ftSmallint }
868	>	TIBIntegerField, { ftInteger }
869		TWordField, { ftWord }
870		TBooleanField, { ftBoolean }
871		TFloatField, { ftFloat }
#	Line 605 \| Line 878 \| DefaultFieldClasses: array[TFieldType] o
878		TVarBytesField, { ftVarBytes }
879		TAutoIncField, { ftAutoInc }
880		TBlobField, { ftBlob }
881	<	TMemoField, { ftMemo }
881	>	TIBMemoField, { ftMemo }
882		TGraphicField, { ftGraphic }
883		TBlobField, { ftFmtMemo }
884		TBlobField, { ftParadoxOle }
#	Line 613 \| Line 886 \| DefaultFieldClasses: array[TFieldType] o
886		TBlobField, { ftTypedBinary }
887		nil, { ftCursor }
888		TStringField, { ftFixedChar }
889	<	TWideStringField, { ftWideString }
890	<	TLargeIntField, { ftLargeInt }
889	>	nil, { ftWideString }
890	>	TIBLargeIntField, { ftLargeInt }
891		nil, { ftADT }
892	<	nil, { ftArray }
892	>	TIBArrayField, { ftArray }
893		nil, { ftReference }
894		nil, { ftDataSet }
895		TBlobField, { ftOraBlob }
#	Line 628 \| Line 901 \| DefaultFieldClasses: array[TFieldType] o
901		TDateTimeField, {ftTimestamp}
902		TIBBCDField, {ftFMTBcd}
903		nil, {ftFixedWideChar}
904	<	TWideMemoField); {ftWideMemo}
905	<
906	<	(* TADTField, { ftADT }
904	>	nil); {ftWideMemo}
905	>	(*
906	>	TADTField, { ftADT }
907		TArrayField, { ftArray }
908		TReferenceField, { ftReference }
909		TDataSetField, { ftDataSet }
#	Line 639 \| Line 912 \| DefaultFieldClasses: array[TFieldType] o
912		TVariantField, { ftVariant }
913		TInterfaceField, { ftInterface }
914		TIDispatchField, { ftIDispatch }
915	<	TGuidField); { ftGuid }*)
915	>	TGuidField); { ftGuid } *)
916		(*var
917		CreateProviderProc: function(DataSet: TIBCustomDataSet): IProvider = nil;*)
918
919		implementation
920
921	<	uses IBIntf, Variants, FmtBCD;
921	>	uses Variants, FmtBCD, LazUTF8, FBMessages, IBQuery;
922
923		const FILE_BEGIN = 0;
924		FILE_CURRENT = 1;
#	Line 658 \| Line 931 \| type
931		FieldName : String;
932		COMPUTED_BLR : Boolean;
933		DEFAULT_VALUE : boolean;
934	+	IDENTITY_COLUMN : boolean;
935		NextField : TFieldNode;
936		end;
937
#	Line 669 \| Line 943 \| type
943		end;
944
945
946	<	{ TIBStringField}
946	>	{ Copied from LCLProc in order to avoid LCL dependency
947	>
948	>	Ensures the covenient look of multiline string
949	>	when displaying it in the single line
950	>	* Replaces CR and LF with spaces
951	>	* Removes duplicate spaces
952	>	}
953	>	function TextToSingleLine(const AText: string): string;
954	>	var
955	>	str: string;
956	>	i, wstart, wlen: Integer;
957	>	begin
958	>	str := Trim(AText);
959	>	wstart := 0;
960	>	wlen := 0;
961	>	i := 1;
962	>	while i < Length(str) - 1 do
963	>	begin
964	>	if (str[i] in [' ', #13, #10]) then
965	>	begin
966	>	if (wstart = 0) then
967	>	begin
968	>	wstart := i;
969	>	wlen := 1;
970	>	end else
971	>	Inc(wlen);
972	>	end else
973	>	begin
974	>	if wstart > 0 then
975	>	begin
976	>	str[wstart] := ' ';
977	>	Delete(str, wstart+1, wlen-1);
978	>	Dec(i, wlen-1);
979	>	wstart := 0;
980	>	end;
981	>	end;
982	>	Inc(i);
983	>	end;
984	>	Result := str;
985	>	end;
986	>
987	>	{ TIBLargeIntField }
988	>
989	>	procedure TIBLargeIntField.Bind(Binding: Boolean);
990	>	begin
991	>	inherited Bind(Binding);
992	>	if Binding and (FieldDef <> nil) then
993	>	FIdentityColumn := (FieldDef as TIBFieldDef).IdentityColumn;
994	>	end;
995	>
996	>	{ TIBIntegerField }
997	>
998	>	procedure TIBIntegerField.Bind(Binding: Boolean);
999	>	begin
1000	>	inherited Bind(Binding);
1001	>	if Binding and (FieldDef <> nil) then
1002	>	FIdentityColumn := (FieldDef as TIBFieldDef).IdentityColumn;
1003	>	end;
1004	>
1005	>	{ TIBSmallintField }
1006	>
1007	>	procedure TIBSmallintField.Bind(Binding: Boolean);
1008	>	begin
1009	>	inherited Bind(Binding);
1010	>	if Binding and (FieldDef <> nil) then
1011	>	FIdentityColumn := (FieldDef as TIBFieldDef).IdentityColumn;
1012	>	end;
1013	>
1014	>	{ TIBArray }
1015	>
1016	>	procedure TIBArray.EventHandler(Sender: IArray; Reason: TArrayEventReason);
1017	>	begin
1018	>	case Reason of
1019	>	arChanging:
1020	>	if FRecNo <> FField.Dataset.RecNo then
1021	>	IBError(ibxeNotCurrentArray,[nil]);
1022	>
1023	>	arChanged:
1024	>	FField.DataChanged;
1025	>	end;
1026	>	end;
1027	>
1028	>	constructor TIBArray.Create(aField: TIBArrayField; anArray: IArray);
1029	>	begin
1030	>	inherited Create;
1031	>	FField := aField;
1032	>	FArray := anArray;
1033	>	FRecNo := FField.Dataset.RecNo;
1034	>	FArray.AddEventHandler(EventHandler);
1035	>	end;
1036	>
1037	>	destructor TIBArray.Destroy;
1038	>	begin
1039	>	FArray.RemoveEventHandler(EventHandler);
1040	>	inherited Destroy;
1041	>	end;
1042	>
1043	>	{ TIBArrayField }
1044	>
1045	>	function TIBArrayField.GetArrayIntf: IArray;
1046	>	begin
1047	>	Result := TIBCustomDataSet(DataSet).GetArray(self);
1048	>	end;
1049	>
1050	>	function TIBArrayField.GetArrayID: TISC_QUAD;
1051	>	begin
1052	>	GetData(@Result);
1053	>	end;
1054	>
1055	>	procedure TIBArrayField.SetArrayIntf(AValue: IArray);
1056	>	begin
1057	>	TIBCustomDataSet(DataSet).SetArrayIntf(AValue,self);
1058	>	DataChanged;
1059	>	end;
1060	>
1061	>	class procedure TIBArrayField.CheckTypeSize(AValue: Longint);
1062	>	begin
1063	>	//Ignore
1064	>	end;
1065	>
1066	>	function TIBArrayField.GetAsString: string;
1067	>	begin
1068	>	Result := '(Array)';
1069	>	end;
1070	>
1071	>	function TIBArrayField.GetDataSize: Integer;
1072	>	begin
1073	>	Result := sizeof(TISC_QUAD);
1074	>	end;
1075	>
1076	>	procedure TIBArrayField.Bind(Binding: Boolean);
1077	>	begin
1078	>	inherited Bind(Binding);
1079	>	if Binding then
1080	>	begin
1081	>	FCacheOffset := TIBCustomDataSet(DataSet).ArrayFieldCount;
1082	>	Inc(TIBCustomDataSet(DataSet).FArrayFieldCount);
1083	>	if FieldDef <> nil then
1084	>	begin
1085	>	FRelationName := TIBFieldDef(FieldDef).FRelationName;
1086	>	FArrayDimensions := TIBFieldDef(FieldDef).ArrayDimensions;
1087	>	FArrayBounds := TIBFieldDef(FieldDef).ArrayBounds;
1088	>	end;
1089	>	end;
1090	>	end;
1091	>
1092	>	constructor TIBArrayField.Create(AOwner: TComponent);
1093	>	begin
1094	>	inherited Create(AOwner);
1095	>	SetDataType(ftArray);
1096	>	end;
1097	>
1098	>	function TIBArrayField.CreateArray: IArray;
1099	>	begin
1100	>	with DataSet as TIBCustomDataSet do
1101	>	Result := Database.Attachment.CreateArray(Transaction.TransactionIntf,FRelationName,FieldName);
1102	>	end;
1103	>
1104	>	{ TIBMemoField }
1105
1106	<	constructor TIBStringField.Create(AOwner: TComponent);
1106	>	function TIBMemoField.GetTruncatedText: string;
1107	>	begin
1108	>	Result := GetAsString;
1109	>
1110	>	if Result <> '' then
1111	>	begin
1112	>	case CharacterSetSize of
1113	>	1:
1114	>	if DisplayWidth = 0 then
1115	>	Result := TextToSingleLine(Result)
1116	>	else
1117	>	if Length(Result) > DisplayWidth then {Show truncation with elipses}
1118	>	Result := TextToSingleLine(system.copy(Result,1,DisplayWidth-3)) + '...';
1119	>
1120	>	{2: case 2 ignored. This should be handled by TIBWideMemo}
1121	>
1122	>	3, {Assume UNICODE_FSS is really UTF8}
1123	>	4: {Include GB18030 - assuming UTF8 routines work for this codeset}
1124	>	if DisplayWidth = 0 then
1125	>	Result := ValidUTF8String(TextToSingleLine(Result))
1126	>	else
1127	>	if UTF8Length(Result) > DisplayWidth then {Show truncation with elipses}
1128	>	Result := ValidUTF8String(TextToSingleLine(UTF8Copy(Result,1,DisplayWidth-3))) + '...';
1129	>	end;
1130	>	end
1131	>	end;
1132	>
1133	>	procedure TIBMemoField.Bind(Binding: Boolean);
1134	>	var IBFieldDef: TIBFieldDef;
1135	>	begin
1136	>	inherited Bind(Binding);
1137	>	if Binding and (FieldDef <> nil) then
1138	>	begin
1139	>	IBFieldDef := FieldDef as TIBFieldDef;
1140	>	CharacterSetSize := IBFieldDef.CharacterSetSize;
1141	>	CharacterSetName := IBFieldDef.CharacterSetName;
1142	>	CodePage := IBFieldDef.CodePage;
1143	>	end;
1144	>	end;
1145	>
1146	>	function TIBMemoField.GetAsString: string;
1147	>	var s: RawByteString;
1148	>	begin
1149	>	s := inherited GetAsString;
1150	>	SetCodePage(s,CodePage,false);
1151	>	if (CodePage <> CP_NONE) and (CodePage <> CP_UTF8) then
1152	>	SetCodePage(s,CP_UTF8,true); {LCL only accepts UTF8}
1153	>	Result := s;
1154	>	end;
1155	>
1156	>	function TIBMemoField.GetDefaultWidth: Longint;
1157	>	begin
1158	>	if DisplayTextAsClassName then
1159	>	Result := inherited
1160	>	else
1161	>	Result := 128;
1162	>	end;
1163	>
1164	>	procedure TIBMemoField.GetText(var AText: string; ADisplayText: Boolean);
1165	>	begin
1166	>	if ADisplayText then
1167	>	begin
1168	>	if not DisplayTextAsClassName and (CharacterSetName <> '') then
1169	>	AText := GetTruncatedText
1170	>	else
1171	>	inherited GetText(AText, ADisplayText);
1172	>	end
1173	>	else
1174	>	AText := GetAsString;
1175	>	end;
1176	>
1177	>	procedure TIBMemoField.SetAsString(const AValue: string);
1178	>	var s: RawByteString;
1179	>	begin
1180	>	s := AValue;
1181	>	if StringCodePage(s) <> CodePage then
1182	>	SetCodePage(s,CodePage,CodePage<>CP_NONE);
1183	>	inherited SetAsString(s);
1184	>	end;
1185	>
1186	>	constructor TIBMemoField.Create(AOwner: TComponent);
1187		begin
1188		inherited Create(AOwner);
1189	+	BlobType := ftMemo;
1190	+	FCodePage := CP_NONE;
1191	+	end;
1192	+
1193	+	{ TIBControlLink }
1194	+
1195	+	destructor TIBControlLink.Destroy;
1196	+	begin
1197	+	IBDataSet := nil;
1198	+	inherited Destroy;
1199	+	end;
1200	+
1201	+	procedure TIBControlLink.UpdateParams(Sender: TObject);
1202	+	begin
1203	+
1204	+	end;
1205	+
1206	+	procedure TIBControlLink.UpdateSQL(Sender: TObject);
1207	+	begin
1208	+
1209	+	end;
1210	+
1211	+	procedure TIBControlLink.SetIBDataSet(AValue: TIBCustomDataSet);
1212	+	begin
1213	+	if FTIBDataSet = AValue then Exit;
1214	+	if IBDataSet <> nil then
1215	+	IBDataSet.UnRegisterIBLink(self);
1216	+	FTIBDataSet := AValue;
1217	+	if IBDataSet <> nil then
1218	+	IBDataSet.RegisterIBLink(self);
1219	+	end;
1220	+
1221	+
1222	+	{ TIBStringField}
1223	+
1224	+	procedure TIBStringField.Bind(Binding: Boolean);
1225	+	var IBFieldDef: TIBFieldDef;
1226	+	begin
1227	+	inherited Bind(Binding);
1228	+	if Binding and (FieldDef <> nil) then
1229	+	begin
1230	+	IBFieldDef := FieldDef as TIBFieldDef;
1231	+	CharacterSetSize := IBFieldDef.CharacterSetSize;
1232	+	CharacterSetName := IBFieldDef.CharacterSetName;
1233	+	FDataSize := IBFieldDef.DataSize + 1;
1234	+	if AutoFieldSize then
1235	+	Size := IBFieldDef.Size;
1236	+	CodePage := IBFieldDef.CodePage;
1237	+	end;
1238	+	end;
1239	+
1240	+	function TIBStringField.GetDataSize: Integer;
1241	+	begin
1242	+	Result := FDataSize;
1243	+	end;
1244	+
1245	+	constructor TIBStringField.Create(aOwner: TComponent);
1246	+	begin
1247	+	inherited Create(aOwner);
1248	+	FCharacterSetSize := 1;
1249	+	FCodePage := CP_NONE;
1250	+	FAutoFieldSize := true;
1251		end;
1252
1253		class procedure TIBStringField.CheckTypeSize(Value: Integer);
#	Line 696 \| Line 1270 \| end;
1270		function TIBStringField.GetValue(var Value: string): Boolean;
1271		var
1272		Buffer: PChar;
1273	+	s: RawByteString;
1274		begin
1275		Buffer := nil;
1276	<	IBAlloc(Buffer, 0, Size + 1);
1276	>	IBAlloc(Buffer, 0, DataSize);
1277		try
1278		Result := GetData(Buffer);
1279		if Result then
1280		begin
1281	<	Value := string(Buffer);
1281	>	s := strpas(Buffer);
1282	>	SetCodePage(s,CodePage,false);
1283	>	if (CodePage <> CP_NONE) and (CodePage <> CP_UTF8) then
1284	>	SetCodePage(s,CP_UTF8,true); {LCL only accepts UTF8}
1285	>	Value := s;
1286	>	// writeln(FieldName,': ', StringCodePage(Value),', ',Value);
1287		if Transliterate and (Value <> '') then
1288		DataSet.Translate(PChar(Value), PChar(Value), False);
1289		end
#	Line 715 \| Line 1295 \| end;
1295		procedure TIBStringField.SetAsString(const Value: string);
1296		var
1297		Buffer: PChar;
1298	+	s: RawByteString;
1299		begin
1300		Buffer := nil;
1301	<	IBAlloc(Buffer, 0, Size + 1);
1301	>	IBAlloc(Buffer, 0, DataSize);
1302		try
1303	<	StrLCopy(Buffer, PChar(Value), Size);
1303	>	s := Value;
1304	>	if StringCodePage(s) <> CodePage then
1305	>	SetCodePage(s,CodePage,CodePage<>CP_NONE);
1306	>	StrLCopy(Buffer, PChar(s), DataSize-1);
1307		if Transliterate then
1308		DataSet.Translate(Buffer, Buffer, True);
1309		SetData(Buffer);
#	Line 728 \| Line 1312 \| begin
1312		end;
1313		end;
1314
1315	+
1316		{ TIBBCDField }
1317
1318		constructor TIBBCDField.Create(AOwner: TComponent);
#	Line 737 \| Line 1322 \| begin
1322		Size := 8;
1323		end;
1324
1325	+	procedure TIBBCDField.Bind(Binding: Boolean);
1326	+	begin
1327	+	inherited Bind(Binding);
1328	+	if Binding and (FieldDef <> nil) then
1329	+	FIdentityColumn := (FieldDef as TIBFieldDef).IdentityColumn;
1330	+	end;
1331	+
1332		class procedure TIBBCDField.CheckTypeSize(Value: Integer);
1333		begin
1334		{ No need to check as the base type is currency, not BCD }
#	Line 770 \| Line 1362 \| end;
1362
1363		function TIBBCDField.GetDataSize: Integer;
1364		begin
1365	+	{$IFDEF TBCDFIELD_IS_BCD}
1366		Result := 8;
1367	+	{$ELSE}
1368	+	Result := inherited GetDataSize
1369	+	{$ENDIF}
1370		end;
1371
1372		{ TIBDataLink }
#	Line 817 \| Line 1413 \| end;
1413		constructor TIBCustomDataSet.Create(AOwner: TComponent);
1414		begin
1415		inherited Create(AOwner);
820	–	FIBLoaded := False;
821	–	CheckIBLoaded;
822	–	FIBLoaded := True;
1416		FBase := TIBBase.Create(Self);
1417	+	FDatabaseInfo := TIBDatabaseInfo.Create(self);
1418	+	FIBLinks := TList.Create;
1419		FCurrentRecord := -1;
1420		FDeletedRecords := 0;
1421		FUniDirectional := False;
1422		FBufferChunks := BufferCacheSize;
1423		FBlobStreamList := TList.Create;
1424	<	FGenerator := TIBGenerator.Create(self);
1424	>	FArrayList := TList.Create;
1425	>	FGeneratorField := TIBGenerator.Create(self);
1426		FDataLink := TIBDataLink.Create(Self);
1427		FQDelete := TIBSQL.Create(Self);
1428		FQDelete.OnSQLChanging := SQLChanging;
#	Line 839 \| Line 1435 \| begin
1435		FQRefresh.GoToFirstRecordOnExecute := False;
1436		FQSelect := TIBSQL.Create(Self);
1437		FQSelect.OnSQLChanging := SQLChanging;
1438	+	FQSelect.OnSQLChanged := SQLChanged;
1439		FQSelect.GoToFirstRecordOnExecute := False;
1440		FQModify := TIBSQL.Create(Self);
1441		FQModify.OnSQLChanging := SQLChanging;
1442		FQModify.GoToFirstRecordOnExecute := False;
1443		FUpdateRecordTypes := [cusUnmodified, cusModified, cusInserted];
1444		FParamCheck := True;
1445	+	FGenerateParamNames := False;
1446		FForcedRefresh := False;
1447	+	FAutoCommit:= acDisabled;
1448	+	FDataSetCloseAction := dcDiscardChanges;
1449		{Bookmark Size is Integer for IBX}
1450		BookmarkSize := SizeOf(Integer);
1451		FBase.BeforeDatabaseDisconnect := DoBeforeDatabaseDisconnect;
#	Line 859 \| Line 1459 \| begin
1459		else
1460		if AOwner is TIBTransaction then
1461		Transaction := TIBTransaction(AOwner);
1462	+	FBaseSQLSelect := TStringList.Create;
1463		end;
1464
1465		destructor TIBCustomDataSet.Destroy;
1466		begin
1467	<	if FIBLoaded then
1468	<	begin
1469	<	if assigned(FGenerator) then FGenerator.Free;
1470	<	FDataLink.Free;
1471	<	FBase.Free;
1472	<	ClearBlobCache;
1473	<	FBlobStreamList.Free;
1474	<	FreeMem(FBufferCache);
1475	<	FBufferCache := nil;
1476	<	FreeMem(FOldBufferCache);
1477	<	FOldBufferCache := nil;
1478	<	FCacheSize := 0;
1479	<	FOldCacheSize := 0;
1480	<	FMappedFieldPosition := nil;
1481	<	end;
1467	>	if Active then Active := false;
1468	>	if assigned(FGeneratorField) then FGeneratorField.Free;
1469	>	FDataLink.Free;
1470	>	FBase.Free;
1471	>	ClearBlobCache;
1472	>	ClearIBLinks;
1473	>	FIBLinks.Free;
1474	>	FBlobStreamList.Free;
1475	>	FArrayList.Free;
1476	>	FreeMem(FBufferCache);
1477	>	FBufferCache := nil;
1478	>	FreeMem(FOldBufferCache);
1479	>	FOldBufferCache := nil;
1480	>	FCacheSize := 0;
1481	>	FOldCacheSize := 0;
1482	>	FMappedFieldPosition := nil;
1483	>	if assigned(FBaseSQLSelect) then FBaseSQLSelect.Free;
1484	>	if assigned(FParser) then FParser.Free;
1485		inherited Destroy;
1486		end;
1487
#	Line 900 \| Line 1504 \| begin
1504		Inc(FCurrentRecord);
1505		if (FCurrentRecord = FRecordCount) then
1506		begin
1507	<	if (not FQSelect.EOF) and (FQSelect.Next <> nil) then
1507	>	if (not FQSelect.EOF) and FQSelect.Next then
1508		begin
1509		FetchCurrentRecordToBuffer(FQSelect, FCurrentRecord, Buffer);
1510		Inc(FRecordCount);
#	Line 919 \| Line 1523 \| end;
1523
1524		procedure TIBCustomDataSet.ApplyUpdates;
1525		var
1526	<	CurBookmark: string;
1526	>	CurBookmark: TBookmark;
1527		Buffer: PRecordData;
1528		CurUpdateTypes: TIBUpdateRecordTypes;
1529		UpdateAction: TIBUpdateAction;
#	Line 979 \| Line 1583 \| var
1583		procedure UpdateUsingUpdateObject;
1584		begin
1585		try
1586	<	FUpdateObject.Apply(UpdateKind);
1586	>	FUpdateObject.Apply(UpdateKind,PChar(Buffer));
1587		ResetBufferUpdateStatus;
1588		except
1589		on E: Exception do
#	Line 1117 \| Line 1721 \| begin
1721		end;
1722		end;
1723
1724	+	function TIBCustomDataSet.GetFieldPosition(AliasName: string): integer;
1725	+	var i: integer;
1726	+	Prepared: boolean;
1727	+	begin
1728	+	Result := 0;
1729	+	Prepared := FInternalPrepared;
1730	+	if not Prepared then
1731	+	InternalPrepare;
1732	+	try
1733	+	for i := 0 to Length(FAliasNameList) - 1 do
1734	+	if FAliasNameList[i] = AliasName then
1735	+	begin
1736	+	Result := i + 1;
1737	+	Exit
1738	+	end;
1739	+	finally
1740	+	if not Prepared then
1741	+	InternalUnPrepare;
1742	+	end;
1743	+	end;
1744	+
1745		procedure TIBCustomDataSet.ActivateConnection;
1746		begin
1747		if not Assigned(Database) then
#	Line 1129 \| Line 1754 \| end;
1754		function TIBCustomDataSet.ActivateTransaction: Boolean;
1755		begin
1756		Result := False;
1757	<	if not Assigned(Transaction) then
1133	<	IBError(ibxeTransactionNotAssigned, [nil]);
1134	<	if not Transaction.Active then
1757	>	if AllowAutoActivateTransaction or (csDesigning in ComponentState) then
1758		begin
1759	<	Result := True;
1760	<	Transaction.StartTransaction;
1761	<	FDidActivate := True;
1759	>	if not Assigned(Transaction) then
1760	>	IBError(ibxeTransactionNotAssigned, [nil]);
1761	>	if not Transaction.Active then
1762	>	begin
1763	>	Result := True;
1764	>	Transaction.StartTransaction;
1765	>	FDidActivate := True;
1766	>	end;
1767		end;
1768		end;
1769
#	Line 1177 \| Line 1805 \| begin
1805		IBError(ibxeDatasetClosed, [nil]);
1806		end;
1807
1808	+	function TIBCustomDataSet.CreateParser: TSelectSQLParser;
1809	+	begin
1810	+	Result := TSelectSQLParser.Create(self,FBaseSQLSelect);
1811	+	Result.OnSQLChanging := SQLChanging
1812	+	end;
1813	+
1814		procedure TIBCustomDataSet.CheckNotUniDirectional;
1815		begin
1816		if UniDirectional then
#	Line 1254 \| Line 1888 \| begin
1888		FBlobStreamList.Pack;
1889		end;
1890
1891	+	procedure TIBCustomDataSet.ClearArrayCache;
1892	+	var
1893	+	i: Integer;
1894	+	begin
1895	+	for i := 0 to FArrayList.Count - 1 do
1896	+	begin
1897	+	TIBArray(FArrayList[i]).Free;
1898	+	FArrayList[i] := nil;
1899	+	end;
1900	+	FArrayList.Pack;
1901	+	end;
1902	+
1903		procedure TIBCustomDataSet.CopyRecordBuffer(Source, Dest: Pointer);
1904		begin
1905		Move(Source^, Dest^, FRecordBufferSize);
#	Line 1263 \| Line 1909 \| procedure TIBCustomDataSet.DoBeforeDatab
1909		begin
1910		if Active then
1911		Active := False;
1912	<	FInternalPrepared := False;
1912	>	InternalUnPrepare;
1913		if Assigned(FBeforeDatabaseDisconnect) then
1914		FBeforeDatabaseDisconnect(Sender);
1915		end;
#	Line 1280 \| Line 1926 \| begin
1926		FDatabaseFree(Sender);
1927		end;
1928
1929	<	procedure TIBCustomDataSet.DoBeforeTransactionEnd(Sender: TObject);
1929	>	procedure TIBCustomDataSet.DoBeforeTransactionEnd(Sender: TObject;
1930	>	Action: TTransactionAction);
1931		begin
1932	<	if Active then
1933	<	Active := False;
1932	>	FCloseAction := Action;
1933	>	FInTransactionEnd := true;
1934	>	try
1935	>	if Active then
1936	>	Active := False;
1937	>	finally
1938	>	FInTransactionEnd := false;
1939	>	end;
1940		if FQSelect <> nil then
1941		FQSelect.FreeHandle;
1942		if FQDelete <> nil then
#	Line 1294 \| Line 1947 \| begin
1947		FQModify.FreeHandle;
1948		if FQRefresh <> nil then
1949		FQRefresh.FreeHandle;
1950	+	InternalUnPrepare;
1951		if Assigned(FBeforeTransactionEnd) then
1952		FBeforeTransactionEnd(Sender);
1953		end;
#	Line 1310 \| Line 1964 \| begin
1964		FTransactionFree(Sender);
1965		end;
1966
1967	<	{ Read the record from FQSelect.Current into the record buffer
1968	<	Then write the buffer to in memory cache }
1969	<	procedure TIBCustomDataSet.FetchCurrentRecordToBuffer(Qry: TIBSQL;
1970	<	RecordNumber: Integer; Buffer: PChar);
1971	<	var
1318	<	p: PRecordData;
1319	<	pbd: PBlobDataArray;
1320	<	i, j: Integer;
1321	<	LocalData: Pointer;
1322	<	LocalDate, LocalDouble: Double;
1323	<	LocalInt: Integer;
1324	<	LocalInt64: Int64;
1325	<	LocalCurrency: Currency;
1326	<	FieldsLoaded: Integer;
1327	<	temp: TIBXSQLVAR;
1967	>	procedure TIBCustomDataSet.InitModelBuffer(Qry: TIBSQL; Buffer: PChar);
1968	>	var i, j: Integer;
1969	>	FieldsLoaded: integer;
1970	>	p: PRecordData;
1971	>	colMetadata: IColumnMetaData;
1972		begin
1973		p := PRecordData(Buffer);
1330	–	{ Make sure blob cache is empty }
1331	–	pbd := PBlobDataArray(Buffer + FBlobCacheOffset);
1332	–	if RecordNumber > -1 then
1333	–	for i := 0 to BlobFieldCount - 1 do
1334	–	pbd^[i] := nil;
1974		{ Get record information }
1975		p^.rdBookmarkFlag := bfCurrent;
1976	<	p^.rdFieldCount := Qry.Current.Count;
1977	<	p^.rdRecordNumber := RecordNumber;
1976	>	p^.rdFieldCount := Qry.FieldCount;
1977	>	p^.rdRecordNumber := -1;
1978		p^.rdUpdateStatus := usUnmodified;
1979		p^.rdCachedUpdateStatus := cusUnmodified;
1980		p^.rdSavedOffset := $FFFFFFFF;
1981
1982		{ Load up the fields }
1983	<	FieldsLoaded := FQSelect.Current.Count;
1983	>	FieldsLoaded := FQSelect.MetaData.Count;
1984		j := 1;
1985	<	for i := 0 to Qry.Current.Count - 1 do
1985	>	for i := 0 to Qry.MetaData.Count - 1 do
1986		begin
1987		if (Qry = FQSelect) then
1988		j := i + 1
1989	<	else begin
1989	>	else
1990	>	begin
1991		if FieldsLoaded = 0 then
1992		break;
1993	<	j := FQSelect.FieldIndex[Qry.Current[i].Name] + 1;
1993	>	j := FQSelect.FieldIndex[Qry[i].Name] + 1;
1994		if j < 1 then
1995		continue
1996		else
1997		Dec(FieldsLoaded);
1998		end;
1999	<	with FQSelect.Current[j - 1].Data^ do
2000	<	if aliasname = 'IBX_INTERNAL_DBKEY' then {do not localize}
1999	>	if j > 0 then
2000	>	begin
2001	>	colMetadata := Qry.MetaData[i];
2002	>	with p^.rdFields[j], FFieldColumns^[j] do
2003		begin
2004	<	if sqllen <= 8 then
2005	<	p^.rdDBKey := PIBDBKEY(Qry.Current[i].AsPointer)^;
2006	<	continue;
2004	>	fdDataType := colMetadata.GetSQLType;
2005	>	if fdDataType = SQL_BLOB then
2006	>	fdDataScale := 0
2007	>	else
2008	>	fdDataScale := colMetadata.getScale;
2009	>	fdNullable := colMetadata.getIsNullable;
2010	>	fdIsNull := true;
2011	>	fdDataSize := colMetadata.GetSize;
2012	>	fdDataLength := 0;
2013	>	fdCodePage := CP_NONE;
2014	>
2015	>	case fdDataType of
2016	>	SQL_TIMESTAMP,
2017	>	SQL_TYPE_DATE,
2018	>	SQL_TYPE_TIME:
2019	>	fdDataSize := SizeOf(TDateTime);
2020	>	SQL_SHORT, SQL_LONG:
2021	>	begin
2022	>	if (fdDataScale = 0) then
2023	>	fdDataSize := SizeOf(Integer)
2024	>	else
2025	>	if (fdDataScale >= (-4)) then
2026	>	fdDataSize := SizeOf(Currency)
2027	>	else
2028	>	fdDataSize := SizeOf(Double);
2029	>	end;
2030	>	SQL_INT64:
2031	>	begin
2032	>	if (fdDataScale = 0) then
2033	>	fdDataSize := SizeOf(Int64)
2034	>	else
2035	>	if (fdDataScale >= (-4)) then
2036	>	fdDataSize := SizeOf(Currency)
2037	>	else
2038	>	fdDataSize := SizeOf(Double);
2039	>	end;
2040	>	SQL_DOUBLE, SQL_FLOAT, SQL_D_FLOAT:
2041	>	fdDataSize := SizeOf(Double);
2042	>	SQL_BOOLEAN:
2043	>	fdDataSize := SizeOf(wordBool);
2044	>	SQL_VARYING,
2045	>	SQL_TEXT,
2046	>	SQL_BLOB:
2047	>	fdCodePage := Qry.Metadata[i].getCodePage;
2048	>	end;
2049	>	fdDataOfs := FRecordSize;
2050	>	Inc(FRecordSize, fdDataSize);
2051		end;
2052	<	if j > 0 then with p^ do
2052	>	end;
2053	>	end;
2054	>	end;
2055	>
2056	>	{Update Buffer Fields from Query Results}
2057	>
2058	>	procedure TIBCustomDataSet.UpdateRecordFromQuery(QryResults: IResults;
2059	>	Buffer: PChar);
2060	>	var i, j: integer;
2061	>	begin
2062	>	for i := 0 to QryResults.Count - 1 do
2063	>	begin
2064	>	j := GetFieldPosition(QryResults[i].GetAliasName);
2065	>	if j > 0 then
2066	>	ColumnDataToBuffer(QryResults,i,j,Buffer);
2067	>	end;
2068	>	end;
2069	>
2070	>
2071	>	{Move column data returned from query to row buffer}
2072	>
2073	>	procedure TIBCustomDataSet.ColumnDataToBuffer(QryResults: IResults;
2074	>	ColumnIndex, FieldIndex: integer; Buffer: PChar);
2075	>	var
2076	>	LocalData: PByte;
2077	>	LocalDate: TDateTime;
2078	>	LocalDouble: Double;
2079	>	LocalInt: Integer;
2080	>	LocalBool: wordBool;
2081	>	LocalInt64: Int64;
2082	>	LocalCurrency: Currency;
2083	>	ColData: ISQLData;
2084	>	begin
2085	>	LocalData := nil;
2086	>	with PRecordData(Buffer)^.rdFields[FieldIndex], FFieldColumns^[FieldIndex] do
2087	>	begin
2088	>	QryResults.GetData(ColumnIndex,fdIsNull,fdDataLength,LocalData);
2089	>	if not fdIsNull then
2090		begin
2091	<	rdFields[j].fdDataType :=
2092	<	Qry.Current[i].Data^.sqltype and (not 1);
2093	<	rdFields[j].fdDataScale :=
2094	<	Qry.Current[i].Data^.sqlscale;
1372	<	rdFields[j].fdNullable :=
1373	<	(Qry.Current[i].Data^.sqltype and 1 = 1);
1374	<	rdFields[j].fdIsNull :=
1375	<	(rdFields[j].fdNullable and (Qry.Current[i].Data^.sqlind^ = -1));
1376	<	LocalData := Qry.Current[i].Data^.sqldata;
1377	<	case rdFields[j].fdDataType of
2091	>	ColData := QryResults[ColumnIndex];
2092	>	case fdDataType of {Get Formatted data for column types that need formatting}
2093	>	SQL_TYPE_DATE,
2094	>	SQL_TYPE_TIME,
2095		SQL_TIMESTAMP:
2096		begin
2097	<	rdFields[j].fdDataSize := SizeOf(TDateTime);
2098	<	if RecordNumber >= 0 then
2099	<	LocalDate := TimeStampToMSecs(DateTimeToTimeStamp(Qry.Current[i].AsDateTime));
1383	<	LocalData := PChar(@LocalDate);
1384	<	end;
1385	<	SQL_TYPE_DATE:
1386	<	begin
1387	<	rdFields[j].fdDataSize := SizeOf(TDateTime);
1388	<	if RecordNumber >= 0 then
1389	<	LocalInt := DateTimeToTimeStamp(Qry.Current[i].AsDateTime).Date;
1390	<	LocalData := PChar(@LocalInt);
1391	<	end;
1392	<	SQL_TYPE_TIME:
1393	<	begin
1394	<	rdFields[j].fdDataSize := SizeOf(TDateTime);
1395	<	if RecordNumber >= 0 then
1396	<	LocalInt := DateTimeToTimeStamp(Qry.Current[i].AsDateTime).Time;
1397	<	LocalData := PChar(@LocalInt);
2097	>	{This is an IBX native format and not the TDataset approach. See also GetFieldData}
2098	>	LocalDate := ColData.AsDateTime;
2099	>	LocalData := PByte(@LocalDate);
2100		end;
2101		SQL_SHORT, SQL_LONG:
2102		begin
2103	<	if (rdFields[j].fdDataScale = 0) then
2103	>	if (fdDataScale = 0) then
2104		begin
2105	<	rdFields[j].fdDataSize := SizeOf(Integer);
2106	<	if RecordNumber >= 0 then
1405	<	LocalInt := Qry.Current[i].AsLong;
1406	<	LocalData := PChar(@LocalInt);
2105	>	LocalInt := ColData.AsLong;
2106	>	LocalData := PByte(@LocalInt);
2107		end
2108	<	else if (rdFields[j].fdDataScale >= (-4)) then
2109	<	begin
2110	<	rdFields[j].fdDataSize := SizeOf(Currency);
2111	<	if RecordNumber >= 0 then
2112	<	LocalCurrency := Qry.Current[i].AsCurrency;
2113	<	LocalData := PChar(@LocalCurrency);
2114	<	end
2115	<	else begin
2116	<	rdFields[j].fdDataSize := SizeOf(Double);
2117	<	if RecordNumber >= 0 then
2118	<	LocalDouble := Qry.Current[i].AsDouble;
1419	<	LocalData := PChar(@LocalDouble);
1420	<	end;
2108	>	else
2109	>	if (fdDataScale >= (-4)) then
2110	>	begin
2111	>	LocalCurrency := ColData.AsCurrency;
2112	>	LocalData := PByte(@LocalCurrency);
2113	>	end
2114	>	else
2115	>	begin
2116	>	LocalDouble := ColData.AsDouble;
2117	>	LocalData := PByte(@LocalDouble);
2118	>	end;
2119		end;
2120		SQL_INT64:
2121		begin
2122	<	if (rdFields[j].fdDataScale = 0) then
2122	>	if (fdDataScale = 0) then
2123		begin
2124	<	rdFields[j].fdDataSize := SizeOf(Int64);
2125	<	if RecordNumber >= 0 then
1428	<	LocalInt64 := Qry.Current[i].AsInt64;
1429	<	LocalData := PChar(@LocalInt64);
2124	>	LocalInt64 := ColData.AsInt64;
2125	>	LocalData := PByte(@LocalInt64);
2126		end
2127	<	else if (rdFields[j].fdDataScale >= (-4)) then
2128	<	begin
1433	<	rdFields[j].fdDataSize := SizeOf(Currency);
1434	<	if RecordNumber >= 0 then
1435	<	LocalCurrency := Qry.Current[i].AsCurrency;
1436	<	LocalData := PChar(@LocalCurrency);
1437	<	end
1438	<	else begin
1439	<	rdFields[j].fdDataSize := SizeOf(Double);
1440	<	if RecordNumber >= 0 then
1441	<	LocalDouble := Qry.Current[i].AsDouble;
1442	<	LocalData := PChar(@LocalDouble);
1443	<	end
1444	<	end;
1445	<	SQL_DOUBLE, SQL_FLOAT, SQL_D_FLOAT:
1446	<	begin
1447	<	rdFields[j].fdDataSize := SizeOf(Double);
1448	<	if RecordNumber >= 0 then
1449	<	LocalDouble := Qry.Current[i].AsDouble;
1450	<	LocalData := PChar(@LocalDouble);
1451	<	end;
1452	<	SQL_VARYING:
1453	<	begin
1454	<	rdFields[j].fdDataSize := Qry.Current[i].Data^.sqllen;
1455	<	rdFields[j].fdDataLength := isc_vax_integer(Qry.Current[i].Data^.sqldata, 2);
1456	<	if RecordNumber >= 0 then
2127	>	else
2128	>	if (fdDataScale >= (-4)) then
2129		begin
2130	<	if (rdFields[j].fdDataLength = 0) then
2131	<	LocalData := nil
2130	>	LocalCurrency := ColData.AsCurrency;
2131	>	LocalData := PByte(@LocalCurrency);
2132	>	end
2133		else
2134		begin
2135	<	temp := Qry.Current[i];
2136	<	LocalData := @temp.Data^.sqldata[2];
2137	<	(* LocalData := @Qry.Current[i].Data^.sqldata[2];*)
1465	<	end;
1466	<	end;
2135	>	LocalDouble := ColData.AsDouble;
2136	>	LocalData := PByte(@LocalDouble);
2137	>	end
2138		end;
2139	<	else { SQL_TEXT, SQL_BLOB, SQL_ARRAY, SQL_QUAD }
2139	>	SQL_DOUBLE, SQL_FLOAT, SQL_D_FLOAT:
2140		begin
2141	<	rdFields[j].fdDataSize := Qry.Current[i].Data^.sqllen;
2142	<	if (rdFields[j].fdDataType = SQL_TEXT) then
1472	<	rdFields[j].fdDataLength := rdFields[j].fdDataSize;
2141	>	LocalDouble := ColData.AsDouble;
2142	>	LocalData := PByte(@LocalDouble);
2143		end;
2144	<	end;
1475	<	if RecordNumber < 0 then
1476	<	begin
1477	<	rdFields[j].fdIsNull := True;
1478	<	rdFields[j].fdDataOfs := FRecordSize;
1479	<	Inc(FRecordSize, rdFields[j].fdDataSize);
1480	<	end
1481	<	else begin
1482	<	if rdFields[j].fdDataType = SQL_VARYING then
2144	>	SQL_BOOLEAN:
2145		begin
2146	<	if LocalData <> nil then
2147	<	Move(LocalData^, Buffer[rdFields[j].fdDataOfs], rdFields[j].fdDataLength)
2148	<	end
1487	<	else
1488	<	Move(LocalData^, Buffer[rdFields[j].fdDataOfs], rdFields[j].fdDataSize)
2146	>	LocalBool := ColData.AsBoolean;
2147	>	LocalData := PByte(@LocalBool);
2148	>	end;
2149		end;
2150	+
2151	+	if fdDataType = SQL_VARYING then
2152	+	Move(LocalData^, Buffer[fdDataOfs], fdDataLength)
2153	+	else
2154	+	Move(LocalData^, Buffer[fdDataOfs], fdDataSize)
2155	+	end
2156	+	else {Null column}
2157	+	if fdDataType = SQL_VARYING then
2158	+	FillChar(Buffer[fdDataOfs],fdDataLength,0)
2159	+	else
2160	+	FillChar(Buffer[fdDataOfs],fdDataSize,0);
2161	+	end;
2162	+	end;
2163	+
2164	+	{ Read the record from FQSelect.Current into the record buffer
2165	+	Then write the buffer to in memory cache }
2166	+	procedure TIBCustomDataSet.FetchCurrentRecordToBuffer(Qry: TIBSQL;
2167	+	RecordNumber: Integer; Buffer: PChar);
2168	+	var
2169	+	pbd: PBlobDataArray;
2170	+	pda: PArrayDataArray;
2171	+	i, j: Integer;
2172	+	FieldsLoaded: Integer;
2173	+	p: PRecordData;
2174	+	begin
2175	+	if RecordNumber = -1 then
2176	+	begin
2177	+	InitModelBuffer(Qry,Buffer);
2178	+	Exit;
2179	+	end;
2180	+	p := PRecordData(Buffer);
2181	+	{ Make sure blob cache is empty }
2182	+	pbd := PBlobDataArray(Buffer + FBlobCacheOffset);
2183	+	pda := PArrayDataArray(Buffer + FArrayCacheOffset);
2184	+	for i := 0 to BlobFieldCount - 1 do
2185	+	pbd^[i] := nil;
2186	+	for i := 0 to ArrayFieldCount - 1 do
2187	+	pda^[i] := nil;
2188	+
2189	+	{ Get record information }
2190	+	p^.rdBookmarkFlag := bfCurrent;
2191	+	p^.rdFieldCount := Qry.FieldCount;
2192	+	p^.rdRecordNumber := RecordNumber;
2193	+	p^.rdUpdateStatus := usUnmodified;
2194	+	p^.rdCachedUpdateStatus := cusUnmodified;
2195	+	p^.rdSavedOffset := $FFFFFFFF;
2196	+
2197	+	{ Load up the fields }
2198	+	FieldsLoaded := FQSelect.MetaData.Count;
2199	+	j := 1;
2200	+	for i := 0 to Qry.FieldCount - 1 do
2201	+	begin
2202	+	if (Qry = FQSelect) then
2203	+	j := i + 1
2204	+	else
2205	+	begin
2206	+	if FieldsLoaded = 0 then
2207	+	break;
2208	+	j := FQSelect.FieldIndex[Qry[i].Name] + 1;
2209	+	if j < 1 then
2210	+	continue
2211	+	else
2212	+	Dec(FieldsLoaded);
2213		end;
2214	+	with FQSelect.MetaData[j - 1] do
2215	+	if GetAliasname = 'IBX_INTERNAL_DBKEY' then {do not localize}
2216	+	begin
2217	+	if (GetSize <= 8) then
2218	+	p^.rdDBKey := PIBDBKEY(Qry[i].AsPointer)^;
2219	+	continue;
2220	+	end;
2221	+	if j > 0 then
2222	+	ColumnDataToBuffer(Qry.Current,i,j,Buffer);
2223		end;
2224	<	WriteRecordCache(RecordNumber, PChar(p));
2224	>	WriteRecordCache(RecordNumber, Buffer);
2225		end;
2226
2227		function TIBCustomDataSet.GetActiveBuf: PChar;
#	Line 1534 \| Line 2266 \| begin
2266		result := FBase.Database;
2267		end;
2268
1537	–	function TIBCustomDataSet.GetDBHandle: PISC_DB_HANDLE;
1538	–	begin
1539	–	result := FBase.DBHandle;
1540	–	end;
1541	–
2269		function TIBCustomDataSet.GetDeleteSQL: TStrings;
2270		begin
2271		result := FQDelete.SQL;
#	Line 1549 \| Line 2276 \| begin
2276		result := FQInsert.SQL;
2277		end;
2278
2279	<	function TIBCustomDataSet.GetSQLParams: TIBXSQLDA;
2279	>	function TIBCustomDataSet.GetSQLParams: ISQLParams;
2280		begin
2281		if not FInternalPrepared then
2282		InternalPrepare;
#	Line 1566 \| Line 2293 \| begin
2293		result := FQSelect.SQL;
2294		end;
2295
2296	<	function TIBCustomDataSet.GetStatementType: TIBSQLTypes;
2296	>	function TIBCustomDataSet.GetStatementType: TIBSQLStatementTypes;
2297		begin
2298	<	result := FQSelect.SQLType;
2298	>	result := FQSelect.SQLStatementType;
2299		end;
2300
2301		function TIBCustomDataSet.GetModifySQL: TStrings;
#	Line 1581 \| Line 2308 \| begin
2308		result := FBase.Transaction;
2309		end;
2310
1584	–	function TIBCustomDataSet.GetTRHandle: PISC_TR_HANDLE;
1585	–	begin
1586	–	result := FBase.TRHandle;
1587	–	end;
1588	–
2311		procedure TIBCustomDataSet.InternalDeleteRecord(Qry: TIBSQL; Buff: Pointer);
2312		begin
2313		if (Assigned(FUpdateObject) and (FUpdateObject.GetSQL(ukDelete).Text <> '')) then
2314	<	FUpdateObject.Apply(ukDelete)
2314	>	FUpdateObject.Apply(ukDelete,Buff)
2315		else
2316		begin
2317	<	SetInternalSQLParams(FQDelete, Buff);
2317	>	SetInternalSQLParams(FQDelete.Params, Buff);
2318		FQDelete.ExecQuery;
2319		end;
2320		with PRecordData(Buff)^ do
#	Line 1606 \| Line 2328 \| end;
2328		function TIBCustomDataSet.InternalLocate(const KeyFields: string;
2329		const KeyValues: Variant; Options: TLocateOptions): Boolean;
2330		var
2331	<	fl: TList;
2332	<	CurBookmark: string;
2333	<	fld, val: Variant;
2334	<	i, fld_cnt: Integer;
2331	>	keyFieldList: TList;
2332	>	CurBookmark: TBookmark;
2333	>	fieldValue: Variant;
2334	>	lookupValues: array of variant;
2335	>	i, fieldCount: Integer;
2336	>	fieldValueAsString: string;
2337	>	lookupValueAsString: string;
2338		begin
2339	<	fl := TList.Create;
2339	>	keyFieldList := TList.Create;
2340		try
2341	<	GetFieldList(fl, KeyFields);
2342	<	fld_cnt := fl.Count;
2341	>	GetFieldList(keyFieldList, KeyFields);
2342	>	fieldCount := keyFieldList.Count;
2343		CurBookmark := Bookmark;
2344	<	result := False;
2345	<	while ((not result) and (not EOF)) do
2344	>	result := false;
2345	>	SetLength(lookupValues, fieldCount);
2346	>	if not EOF then
2347		begin
2348	<	i := 0;
1623	<	result := True;
1624	<	while (result and (i < fld_cnt)) do
2348	>	for i := 0 to fieldCount - 1 do {expand key values into lookupValues array}
2349		begin
2350	<	if fld_cnt > 1 then
2351	<	val := KeyValues[i]
2350	>	if VarIsArray(KeyValues) then
2351	>	lookupValues[i] := KeyValues[i]
2352	>	else
2353	>	if i > 0 then
2354	>	lookupValues[i] := NULL
2355		else
2356	<	val := KeyValues;
2357	<	fld := TField(fl[i]).Value;
2358	<	result := not (VarIsNull(val) xor VarIsNull(fld));
2359	<	if result and not VarIsNull(val) then
2356	>	lookupValues[0] := KeyValues;
2357	>
2358	>	{convert to upper case is case insensitive search}
2359	>	if (TField(keyFieldList[i]).DataType = ftString) and
2360	>	not VarIsNull(lookupValues[i]) and (loCaseInsensitive in Options) then
2361	>	lookupValues[i] := UpperCase(lookupValues[i]);
2362	>	end;
2363	>	end;
2364	>	while not result and not EOF do {search for a matching record}
2365	>	begin
2366	>	i := 0;
2367	>	result := true;
2368	>	while result and (i < fieldCount) do
2369	>	{see if all of the key fields matches}
2370	>	begin
2371	>	fieldValue := TField(keyFieldList[i]).Value;
2372	>	result := not (VarIsNull(fieldValue) xor VarIsNull(lookupValues[i]));
2373	>	if result and not VarIsNull(fieldValue) then
2374		begin
2375		try
2376	<	fld := VarAsType(fld, VarType(val));
1636	<	except
1637	<	on E: EVariantError do result := False;
1638	<	end;
1639	<	if Result then
1640	<	if TField(fl[i]).DataType = ftString then
2376	>	if TField(keyFieldList[i]).DataType = ftString then
2377		begin
2378	+	{strings need special handling because of the locate options that
2379	+	apply to them}
2380	+	fieldValueAsString := TField(keyFieldList[i]).AsString;
2381	+	lookupValueAsString := lookupValues[i];
2382		if (loCaseInsensitive in Options) then
2383	<	begin
2384	<	fld := AnsiUpperCase(fld);
1645	<	val := AnsiUpperCase(val);
1646	<	end;
1647	<	fld := TrimRight(fld);
1648	<	val := TrimRight(val);
2383	>	fieldValueAsString := UpperCase(fieldValueAsString);
2384	>
2385		if (loPartialKey in Options) then
2386	<	result := result and (AnsiPos(val, fld) = 1)
2386	>	result := result and (Pos(lookupValueAsString, fieldValueAsString) = 1)
2387		else
2388	<	result := result and (val = fld);
2389	<	end else
2390	<	result := result and (val = fld);
2388	>	result := result and (fieldValueAsString = lookupValueAsString);
2389	>	end
2390	>	else
2391	>	result := result and (lookupValues[i] =
2392	>	VarAsType(fieldValue, VarType(lookupValues[i])));
2393	>	except on EVariantError do
2394	>	result := False;
2395	>	end;
2396		end;
2397		Inc(i);
2398		end;
2399		if not result then
2400	<	Next;
2400	>	Next;
2401		end;
2402		if not result then
2403		Bookmark := CurBookmark
2404		else
2405		CursorPosChanged;
2406		finally
2407	<	fl.Free;
2407	>	keyFieldList.Free;
2408	>	SetLength(lookupValues,0)
2409		end;
2410		end;
2411
2412		procedure TIBCustomDataSet.InternalPostRecord(Qry: TIBSQL; Buff: Pointer);
2413		var
2414	<	i, j, k: Integer;
2414	>	i, j, k, arr: Integer;
2415		pbd: PBlobDataArray;
2416	+	pda: PArrayDataArray;
2417		begin
2418		pbd := PBlobDataArray(PChar(Buff) + FBlobCacheOffset);
2419	<	j := 0;
2419	>	pda := PArrayDataArray(PChar(Buff) + FArrayCacheOffset);
2420	>	j := 0; arr := 0;
2421		for i := 0 to FieldCount - 1 do
2422		if Fields[i].IsBlob then
2423		begin
#	Line 1682 \| Line 2426 \| begin
2426		begin
2427		pbd^[j].Finalize;
2428		PISC_QUAD(
2429	<	PChar(Buff) + PRecordData(Buff)^.rdFields[k].fdDataOfs)^ :=
2429	>	PChar(Buff) + FFieldColumns^[k].fdDataOfs)^ :=
2430		pbd^[j].BlobID;
2431		PRecordData(Buff)^.rdFields[k].fdIsNull := pbd^[j].Size = 0;
2432	+	end
2433	+	else
2434	+	begin
2435	+	PRecordData(Buff)^.rdFields[k].fdIsNull := true;
2436	+	with PISC_QUAD(PChar(Buff) + FFieldColumns^[k].fdDataOfs)^ do
2437	+	begin
2438	+	gds_quad_high := 0;
2439	+	gds_quad_low := 0;
2440	+	end;
2441		end;
2442		Inc(j);
2443	+	end
2444	+	else
2445	+	if Fields[i] is TIBArrayField then
2446	+	begin
2447	+	if pda^[arr] <> nil then
2448	+	begin
2449	+	k := FMappedFieldPosition[Fields[i].FieldNo -1];
2450	+	PISC_QUAD(
2451	+	PChar(Buff) + FFieldColumns^[k].fdDataOfs)^ := pda^[arr].ArrayIntf.GetArrayID;
2452	+	PRecordData(Buff)^.rdFields[k].fdIsNull := pda^[arr].ArrayIntf.IsEmpty;
2453	+	end;
2454	+	Inc(arr);
2455		end;
2456		if Assigned(FUpdateObject) then
2457		begin
2458		if (Qry = FQDelete) then
2459	<	FUpdateObject.Apply(ukDelete)
2459	>	FUpdateObject.Apply(ukDelete,Buff)
2460		else if (Qry = FQInsert) then
2461	<	FUpdateObject.Apply(ukInsert)
2461	>	FUpdateObject.Apply(ukInsert,Buff)
2462		else
2463	<	FUpdateObject.Apply(ukModify);
2463	>	FUpdateObject.Apply(ukModify,Buff);
2464		end
2465		else begin
2466	<	SetInternalSQLParams(Qry, Buff);
2466	>	SetInternalSQLParams(Qry.Params, Buff);
2467		Qry.ExecQuery;
2468		end;
2469	+	if Qry.FieldCount > 0 then {Has RETURNING Clause}
2470	+	UpdateRecordFromQuery(Qry.Current,Buff);
2471		PRecordData(Buff)^.rdUpdateStatus := usUnmodified;
2472		PRecordData(Buff)^.rdCachedUpdateStatus := cusUnmodified;
2473		SetModified(False);
#	Line 1712 \| Line 2479 \| end;
2479		procedure TIBCustomDataSet.InternalRefreshRow;
2480		var
2481		Buff: PChar;
1715	–	SetCursor: Boolean;
2482		ofs: DWORD;
2483		Qry: TIBSQL;
2484		begin
2485	<	SetCursor := (GetCurrentThreadID = MainThreadID) and (Screen.Cursor = crDefault);
1720	<	if SetCursor then
1721	<	Screen.Cursor := crHourGlass;
2485	>	FBase.SetCursor;
2486		try
2487		Buff := GetActiveBuf;
2488		if CanRefresh then
#	Line 1735 \| Line 2499 \| begin
2499		end
2500		else
2501		Qry := FQRefresh;
2502	<	SetInternalSQLParams(Qry, Buff);
2502	>	SetInternalSQLParams(Qry.Params, Buff);
2503		Qry.ExecQuery;
2504		try
2505	<	if (Qry.SQLType = SQLExecProcedure) or
1742	<	(Qry.Next <> nil) then
2505	>	if (Qry.SQLStatementType = SQLExecProcedure) or Qry.Next then
2506		begin
2507		ofs := PRecordData(Buff)^.rdSavedOffset;
2508		FetchCurrentRecordToBuffer(Qry,
#	Line 1762 \| Line 2525 \| begin
2525		else
2526		IBError(ibxeCannotRefresh, [nil]);
2527		finally
2528	<	if SetCursor and (Screen.Cursor = crHourGlass) then
1766	<	Screen.Cursor := crDefault;
2528	>	FBase.RestoreCursor;
2529		end;
2530		end;
2531
#	Line 1833 \| Line 2595 \| begin
2595		end;
2596
2597		procedure TIBCustomDataSet.InternalPrepare;
1836	–	var
1837	–	SetCursor: Boolean;
1838	–	DidActivate: Boolean;
2598		begin
2599		if FInternalPrepared then
2600		Exit;
2601	<	DidActivate := False;
1843	<	SetCursor := (GetCurrentThreadID = MainThreadID) and (Screen.Cursor = crDefault);
1844	<	if SetCursor then
1845	<	Screen.Cursor := crHourGlass;
2601	>	FBase.SetCursor;
2602		try
2603		ActivateConnection;
2604	<	DidActivate := ActivateTransaction;
2604	>	ActivateTransaction;
2605		FBase.CheckDatabase;
2606		FBase.CheckTransaction;
2607	+	if HasParser and (FParser.SQLText <> FQSelect.SQL.Text) then
2608	+	begin
2609	+	FQSelect.OnSQLChanged := nil; {Do not react to change}
2610	+	try
2611	+	FQSelect.SQL.Text := FParser.SQLText;
2612	+	finally
2613	+	FQSelect.OnSQLChanged := SQLChanged;
2614	+	end;
2615	+	end;
2616	+	// writeln( FQSelect.SQL.Text);
2617		if FQSelect.SQL.Text <> '' then
2618		begin
2619		if not FQSelect.Prepared then
2620		begin
2621	+	FQSelect.GenerateParamNames := FGenerateParamNames;
2622		FQSelect.ParamCheck := ParamCheck;
2623		FQSelect.Prepare;
2624		end;
2625	<	if (FQDelete.SQL.Text <> '') and (not FQDelete.Prepared) then
2625	>	FQDelete.GenerateParamNames := FGenerateParamNames;
2626	>	if (Trim(FQDelete.SQL.Text) <> '') and (not FQDelete.Prepared) then
2627		FQDelete.Prepare;
2628	<	if (FQInsert.SQL.Text <> '') and (not FQInsert.Prepared) then
2628	>	FQInsert.GenerateParamNames := FGenerateParamNames;
2629	>	if (Trim(FQInsert.SQL.Text) <> '') and (not FQInsert.Prepared) then
2630		FQInsert.Prepare;
2631	<	if (FQRefresh.SQL.Text <> '') and (not FQRefresh.Prepared) then
2631	>	FQRefresh.GenerateParamNames := FGenerateParamNames;
2632	>	if (Trim(FQRefresh.SQL.Text) <> '') and (not FQRefresh.Prepared) then
2633		FQRefresh.Prepare;
2634	<	if (FQModify.SQL.Text <> '') and (not FQModify.Prepared) then
2634	>	FQModify.GenerateParamNames := FGenerateParamNames;
2635	>	if (Trim(FQModify.SQL.Text) <> '') and (not FQModify.Prepared) then
2636		FQModify.Prepare;
2637		FInternalPrepared := True;
2638		InternalInitFieldDefs;
2639		end else
2640		IBError(ibxeEmptyQuery, [nil]);
2641		finally
2642	<	if DidActivate then
1872	<	DeactivateTransaction;
1873	<	if SetCursor and (Screen.Cursor = crHourGlass) then
1874	<	Screen.Cursor := crDefault;
2642	>	FBase.RestoreCursor;
2643		end;
2644		end;
2645
#	Line 1900 \| Line 2668 \| var
2668		begin
2669		CopyRecordBuffer(Buffer, OldBuffer);
2670		if BlobFieldCount > 0 then
2671	<	FillChar(PChar(OldBuffer)[FBlobCacheOffset], BlobFieldCount * SizeOf(TIBBlobStream),
2671	>	FillChar(PChar(OldBuffer)[FBlobCacheOffset],
2672	>	BlobFieldCount * SizeOf(TIBBlobStream) + ArrayFieldCount * SizeOf(IArray),
2673		0);
2674		end;
2675
#	Line 1942 \| Line 2711 \| begin
2711		if (FBase.Database <> Value) then
2712		begin
2713		CheckDatasetClosed;
2714	+	InternalUnPrepare;
2715		FBase.Database := Value;
2716		FQDelete.Database := Value;
2717		FQInsert.Database := Value;
2718		FQRefresh.Database := Value;
2719		FQSelect.Database := Value;
2720		FQModify.Database := Value;
2721	+	FDatabaseInfo.Database := Value;
2722	+	FGeneratorField.Database := Value;
2723		end;
2724		end;
2725
#	Line 1969 \| Line 2741 \| begin
2741		end;
2742		end;
2743
2744	<	procedure TIBCustomDataSet.SetInternalSQLParams(Qry: TIBSQL; Buffer: Pointer);
2744	>	procedure TIBCustomDataSet.SetInternalSQLParams(Params: ISQLParams; Buffer: Pointer);
2745		var
2746		i, j: Integer;
2747		cr, data: PChar;
2748	<	fn, st: string;
2748	>	fn: string;
2749	>	st: RawByteString;
2750		OldBuffer: Pointer;
2751		ts: TTimeStamp;
2752	+	Param: ISQLParam;
2753		begin
2754		if (Buffer = nil) then
2755		IBError(ibxeBufferNotSet, [nil]);
#	Line 1983 \| Line 2757 \| begin
2757		InternalPrepare;
2758		OldBuffer := nil;
2759		try
2760	<	for i := 0 to Qry.Params.Count - 1 do
2760	>	for i := 0 to Params.GetCount - 1 do
2761		begin
2762	<	fn := Qry.Params[i].Name;
2762	>	Param := Params[i];
2763	>	fn := Param.Name;
2764		if (Pos('OLD_', fn) = 1) then {mbcs ok}
2765		begin
2766		fn := Copy(fn, 5, Length(fn));
#	Line 2005 \| Line 2780 \| begin
2780		cr := Buffer;
2781		j := FQSelect.FieldIndex[fn] + 1;
2782		if (j > 0) then
2783	<	with PRecordData(cr)^ do
2783	>	with PRecordData(cr)^,rdFields[j], FFieldColumns^[j] do
2784		begin
2785	<	if Qry.Params[i].name = 'IBX_INTERNAL_DBKEY' then {do not localize}
2785	>	if Param.name = 'IBX_INTERNAL_DBKEY' then {do not localize}
2786		begin
2787	<	PIBDBKey(Qry.Params[i].AsPointer)^ := rdDBKey;
2787	>	PIBDBKey(Param.AsPointer)^ := rdDBKey;
2788		continue;
2789		end;
2790	<	if rdFields[j].fdIsNull then
2791	<	Qry.Params[i].IsNull := True
2790	>	if fdIsNull then
2791	>	Param.IsNull := True
2792		else begin
2793	<	Qry.Params[i].IsNull := False;
2794	<	data := cr + rdFields[j].fdDataOfs;
2795	<	case rdFields[j].fdDataType of
2793	>	Param.IsNull := False;
2794	>	data := cr + fdDataOfs;
2795	>	case fdDataType of
2796		SQL_TEXT, SQL_VARYING:
2797		begin
2798	<	SetString(st, data, rdFields[j].fdDataLength);
2799	<	Qry.Params[i].AsString := st;
2798	>	SetString(st, data, fdDataLength);
2799	>	SetCodePage(st,fdCodePage,false);
2800	>	Param.AsString := st;
2801		end;
2802		SQL_FLOAT, SQL_DOUBLE, SQL_D_FLOAT:
2803	<	Qry.Params[i].AsDouble := PDouble(data)^;
2803	>	Param.AsDouble := PDouble(data)^;
2804		SQL_SHORT, SQL_LONG:
2805		begin
2806	<	if rdFields[j].fdDataScale = 0 then
2807	<	Qry.Params[i].AsLong := PLong(data)^
2808	<	else if rdFields[j].fdDataScale >= (-4) then
2809	<	Qry.Params[i].AsCurrency := PCurrency(data)^
2806	>	if fdDataScale = 0 then
2807	>	Param.AsLong := PLong(data)^
2808	>	else
2809	>	if fdDataScale >= (-4) then
2810	>	Param.AsCurrency := PCurrency(data)^
2811		else
2812	<	Qry.Params[i].AsDouble := PDouble(data)^;
2812	>	Param.AsDouble := PDouble(data)^;
2813		end;
2814		SQL_INT64:
2815		begin
2816	<	if rdFields[j].fdDataScale = 0 then
2817	<	Qry.Params[i].AsInt64 := PInt64(data)^
2041	<	else if rdFields[j].fdDataScale >= (-4) then
2042	<	Qry.Params[i].AsCurrency := PCurrency(data)^
2816	>	if fdDataScale = 0 then
2817	>	Param.AsInt64 := PInt64(data)^
2818		else
2819	<	Qry.Params[i].AsDouble := PDouble(data)^;
2819	>	if fdDataScale >= (-4) then
2820	>	Param.AsCurrency := PCurrency(data)^
2821	>	else
2822	>	Param.AsDouble := PDouble(data)^;
2823		end;
2824		SQL_BLOB, SQL_ARRAY, SQL_QUAD:
2825	<	Qry.Params[i].AsQuad := PISC_QUAD(data)^;
2826	<	SQL_TYPE_DATE:
2827	<	begin
2050	<	ts.Date := PInt(data)^;
2051	<	ts.Time := 0;
2052	<	Qry.Params[i].AsDate :=
2053	<	TimeStampToDateTime(ts);
2054	<	end;
2055	<	SQL_TYPE_TIME:
2056	<	begin
2057	<	ts.Date := 0;
2058	<	ts.Time := PInt(data)^;
2059	<	Qry.Params[i].AsTime :=
2060	<	TimeStampToDateTime(ts);
2061	<	end;
2825	>	Param.AsQuad := PISC_QUAD(data)^;
2826	>	SQL_TYPE_DATE,
2827	>	SQL_TYPE_TIME,
2828		SQL_TIMESTAMP:
2829	<	Qry.Params[i].AsDateTime :=
2830	<	TimeStampToDateTime(
2831	<	MSecsToTimeStamp(PDouble(data)^));
2829	>	{This is an IBX native format and not the TDataset approach. See also SetFieldData}
2830	>	Param.AsDateTime := PDateTime(data)^;
2831	>	SQL_BOOLEAN:
2832	>	Param.AsBoolean := PWordBool(data)^;
2833		end;
2834		end;
2835		end;
#	Line 2111 \| Line 2878 \| begin
2878		FQRefresh.Transaction := Value;
2879		FQSelect.Transaction := Value;
2880		FQModify.Transaction := Value;
2881	+	FGeneratorField.Transaction := Value;
2882		end;
2883		end;
2884
#	Line 2148 \| Line 2916 \| begin
2916		end;
2917		end;
2918
2919	+	procedure TIBCustomDataSet.RegisterIBLink(Sender: TIBControlLink);
2920	+	begin
2921	+	if FIBLinks.IndexOf(Sender) = -1 then
2922	+	FIBLinks.Add(Sender);
2923	+	end;
2924	+
2925
2926		procedure TIBCustomDataSet.SQLChanging(Sender: TObject);
2927		begin
2928	<	if FOpen then
2929	<	InternalClose;
2928	>	Active := false;
2929	>	{ if FOpen then
2930	>	InternalClose;}
2931		if FInternalPrepared then
2932		InternalUnPrepare;
2933	+	FieldDefs.Clear;
2934	+	FieldDefs.Updated := false;
2935	+	end;
2936	+
2937	+	procedure TIBCustomDataSet.SQLChanged(Sender: TObject);
2938	+	begin
2939	+	FBaseSQLSelect.assign(FQSelect.SQL);
2940		end;
2941
2942		{ I can "undelete" uninserted records (make them "inserted" again).
#	Line 2183 \| Line 2965 \| begin
2965		end;
2966		end;
2967
2968	+	procedure TIBCustomDataSet.UnRegisterIBLink(Sender: TIBControlLink);
2969	+	begin
2970	+	FIBLinks.Remove(Sender);
2971	+	end;
2972	+
2973		function TIBCustomDataSet.UpdateStatus: TUpdateStatus;
2974		begin
2975		if Active then
#	Line 2199 \| Line 2986 \| begin
2986		Result := Assigned( FQSelect ) and FQSelect.EOF;
2987		end;
2988
2989	+	function TIBCustomDataSet.ParamByName(ParamName: String): ISQLParam;
2990	+	begin
2991	+	ActivateConnection;
2992	+	ActivateTransaction;
2993	+	if not FInternalPrepared then
2994	+	InternalPrepare;
2995	+	Result := Params.ByName(ParamName);
2996	+	end;
2997	+
2998	+	{Beware: the parameter FCache is used as an identifier to determine which
2999	+	cache is being operated on and is not referenced in the computation.
3000	+	The result is an adjusted offset into the identified cache, either the
3001	+	Buffer Cache or the old Buffer Cache.}
3002	+
3003		function TIBCustomDataSet.AdjustPosition(FCache: PChar; Offset: DWORD;
3004	<	Origin: Integer): Integer;
3004	>	Origin: Integer): DWORD;
3005		var
3006		OldCacheSize: Integer;
3007		begin
#	Line 2237 \| Line 3038 \| procedure TIBCustomDataSet.ReadCache(FCa
3038		Buffer: PChar);
3039		var
3040		pCache: PChar;
3041	+	AdjustedOffset: DWORD;
3042		bOld: Boolean;
3043		begin
3044		bOld := (FCache = FOldBufferCache);
3045	<	pCache := PChar(AdjustPosition(FCache, Offset, Origin));
3045	>	AdjustedOffset := AdjustPosition(FCache, Offset, Origin);
3046		if not bOld then
3047	<	pCache := FBufferCache + Integer(pCache)
3047	>	pCache := FBufferCache + AdjustedOffset
3048		else
3049	<	pCache := FOldBufferCache + Integer(pCache);
3049	>	pCache := FOldBufferCache + AdjustedOffset;
3050		Move(pCache^, Buffer^, DWORD(FRecordBufferSize));
3051		AdjustPosition(FCache, FRecordBufferSize, FILE_CURRENT);
3052		end;
#	Line 2274 \| Line 3076 \| procedure TIBCustomDataSet.WriteCache(FC
3076		Buffer: PChar);
3077		var
3078		pCache: PChar;
3079	+	AdjustedOffset: DWORD;
3080		bOld: Boolean;
3081		dwEnd: DWORD;
3082		begin
3083		bOld := (FCache = FOldBufferCache);
3084	<	pCache := PChar(AdjustPosition(FCache, Offset, Origin));
3084	>	AdjustedOffset := AdjustPosition(FCache, Offset, Origin);
3085		if not bOld then
3086	<	pCache := FBufferCache + Integer(pCache)
3086	>	pCache := FBufferCache + AdjustedOffset
3087		else
3088	<	pCache := FOldBufferCache + Integer(pCache);
3088	>	pCache := FOldBufferCache + AdjustedOffset;
3089		Move(Buffer^, pCache^, FRecordBufferSize);
3090		dwEnd := AdjustPosition(FCache, FRecordBufferSize, FILE_CURRENT);
3091		if not bOld then
#	Line 2320 \| Line 3123 \| var
3123		Buff: PChar;
3124		bTr, bDB: Boolean;
3125		begin
3126	+	if (Field = nil) or (Field.DataSet <> self) then
3127	+	IBError(ibxFieldNotinDataSet,[Field.Name,Name]);
3128		Buff := GetActiveBuf;
3129		if Buff = nil then
3130		begin
3131		fs := TIBBlobStream.Create;
3132		fs.Mode := bmReadWrite;
3133	+	fs.Database := Database;
3134	+	fs.Transaction := Transaction;
3135	+	fs.SetField(Field);
3136		FBlobStreamList.Add(Pointer(fs));
3137		result := TIBDSBlobStream.Create(Field, fs, Mode);
3138		exit;
#	Line 2339 \| Line 3147 \| begin
3147		fs.Mode := bmReadWrite;
3148		fs.Database := Database;
3149		fs.Transaction := Transaction;
3150	+	fs.SetField(Field);
3151		fs.BlobID :=
3152	<	PISC_QUAD(@Buff[PRecordData(Buff)^.rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdDataOfs])^;
3152	>	PISC_QUAD(@Buff[FFieldColumns^[FMappedFieldPosition[Field.FieldNo - 1]].fdDataOfs])^;
3153		if (CachedUpdates) then
3154		begin
3155		bTr := not Transaction.InTransaction;
#	Line 2361 \| Line 3170 \| begin
3170		result := TIBDSBlobStream.Create(Field, fs, Mode);
3171		end;
3172
3173	+	function TIBCustomDataSet.GetArray(Field: TIBArrayField): IArray;
3174	+	var Buff: PChar;
3175	+	pda: PArrayDataArray;
3176	+	bTr, bDB: Boolean;
3177	+	begin
3178	+	if (Field = nil) or (Field.DataSet <> self) then
3179	+	IBError(ibxFieldNotinDataSet,[Field.Name,Name]);
3180	+	Buff := GetActiveBuf;
3181	+	if Buff = nil then
3182	+	Result := Database.Attachment.CreateArray(Transaction.TransactionIntf,
3183	+	Field.FRelationName,Field.FieldName)
3184	+	else
3185	+	begin
3186	+	pda := PArrayDataArray(Buff + FArrayCacheOffset);
3187	+	if pda^[Field.FCacheOffset] = nil then
3188	+	begin
3189	+	AdjustRecordOnInsert(Buff);
3190	+	if Field.IsNull then
3191	+	Result := Database.Attachment.CreateArray(Transaction.TransactionIntf,
3192	+	Field.FRelationName,Field.FieldName)
3193	+	else
3194	+	Result := Database.Attachment.OpenArray(Transaction.TransactionIntf,
3195	+	Field.FRelationName,Field.FieldName,Field.ArrayID);
3196	+	pda^[Field.FCacheOffset] := TIBArray.Create(Field,Result);
3197	+	FArrayList.Add(pda^[Field.FCacheOffset]);
3198	+	if (CachedUpdates) then
3199	+	begin
3200	+	bTr := not Transaction.InTransaction;
3201	+	bDB := not Database.Connected;
3202	+	if bDB then
3203	+	Database.Open;
3204	+	if bTr then
3205	+	Transaction.StartTransaction;
3206	+	pda^[Field.FCacheOffset].ArrayIntf.PreLoad;
3207	+	if bTr then
3208	+	Transaction.Commit;
3209	+	if bDB then
3210	+	Database.Close;
3211	+	end;
3212	+	WriteRecordCache(PRecordData(Buff)^.rdRecordNumber, Pointer(Buff));
3213	+	end
3214	+	else
3215	+	Result := pda^[Field.FCacheOffset].ArrayIntf;
3216	+	end;
3217	+	end;
3218	+
3219	+	procedure TIBCustomDataSet.SetArrayIntf(AnArray: IArray; Field: TIBArrayField);
3220	+	var Buff: PChar;
3221	+	pda: PArrayDataArray;
3222	+	begin
3223	+	if (Field = nil) or (Field.DataSet <> self) then
3224	+	IBError(ibxFieldNotinDataSet,[Field.Name,Name]);
3225	+	Buff := GetActiveBuf;
3226	+	if Buff <> nil then
3227	+	begin
3228	+	AdjustRecordOnInsert(Buff);
3229	+	pda := PArrayDataArray(Buff + FArrayCacheOffset);
3230	+	pda^[Field.FCacheOffset].FArray := AnArray;
3231	+	WriteRecordCache(PRecordData(Buff)^.rdRecordNumber, Pointer(Buff));
3232	+	end;
3233	+	end;
3234	+
3235		function TIBCustomDataSet.CompareBookmarks(Bookmark1, Bookmark2: TBookmark): Integer;
3236		const
3237		CMPLess = -1;
#	Line 2396 \| Line 3267 \| begin
3267		inherited DoBeforeDelete;
3268		end;
3269
3270	+	procedure TIBCustomDataSet.DoAfterDelete;
3271	+	begin
3272	+	inherited DoAfterDelete;
3273	+	FBase.DoAfterDelete(self);
3274	+	InternalAutoCommit;
3275	+	end;
3276	+
3277		procedure TIBCustomDataSet.DoBeforeEdit;
3278		var
3279		Buff: PRecordData;
#	Line 2410 \| Line 3288 \| begin
3288		inherited DoBeforeEdit;
3289		end;
3290
3291	+	procedure TIBCustomDataSet.DoAfterEdit;
3292	+	begin
3293	+	inherited DoAfterEdit;
3294	+	FBase.DoAfterEdit(self);
3295	+	end;
3296	+
3297		procedure TIBCustomDataSet.DoBeforeInsert;
3298		begin
3299		if not CanInsert then
#	Line 2419 \| Line 3303 \| end;
3303
3304		procedure TIBCustomDataSet.DoAfterInsert;
3305		begin
3306	<	if Generator.ApplyOnEvent = gaeOnNewRecord then
3307	<	Generator.Apply;
3306	>	if GeneratorField.ApplyOnEvent = gaeOnNewRecord then
3307	>	GeneratorField.Apply;
3308		inherited DoAfterInsert;
3309	+	FBase.DoAfterInsert(self);
3310	+	end;
3311	+
3312	+	procedure TIBCustomDataSet.DoBeforeClose;
3313	+	begin
3314	+	inherited DoBeforeClose;
3315	+	if FInTransactionEnd and (FCloseAction = TARollback) then
3316	+	Exit;
3317	+	if State in [dsInsert,dsEdit] then
3318	+	begin
3319	+	if DataSetCloseAction = dcSaveChanges then
3320	+	Post;
3321	+	{Note this can fail with an exception e.g. due to
3322	+	database validation error. In which case the dataset remains open }
3323	+	end;
3324	+	if FCachedUpdates and FUpdatesPending and (DataSetCloseAction = dcSaveChanges) then
3325	+	ApplyUpdates;
3326	+	end;
3327	+
3328	+	procedure TIBCustomDataSet.DoBeforeOpen;
3329	+	var i: integer;
3330	+	begin
3331	+	if assigned(FParser) then
3332	+	FParser.Reset;
3333	+	for i := 0 to FIBLinks.Count - 1 do
3334	+	TIBControlLink(FIBLinks[i]).UpdateSQL(self);
3335	+	inherited DoBeforeOpen;
3336	+	for i := 0 to FIBLinks.Count - 1 do
3337	+	TIBControlLink(FIBLinks[i]).UpdateParams(self);
3338		end;
3339
3340		procedure TIBCustomDataSet.DoBeforePost;
3341		begin
3342		inherited DoBeforePost;
3343		if (State = dsInsert) and
3344	<	(Generator.ApplyOnEvent = gaeOnPostRecord) then
3345	<	Generator.Apply
3344	>	(GeneratorField.ApplyOnEvent = gaeOnPostRecord) then
3345	>	GeneratorField.Apply
3346	>	end;
3347	>
3348	>	procedure TIBCustomDataSet.DoAfterPost;
3349	>	begin
3350	>	inherited DoAfterPost;
3351	>	FBase.DoAfterPost(self);
3352	>	InternalAutoCommit;
3353		end;
3354
3355		procedure TIBCustomDataSet.FetchAll;
3356		var
3357	<	SetCursor: Boolean;
2438	<	CurBookmark: string;
3357	>	CurBookmark: TBookmark;
3358		begin
3359	<	SetCursor := (GetCurrentThreadID = MainThreadID) and (Screen.Cursor = crDefault);
3360	<	if SetCursor then
2442	<	Screen.Cursor := crHourGlass;
2443	<	try
3359	>	FBase.SetCursor;
3360	>	try
3361		if FQSelect.EOF or not FQSelect.Open then
3362		exit;
3363		DisableControls;
#	Line 2452 \| Line 3369 \| begin
3369		EnableControls;
3370		end;
3371		finally
3372	<	if SetCursor and (Screen.Cursor = crHourGlass) then
2456	<	Screen.Cursor := crDefault;
3372	>	FBase.RestoreCursor;
3373		end;
3374		end;
3375
#	Line 2501 \| Line 3417 \| begin
3417		result := FDataLink.DataSource;
3418		end;
3419
3420	+	function TIBCustomDataSet.GetDBAliasName(FieldNo: integer): string;
3421	+	begin
3422	+	Result := FAliasNameMap[FieldNo-1]
3423	+	end;
3424	+
3425	+	function TIBCustomDataSet.GetFieldDefFromAlias(aliasName: string): TFieldDef;
3426	+	var
3427	+	i: integer;
3428	+	begin
3429	+	Result := nil;
3430	+	for i := 0 to Length(FAliasNameMap) - 1 do
3431	+	if FAliasNameMap[i] = aliasName then
3432	+	begin
3433	+	Result := FieldDefs[i];
3434	+	Exit
3435	+	end;
3436	+	end;
3437	+
3438		function TIBCustomDataSet.GetFieldClass(FieldType: TFieldType): TFieldClass;
3439		begin
3440		Result := DefaultFieldClasses[FieldType];
#	Line 2519 \| Line 3453 \| begin
3453		result := False;
3454		Buff := GetActiveBuf;
3455		if (Buff = nil) or
3456	<	(not IsVisible(Buff)) then
3456	>	(not IsVisible(Buff)) or not assigned(Field.DataSet) then
3457		exit;
3458		{ The intention here is to stuff the buffer with the data for the
3459		referenced field for the current record }
#	Line 2531 \| Line 3465 \| begin
3465		if result and (Buffer <> nil) then
3466		Move(Buff[1], Buffer^, Field.DataSize);
3467		end
3468	<	else if (FMappedFieldPosition[Field.FieldNo - 1] > 0) and
3468	>	else
3469	>	if (FMappedFieldPosition[Field.FieldNo - 1] > 0) and
3470		(FMappedFieldPosition[Field.FieldNo - 1] <= CurrentRecord^.rdFieldCount) then
3471	+	with CurrentRecord^.rdFields[FMappedFieldPosition[Field.FieldNo - 1]],
3472	+	FFieldColumns^[FMappedFieldPosition[Field.FieldNo - 1]] do
3473		begin
3474	<	result := not CurrentRecord^.rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdIsNull;
3474	>	result := not fdIsNull;
3475		if result and (Buffer <> nil) then
2539	–	with CurrentRecord^.rdFields[FMappedFieldPosition[Field.FieldNo - 1]] do
3476		begin
3477	<	Data := Buff + CurrentRecord^.rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdDataOfs;
3477	>	Data := Buff + fdDataOfs;
3478		if (fdDataType = SQL_VARYING) or (fdDataType = SQL_TEXT) then
3479		begin
3480	<	Move(Data^, Buffer^, fdDataLength);
3481	<	PChar(Buffer)[fdDataLength] := #0;
3480	>	if fdDataLength < Field.DataSize then
3481	>	begin
3482	>	Move(Data^, Buffer^, fdDataLength);
3483	>	PChar(Buffer)[fdDataLength] := #0;
3484	>	end
3485	>	else
3486	>	IBError(ibxeFieldSizeError,[Field.FieldName])
3487		end
3488		else
3489		Move(Data^, Buffer^, Field.DataSize);
#	Line 2585 \| Line 3526 \| begin
3526		if not Accept and (GetMode = gmCurrent) then
3527		GetMode := gmPrior;
3528		except
3529	<	// Application.HandleException(Self);
3529	>	// FBase.HandleException(Self);
3530		end;
3531		end;
3532		RestoreState(SaveState);
#	Line 2604 \| Line 3545 \| begin
3545		if FCurrentRecord < FRecordCount then
3546		ReadRecordCache(FCurrentRecord, Buffer, False)
3547		else begin
3548	<	while (not FQSelect.EOF) and
2608	<	(FQSelect.Next <> nil) and
3548	>	while (not FQSelect.EOF) and FQSelect.Next and
3549		(FCurrentRecord >= FRecordCount) do begin
3550		FetchCurrentRecordToBuffer(FQSelect, FRecordCount, Buffer);
3551		Inc(FRecordCount);
#	Line 2679 \| Line 3619 \| begin
3619		result := FRecordBufferSize;
3620		end;
3621
3622	+	procedure TIBCustomDataSet.InternalAutoCommit;
3623	+	begin
3624	+	with Transaction do
3625	+	if InTransaction and (FAutoCommit = acCommitRetaining) then
3626	+	begin
3627	+	if CachedUpdates then ApplyUpdates;
3628	+	CommitRetaining;
3629	+	end;
3630	+	end;
3631	+
3632		procedure TIBCustomDataSet.InternalAddRecord(Buffer: Pointer; Append: Boolean);
3633		begin
3634		CheckEditState;
#	Line 2706 \| Line 3656 \| procedure TIBCustomDataSet.InternalCance
3656		var
3657		Buff: PChar;
3658		CurRec: Integer;
3659	+	pda: PArrayDataArray;
3660	+	i: integer;
3661		begin
3662		inherited InternalCancel;
3663		Buff := GetActiveBuf;
3664	<	if Buff <> nil then begin
3664	>	if Buff <> nil then
3665	>	begin
3666	>	pda := PArrayDataArray(Buff + FArrayCacheOffset);
3667	>	for i := 0 to ArrayFieldCount - 1 do
3668	>	pda^[i].ArrayIntf.CancelChanges;
3669		CurRec := FCurrentRecord;
3670		AdjustRecordOnInsert(Buff);
3671		if (State = dsEdit) then begin
#	Line 2732 \| Line 3688 \| begin
3688		DeactivateTransaction;
3689		FQSelect.Close;
3690		ClearBlobCache;
3691	+	ClearArrayCache;
3692		FreeRecordBuffer(FModelBuffer);
3693		FreeRecordBuffer(FOldBuffer);
3694		FCurrentRecord := -1;
#	Line 2747 \| Line 3704 \| begin
3704		FOBEnd := 0;
3705		FreeMem(FBufferCache);
3706		FBufferCache := nil;
3707	+	FreeMem(FFieldColumns);
3708	+	FFieldColumns := nil;
3709		FreeMem(FOldBufferCache);
3710		FOldBufferCache := nil;
3711		BindFields(False);
3712	+	ResetParser;
3713		if DefaultFields then DestroyFields;
3714		end;
3715
3716		procedure TIBCustomDataSet.InternalDelete;
3717		var
3718		Buff: PChar;
2759	–	SetCursor: Boolean;
3719		begin
3720	<	SetCursor := (GetCurrentThreadID = MainThreadID) and (Screen.Cursor = crDefault);
2762	<	if SetCursor then
2763	<	Screen.Cursor := crHourGlass;
3720	>	FBase.SetCursor;
3721		try
3722		Buff := GetActiveBuf;
3723		if CanDelete then
#	Line 2785 \| Line 3742 \| begin
3742		end else
3743		IBError(ibxeCannotDelete, [nil]);
3744		finally
3745	<	if SetCursor and (Screen.Cursor = crHourGlass) then
2789	<	Screen.Cursor := crDefault;
3745	>	FBase.RestoreCursor;
3746		end;
3747		end;
3748
#	Line 2802 \| Line 3758 \| end;
3758
3759		procedure TIBCustomDataSet.InternalHandleException;
3760		begin
3761	<	Application.HandleException(Self)
3761	>	FBase.HandleException(Self)
3762		end;
3763
3764		procedure TIBCustomDataSet.InternalInitFieldDefs;
3765	+	begin
3766	+	if not InternalPrepared then
3767	+	begin
3768	+	InternalPrepare;
3769	+	exit;
3770	+	end;
3771	+	FieldDefsFromQuery(FQSelect);
3772	+	end;
3773	+
3774	+	procedure TIBCustomDataSet.FieldDefsFromQuery(SourceQuery: TIBSQL);
3775		const
3776		DefaultSQL = 'Select F.RDB$COMPUTED_BLR, ' + {do not localize}
3777		'F.RDB$DEFAULT_VALUE, R.RDB$FIELD_NAME ' + {do not localize}
#	Line 2814 \| Line 3780 \| const
3780		'and R.RDB$FIELD_SOURCE = F.RDB$FIELD_NAME '+ {do not localize}
3781		'and ((not F.RDB$COMPUTED_BLR is NULL) or ' + {do not localize}
3782		' (not F.RDB$DEFAULT_VALUE is NULL)) '; {do not localize}
3783	+
3784	+	DefaultSQLODS12 = 'Select F.RDB$COMPUTED_BLR, ' + {do not localize}
3785	+	'F.RDB$DEFAULT_VALUE, R.RDB$FIELD_NAME, R.RDB$IDENTITY_TYPE ' + {do not localize}
3786	+	'from RDB$RELATION_FIELDS R, RDB$FIELDS F ' + {do not localize}
3787	+	'where R.RDB$RELATION_NAME = :RELATION ' + {do not localize}
3788	+	'and R.RDB$FIELD_SOURCE = F.RDB$FIELD_NAME '+ {do not localize}
3789	+	'and ((not F.RDB$COMPUTED_BLR is NULL) or ' + {do not localize}
3790	+	' (not F.RDB$DEFAULT_VALUE is NULL) or ' + {do not localize}
3791	+	' ( not R.RDB$IDENTITY_TYPE is NULL))' ; {do not localize}
3792	+
3793		var
3794		FieldType: TFieldType;
3795		FieldSize: Word;
3796	+	FieldDataSize: integer;
3797	+	charSetID: short;
3798	+	CharSetSize: integer;
3799	+	CharSetName: RawByteString;
3800	+	FieldCodePage: TSystemCodePage;
3801		FieldNullable : Boolean;
3802		i, FieldPosition, FieldPrecision: Integer;
3803	<	FieldAliasName: string;
3804	<	RelationName, FieldName: string;
3803	>	FieldAliasName, DBAliasName: string;
3804	>	aRelationName, FieldName: string;
3805		Query : TIBSQL;
3806		FieldIndex: Integer;
3807		FRelationNodes : TRelationNode;
3808	+	aArrayDimensions: integer;
3809	+	aArrayBounds: TArrayBounds;
3810	+	ArrayMetaData: IArrayMetaData;
3811
3812		function Add_Node(Relation, Field : String) : TRelationNode;
3813		var
#	Line 2846 \| Line 3830 \| var
3830		FField.FieldName := Query.Fields[2].AsString;
3831		FField.DEFAULT_VALUE := not Query.Fields[1].IsNull;
3832		FField.COMPUTED_BLR := not Query.Fields[0].IsNull;
3833	+	FField.IDENTITY_COLUMN := (Query.FieldCount > 3) and not Query.Fields[3].IsNull;
3834		FField.NextField := Result.FieldNodes;
3835		Result.FieldNodes := FField;
3836		Query.Next;
#	Line 2899 \| Line 3884 \| var
3884		FField := Ffield.NextField;
3885		end;
3886
3887	+	function Is_IDENTITY_COLUMN(Relation, Field : String) : Boolean;
3888	+	var
3889	+	FRelation : TRelationNode;
3890	+	FField : TFieldNode;
3891	+	begin
3892	+	FRelation := FRelationNodes;
3893	+	while Assigned(FRelation) and
3894	+	(FRelation.RelationName <> Relation) do
3895	+	FRelation := FRelation.NextRelation;
3896	+	if not Assigned(FRelation) then
3897	+	FRelation := Add_Node(Relation, Field);
3898	+	Result := false;
3899	+	FField := FRelation.FieldNodes;
3900	+	while Assigned(FField) do
3901	+	if FField.FieldName = Field then
3902	+	begin
3903	+	Result := Ffield.IDENTITY_COLUMN;
3904	+	Exit;
3905	+	end
3906	+	else
3907	+	FField := Ffield.NextField;
3908	+	end;
3909	+
3910		Procedure FreeNodes;
3911		var
3912		FRelation : TRelationNode;
#	Line 2919 \| Line 3927 \| var
3927		end;
3928
3929		begin
2922	–	if not InternalPrepared then
2923	–	begin
2924	–	InternalPrepare;
2925	–	exit;
2926	–	end;
3930		FRelationNodes := TRelationNode.Create;
3931		FNeedsRefresh := False;
3932	<	Database.InternalTransaction.StartTransaction;
3932	>	if not Database.InternalTransaction.InTransaction then
3933	>	Database.InternalTransaction.StartTransaction;
3934		Query := TIBSQL.Create(self);
3935		try
3936		Query.Database := DataBase;
#	Line 2934 \| Line 3938 \| begin
3938		FieldDefs.BeginUpdate;
3939		FieldDefs.Clear;
3940		FieldIndex := 0;
3941	<	if (Length(FMappedFieldPosition) < FQSelect.Current.Count) then
3942	<	SetLength(FMappedFieldPosition, FQSelect.Current.Count);
3943	<	Query.SQL.Text := DefaultSQL;
3941	>	if (Length(FMappedFieldPosition) < SourceQuery.MetaData.Count) then
3942	>	SetLength(FMappedFieldPosition, SourceQuery.MetaData.Count);
3943	>	if FDatabaseInfo.ODSMajorVersion >= 12 then
3944	>	Query.SQL.Text := DefaultSQLODS12
3945	>	else
3946	>	Query.SQL.Text := DefaultSQL;
3947		Query.Prepare;
3948	<	for i := 0 to FQSelect.Current.Count - 1 do
3949	<	with FQSelect.Current[i].Data^ do
3948	>	SetLength(FAliasNameMap, SourceQuery.MetaData.Count);
3949	>	SetLength(FAliasNameList, SourceQuery.MetaData.Count);
3950	>	for i := 0 to SourceQuery.MetaData.GetCount - 1 do
3951	>	with SourceQuery.MetaData[i] do
3952		begin
3953		{ Get the field name }
3954	<	SetString(FieldAliasName, aliasname, aliasname_length);
3955	<	SetString(RelationName, relname, relname_length);
3956	<	SetString(FieldName, sqlname, sqlname_length);
3954	>	FieldAliasName := GetName;
3955	>	DBAliasName := GetAliasname;
3956	>	aRelationName := getRelationName;
3957	>	FieldName := getSQLName;
3958	>	FAliasNameList[i] := DBAliasName;
3959		FieldSize := 0;
3960	+	FieldDataSize := GetSize;
3961		FieldPrecision := 0;
3962	<	FieldNullable := FQSelect.Current[i].IsNullable;
3963	<	case sqltype and not 1 of
3962	>	FieldNullable := IsNullable;
3963	>	CharSetSize := 0;
3964	>	CharSetName := '';
3965	>	FieldCodePage := CP_NONE;
3966	>	aArrayDimensions := 0;
3967	>	SetLength(aArrayBounds,0);
3968	>	case SQLType of
3969		{ All VARCHAR's must be converted to strings before recording
3970		their values }
3971		SQL_VARYING, SQL_TEXT:
3972		begin
3973	<	FieldSize := sqllen;
3973	>	if not Database.Attachment.CharSetWidth(getCharSetID,CharSetSize) then
3974	>	CharSetSize := 1;
3975	>	CharSetName := Database.Attachment.GetCharsetName(getCharSetID);
3976	>	Database.Attachment.CharSetID2CodePage(getCharSetID,FieldCodePage);
3977	>	FieldSize := FieldDataSize div CharSetSize;
3978		FieldType := ftString;
3979		end;
3980		{ All Doubles/Floats should be cast to doubles }
#	Line 2961 \| Line 3982 \| begin
3982		FieldType := ftFloat;
3983		SQL_SHORT:
3984		begin
3985	<	if (sqlscale = 0) then
3985	>	if (getScale = 0) then
3986		FieldType := ftSmallInt
3987		else begin
3988		FieldType := ftBCD;
3989		FieldPrecision := 4;
3990	<	FieldSize := -sqlscale;
3990	>	FieldSize := -getScale;
3991		end;
3992		end;
3993		SQL_LONG:
3994		begin
3995	<	if (sqlscale = 0) then
3995	>	if (getScale = 0) then
3996		FieldType := ftInteger
3997	<	else if (sqlscale >= (-4)) then
3997	>	else if (getScale >= (-4)) then
3998		begin
3999		FieldType := ftBCD;
4000		FieldPrecision := 9;
4001	<	FieldSize := -sqlscale;
4001	>	FieldSize := -getScale;
4002		end
4003		else
4004	<	FieldType := ftFloat;
4004	>	if Database.SQLDialect = 1 then
4005	>	FieldType := ftFloat
4006	>	else
4007	>	if (FieldCount > i) and (Fields[i] is TFloatField) then
4008	>	FieldType := ftFloat
4009	>	else
4010	>	begin
4011	>	FieldType := ftFMTBCD;
4012	>	FieldPrecision := 9;
4013	>	FieldSize := -getScale;
4014		end;
4015	+	end;
4016	+
4017		SQL_INT64:
4018		begin
4019	<	if (sqlscale = 0) then
4019	>	if (getScale = 0) then
4020		FieldType := ftLargeInt
4021	<	else if (sqlscale >= (-4)) then
4021	>	else if (getScale >= (-4)) then
4022		begin
4023		FieldType := ftBCD;
4024		FieldPrecision := 18;
4025	<	FieldSize := -sqlscale;
4025	>	FieldSize := -getScale;
4026		end
4027		else
4028		FieldType := ftFloat;
4029	<	end;
4029	>	end;
4030		SQL_TIMESTAMP: FieldType := ftDateTime;
4031		SQL_TYPE_TIME: FieldType := ftTime;
4032		SQL_TYPE_DATE: FieldType := ftDate;
4033		SQL_BLOB:
4034		begin
4035		FieldSize := sizeof (TISC_QUAD);
4036	<	if (sqlsubtype = 1) then
4037	<	FieldType := ftmemo
4036	>	if (getSubtype = 1) then
4037	>	begin
4038	>	if not Database.Attachment.CharSetWidth(getCharSetID,CharSetSize) then
4039	>	CharSetSize := 1;
4040	>	CharSetName := Database.Attachment.GetCharsetName(getCharSetID);
4041	>	Database.Attachment.CharSetID2CodePage(getCharSetID,FieldCodePage);
4042	>	FieldType := ftMemo;
4043	>	end
4044		else
4045		FieldType := ftBlob;
4046		end;
4047		SQL_ARRAY:
4048		begin
4049		FieldSize := sizeof (TISC_QUAD);
4050	<	FieldType := ftUnknown;
4050	>	FieldType := ftArray;
4051	>	ArrayMetaData := GetArrayMetaData;
4052	>	if ArrayMetaData <> nil then
4053	>	begin
4054	>	aArrayDimensions := ArrayMetaData.GetDimensions;
4055	>	aArrayBounds := ArrayMetaData.GetBounds;
4056	>	end;
4057		end;
4058	+	SQL_BOOLEAN:
4059	+	FieldType:= ftBoolean;
4060		else
4061		FieldType := ftUnknown;
4062		end;
#	Line 3019 \| Line 4065 \| begin
4065		begin
4066		FMappedFieldPosition[FieldIndex] := FieldPosition;
4067		Inc(FieldIndex);
4068	<	with FieldDefs.AddFieldDef do
4068	>	with TIBFieldDef.Create(FieldDefs,'',FieldType,0,False,FieldDefs.Count+1) do
4069		begin
4070	<	Name := string( FieldAliasName );
4071	<	(* FieldNo := FieldPosition;*)
3026	<	DataType := FieldType;
4070	>	Name := FieldAliasName;
4071	>	FAliasNameMap[FieldNo-1] := DBAliasName;
4072		Size := FieldSize;
4073	+	DataSize := FieldDataSize;
4074		Precision := FieldPrecision;
4075		Required := not FieldNullable;
4076	+	RelationName := aRelationName;
4077		InternalCalcField := False;
4078	+	CharacterSetSize := CharSetSize;
4079	+	CharacterSetName := CharSetName;
4080	+	CodePage := FieldCodePage;
4081	+	ArrayDimensions := aArrayDimensions;
4082	+	ArrayBounds := aArrayBounds;
4083		if (FieldName <> '') and (RelationName <> '') then
4084		begin
4085	+	IdentityColumn := Is_IDENTITY_COLUMN(RelationName, FieldName);
4086		if Has_COMPUTED_BLR(RelationName, FieldName) then
4087		begin
4088		Attributes := [faReadOnly];
#	Line 3055 \| Line 4108 \| begin
4108		FreeNodes;
4109		Database.InternalTransaction.Commit;
4110		FieldDefs.EndUpdate;
4111	+	FieldDefs.Updated := true;
4112		end;
4113		end;
4114
#	Line 3072 \| Line 4126 \| begin
4126		else begin
4127		Buffer := AllocRecordBuffer;
4128		try
4129	<	while FQSelect.Next <> nil do
4129	>	while FQSelect.Next do
4130		begin
4131		FetchCurrentRecordToBuffer(FQSelect, FRecordCount, Buffer);
4132		Inc(FRecordCount);
#	Line 3087 \| Line 4141 \| end;
4141		procedure TIBCustomDataSet.InternalSetParamsFromCursor;
4142		var
4143		i: Integer;
4144	<	cur_param: TIBXSQLVAR;
4144	>	cur_param: ISQLParam;
4145		cur_field: TField;
4146		s: TStream;
4147		begin
#	Line 3095 \| Line 4149 \| begin
4149		IBError(ibxeEmptyQuery, [nil]);
4150		if not FInternalPrepared then
4151		InternalPrepare;
4152	<	if (SQLParams.Count > 0) and (DataSource <> nil) and (DataSource.DataSet <> nil) then
4152	>	if (SQLParams.GetCount > 0) and (DataSource <> nil) and (DataSource.DataSet <> nil) then
4153		begin
4154	<	for i := 0 to SQLParams.Count - 1 do
4154	>	for i := 0 to SQLParams.GetCount - 1 do
4155		begin
4156		cur_field := DataSource.DataSet.FindField(SQLParams[i].Name);
4157	<	cur_param := SQLParams[i];
4158	<	if (cur_field <> nil) then begin
4157	>	if (cur_field <> nil) then
4158	>	begin
4159	>	cur_param := SQLParams[i];
4160		if (cur_field.IsNull) then
4161		cur_param.IsNull := True
4162	<	else case cur_field.DataType of
4162	>	else
4163	>	case cur_field.DataType of
4164		ftString:
4165		cur_param.AsString := cur_field.AsString;
4166	<	ftBoolean, ftSmallint, ftWord:
4166	>	ftBoolean:
4167	>	cur_param.AsBoolean := cur_field.AsBoolean;
4168	>	ftSmallint, ftWord:
4169		cur_param.AsShort := cur_field.AsInteger;
4170		ftInteger:
4171		cur_param.AsLong := cur_field.AsInteger;
4172		ftLargeInt:
4173	<	cur_param.AsInt64 := TLargeIntField(cur_field).AsLargeInt;
4173	>	cur_param.AsInt64 := cur_field.AsLargeInt;
4174		ftFloat, ftCurrency:
4175		cur_param.AsDouble := cur_field.AsFloat;
4176		ftBCD:
#	Line 3129 \| Line 4187 \| begin
4187		try
4188		s := DataSource.DataSet.
4189		CreateBlobStream(cur_field, bmRead);
4190	<	cur_param.LoadFromStream(s);
4190	>	cur_param.AsBlob := TIBDSBlobStream(s).FBlobStream.Blob;
4191		finally
4192		s.free;
4193		end;
4194		end;
4195	+	ftArray:
4196	+	cur_param.AsArray := TIBArrayField(cur_field).ArrayIntf;
4197		else
4198		IBError(ibxeNotSupported, [nil]);
4199		end;
#	Line 3160 \| Line 4220 \| begin
4220		end;
4221
4222		procedure TIBCustomDataSet.InternalOpen;
3163	–	var
3164	–	SetCursor: Boolean;
4223
4224		function RecordDataLength(n: Integer): Long;
4225		begin
#	Line 3169 \| Line 4227 \| var
4227		end;
4228
4229		begin
4230	<	SetCursor := (GetCurrentThreadID = MainThreadID) and (Screen.Cursor = crDefault);
3173	<	if SetCursor then
3174	<	Screen.Cursor := crHourGlass;
4230	>	FBase.SetCursor;
4231		try
4232		ActivateConnection;
4233		ActivateTransaction;
#	Line 3179 \| Line 4235 \| begin
4235		IBError(ibxeEmptyQuery, [nil]);
4236		if not FInternalPrepared then
4237		InternalPrepare;
4238	<	if FQSelect.SQLType = SQLSelect then
4238	>	if FQSelect.SQLStatementType = SQLSelect then
4239		begin
4240		if DefaultFields then
4241		CreateFields;
4242	+	FArrayFieldCount := 0;
4243		BindFields(True);
4244		FCurrentRecord := -1;
4245		FQSelect.ExecQuery;
#	Line 3194 \| Line 4251 \| begin
4251		3. After the dummy fetch, FRecordSize will be appropriately
4252		adjusted to reflect the additional "weight" of the field
4253		data.
4254	<	4. Set up the FCalcFieldsOffset, FBlobCacheOffset and FRecordBufferSize.
4254	>	4. Set up the FCalcFieldsOffset, FBlobCacheOffset, FArrayCacheOffset and FRecordBufferSize.
4255		5. Now, with the BufferSize available, allocate memory for chunks of records
4256		6. Re-allocate the model buffer, accounting for the new
4257		FRecordBufferSize.
4258		7. Finally, calls to AllocRecordBuffer will work!.
4259		}
4260		{Step 1}
4261	<	FRecordSize := RecordDataLength(FQSelect.Current.Count);
4261	>	FRecordSize := RecordDataLength(FQSelect.FieldCount);
4262		{Step 2, 3}
4263	+	GetMem(FFieldColumns,sizeof(TFieldColumns) * (FQSelect.FieldCount));
4264		IBAlloc(FModelBuffer, 0, FRecordSize);
4265	<	FetchCurrentRecordToBuffer(FQSelect, -1, FModelBuffer);
4265	>	InitModelBuffer(FQSelect, FModelBuffer);
4266		{Step 4}
4267		FCalcFieldsOffset := FRecordSize;
4268		FBlobCacheOffset := FCalcFieldsOffset + CalcFieldsSize;
4269	<	FRecordBufferSize := (FBlobCacheOffset + (BlobFieldCount * SizeOf(TIBBlobStream)));
4269	>	FArrayCacheOffset := (FBlobCacheOffset + (BlobFieldCount * SizeOf(TIBBlobStream)));
4270	>	FRecordBufferSize := FArrayCacheOffset + (ArrayFieldCount * sizeof(IArray));
4271		{Step 5}
4272		if UniDirectional then
4273		FBufferChunkSize := FRecordBufferSize * UniCache
#	Line 3224 \| Line 4283 \| begin
4283		FCacheSize := FBufferChunkSize;
4284		FOldCacheSize := FBufferChunkSize;
4285		{Step 6}
4286	<	IBAlloc(FModelBuffer, RecordDataLength(FQSelect.Current.Count),
4286	>	IBAlloc(FModelBuffer, RecordDataLength(FQSelect.FieldCount),
4287		FRecordBufferSize);
4288		{Step 7}
4289		FOldBuffer := AllocRecordBuffer;
#	Line 3232 \| Line 4291 \| begin
4291		else
4292		FQSelect.ExecQuery;
4293		finally
4294	<	if SetCursor and (Screen.Cursor = crHourGlass) then
3236	<	Screen.Cursor := crDefault;
4294	>	FBase.RestoreCursor;
4295		end;
4296		end;
4297
#	Line 3241 \| Line 4299 \| procedure TIBCustomDataSet.InternalPost;
4299		var
4300		Qry: TIBSQL;
4301		Buff: PChar;
3244	–	SetCursor: Boolean;
4302		bInserting: Boolean;
4303		begin
4304	<	SetCursor := (GetCurrentThreadID = MainThreadID) and (Screen.Cursor = crDefault);
3248	<	if SetCursor then
3249	<	Screen.Cursor := crHourGlass;
4304	>	FBase.SetCursor;
4305		try
4306		Buff := GetActiveBuf;
4307		CheckEditState;
#	Line 3284 \| Line 4339 \| begin
4339		if bInserting then
4340		Inc(FRecordCount);
4341		finally
4342	<	if SetCursor and (Screen.Cursor = crHourGlass) then
3288	<	Screen.Cursor := crDefault;
4342	>	FBase.RestoreCursor;
4343		end;
4344		end;
4345
#	Line 3305 \| Line 4359 \| begin
4359		result := FOpen;
4360		end;
4361
4362	+	procedure TIBCustomDataSet.Loaded;
4363	+	begin
4364	+	if assigned(FQSelect) then
4365	+	FBaseSQLSelect.assign(FQSelect.SQL);
4366	+	inherited Loaded;
4367	+	end;
4368	+
4369	+	procedure TIBCustomDataSet.Post;
4370	+	var CancelPost: boolean;
4371	+	begin
4372	+	CancelPost := false;
4373	+	if assigned(FOnValidatePost) then
4374	+	OnValidatePost(self,CancelPost);
4375	+	if CancelPost then
4376	+	Cancel
4377	+	else
4378	+	inherited Post;
4379	+	end;
4380	+
4381		function TIBCustomDataSet.Locate(const KeyFields: string; const KeyValues: Variant;
4382		Options: TLocateOptions): Boolean;
4383		var
4384	<	CurBookmark: string;
4384	>	CurBookmark: TBookmark;
4385		begin
4386		DisableControls;
4387		try
#	Line 3326 \| Line 4399 \| function TIBCustomDataSet.Lookup(const K
4399		const ResultFields: string): Variant;
4400		var
4401		fl: TList;
4402	<	CurBookmark: string;
4402	>	CurBookmark: TBookmark;
4403		begin
4404		DisableControls;
4405		fl := TList.Create;
#	Line 3379 \| Line 4452 \| end;
4452		procedure TIBCustomDataSet.InternalSetFieldData(Field: TField; Buffer: Pointer);
4453		var
4454		Buff, TmpBuff: PChar;
4455	+	MappedFieldPos: integer;
4456		begin
4457		Buff := GetActiveBuf;
4458		if Field.FieldNo < 0 then
#	Line 3395 \| Line 4469 \| begin
4469		begin
4470		{ If inserting, Adjust record position }
4471		AdjustRecordOnInsert(Buff);
4472	<	if (FMappedFieldPosition[Field.FieldNo - 1] > 0) and
4473	<	(FMappedFieldPosition[Field.FieldNo - 1] <= rdFieldCount) then
4472	>	MappedFieldPos := FMappedFieldPosition[Field.FieldNo - 1];
4473	>	if (MappedFieldPos > 0) and
4474	>	(MappedFieldPos <= rdFieldCount) then
4475	>	with rdFields[MappedFieldPos], FFieldColumns^[MappedFieldPos] do
4476		begin
4477		Field.Validate(Buffer);
4478		if (Buffer = nil) or
4479		(Field is TIBStringField) and (PChar(Buffer)[0] = #0) then
4480	<	rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdIsNull := True
4481	<	else begin
4482	<	Move(Buffer^, Buff[rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdDataOfs],
4483	<	rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdDataSize);
4484	<	if (rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdDataType = SQL_TEXT) or
4485	<	(rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdDataType = SQL_VARYING) then
4486	<	rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdDataLength := StrLen(PChar(Buffer));
3411	<	rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdIsNull := False;
4480	>	fdIsNull := True
4481	>	else
4482	>	begin
4483	>	Move(Buffer^, Buff[fdDataOfs],fdDataSize);
4484	>	if (fdDataType = SQL_TEXT) or (fdDataType = SQL_VARYING) then
4485	>	fdDataLength := StrLen(PChar(Buffer));
4486	>	fdIsNull := False;
4487		if rdUpdateStatus = usUnmodified then
4488		begin
4489		if CachedUpdates then
#	Line 3432 \| Line 4507 \| begin
4507		end;
4508		end;
4509		if not (State in [dsCalcFields, dsFilter, dsNewValue]) then
4510	<	DataEvent(deFieldChange, Longint(Field));
4510	>	DataEvent(deFieldChange, PtrInt(Field));
4511		end;
4512
4513		procedure TIBCustomDataSet.SetRecNo(Value: Integer);
#	Line 3496 \| Line 4571 \| begin
4571		FillChar(Buffer[FRecordSize], CalcFieldsSize, 0);
4572		end;
4573
4574	+	procedure TIBCustomDataSet.ClearIBLinks;
4575	+	var i: integer;
4576	+	begin
4577	+	for i := FIBLinks.Count - 1 downto 0 do
4578	+	TIBControlLink(FIBLinks[i]).IBDataSet := nil;
4579	+	end;
4580	+
4581
4582		procedure TIBCustomDataSet.InternalUnPrepare;
4583		begin
4584		if FInternalPrepared then
4585		begin
4586		CheckDatasetClosed;
4587	+	if FDidActivate then
4588	+	DeactivateTransaction;
4589		FieldDefs.Clear;
4590	+	FieldDefs.Updated := false;
4591		FInternalPrepared := False;
4592	+	Setlength(FAliasNameList,0);
4593		end;
4594		end;
4595
4596		procedure TIBCustomDataSet.InternalExecQuery;
4597		var
4598		DidActivate: Boolean;
3513	–	SetCursor: Boolean;
4599		begin
4600		DidActivate := False;
4601	<	SetCursor := (GetCurrentThreadID = MainThreadID) and (Screen.Cursor = crDefault);
3517	<	if SetCursor then
3518	<	Screen.Cursor := crHourGlass;
4601	>	FBase.SetCursor;
4602		try
4603		ActivateConnection;
4604		DidActivate := ActivateTransaction;
#	Line 3523 \| Line 4606 \| begin
4606		IBError(ibxeEmptyQuery, [nil]);
4607		if not FInternalPrepared then
4608		InternalPrepare;
4609	<	if FQSelect.SQLType = SQLSelect then
4609	>	if FQSelect.SQLStatementType = SQLSelect then
4610		begin
4611		IBError(ibxeIsASelectStatement, [nil]);
4612		end
#	Line 3532 \| Line 4615 \| begin
4615		finally
4616		if DidActivate then
4617		DeactivateTransaction;
4618	<	if SetCursor and (Screen.Cursor = crHourGlass) then
4619	<	Screen.Cursor := crDefault;
4618	>	FBase.RestoreCursor;
4619	>	end;
4620	>	end;
4621	>
4622	>	function TIBCustomDataSet.GetSelectStmtIntf: IStatement;
4623	>	begin
4624	>	Result := FQSelect.Statement;
4625	>	end;
4626	>
4627	>	function TIBCustomDataSet.GetParser: TSelectSQLParser;
4628	>	begin
4629	>	if not assigned(FParser) then
4630	>	FParser := CreateParser;
4631	>	Result := FParser
4632	>	end;
4633	>
4634	>	procedure TIBCustomDataSet.ResetParser;
4635	>	begin
4636	>	if assigned(FParser) then
4637	>	begin
4638	>	FParser.Free;
4639	>	FParser := nil;
4640	>	FQSelect.OnSQLChanged := nil; {Do not react to change}
4641	>	try
4642	>	FQSelect.SQL.Assign(FBaseSQLSelect);
4643	>	finally
4644	>	FQSelect.OnSQLChanged := SQLChanged;
4645	>	end;
4646		end;
4647		end;
4648
4649	<	function TIBCustomDataSet.GetSelectStmtHandle: TISC_STMT_HANDLE;
4649	>	function TIBCustomDataSet.HasParser: boolean;
4650		begin
4651	<	Result := FQSelect.Handle;
4651	>	Result := not (csDesigning in ComponentState) and (FParser <> nil)
4652	>	end;
4653	>
4654	>	procedure TIBCustomDataSet.SetGenerateParamNames(AValue: Boolean);
4655	>	begin
4656	>	if FGenerateParamNames = AValue then Exit;
4657	>	FGenerateParamNames := AValue;
4658	>	Disconnect
4659		end;
4660
4661		procedure TIBCustomDataSet.InitRecord(Buffer: PChar);
#	Line 3560 \| Line 4676 \| end;
4676
4677		{ TIBDataSet IProviderSupport }
4678
4679	<	(*procedure TIBCustomDataSet.PSEndTransaction(Commit: Boolean);
4679	>	procedure TIBCustomDataSet.PSEndTransaction(Commit: Boolean);
4680		begin
4681		if Commit then
4682		Transaction.Commit else
#	Line 3713 \| Line 4829 \| begin
4829		Transaction.StartTransaction;
4830		end;
4831
4832	<	function TIBCustomDataSet.PSGetTableName: string;
4832	>	function TIBCustomDataSet.PsGetTableName: string;
4833		begin
4834		// if not FInternalPrepared then
4835		// InternalPrepare;
#	Line 3723 \| Line 4839 \| begin
4839		if not FQSelect.Prepared then
4840		FQSelect.Prepare;
4841		Result := FQSelect.UniqueRelationName;
4842	<	end;*)
4842	>	end;
4843
4844		procedure TIBDataSet.BatchInput(InputObject: TIBBatchInput);
4845		begin
#	Line 3788 \| Line 4904 \| end;
4904
4905		function TIBCustomDataSet.GetFieldData(Field: TField;
4906		Buffer: Pointer): Boolean;
4907	+	{$IFDEF TBCDFIELD_IS_BCD}
4908		var
4909		lTempCurr : System.Currency;
4910		begin
#	Line 3798 \| Line 4915 \| begin
4915		CurrToBCD(lTempCurr, TBCD(Buffer^), 32, Field.Size);
4916		end
4917		else
4918	+	{$ELSE}
4919	+	begin
4920	+	{$ENDIF}
4921		Result := InternalGetFieldData(Field, Buffer);
4922		end;
4923
4924		function TIBCustomDataSet.GetFieldData(Field: TField; Buffer: Pointer;
4925		NativeFormat: Boolean): Boolean;
4926		begin
4927	<	if (Field.DataType = ftBCD) and not NativeFormat then
4927	>	{These datatypes use IBX conventions and not TDataset conventions}
4928	>	if (Field.DataType in [ftBCD,ftDateTime,ftDate,ftTime]) and not NativeFormat then
4929		Result := InternalGetFieldData(Field, Buffer)
4930		else
4931		Result := inherited GetFieldData(Field, Buffer, NativeFormat);
4932		end;
4933
4934		procedure TIBCustomDataSet.SetFieldData(Field: TField; Buffer: Pointer);
4935	+	{$IFDEF TDBDFIELD_IS_BCD}
4936		var
4937		lTempCurr : System.Currency;
4938		begin
#	Line 3820 \| Line 4942 \| begin
4942		InternalSetFieldData(Field, @lTempCurr);
4943		end
4944		else
4945	+	{$ELSE}
4946	+	begin
4947	+	{$ENDIF}
4948		InternalSetFieldData(Field, Buffer);
4949		end;
4950
4951		procedure TIBCustomDataSet.SetFieldData(Field: TField; Buffer: Pointer;
4952		NativeFormat: Boolean);
4953		begin
4954	<	if (not NativeFormat) and (Field.DataType = ftBCD) then
4954	>	{These datatypes use IBX conventions and not TDataset conventions}
4955	>	if (not NativeFormat) and (Field.DataType in [ftBCD,ftDateTime,ftDate,ftTime]) then
4956		InternalSetfieldData(Field, Buffer)
4957		else
4958		inherited SetFieldData(Field, buffer, NativeFormat);
#	Line 3846 \| Line 4972 \| begin
4972		inherited Destroy;
4973		end;
4974
4975	<	procedure TIBDataSetUpdateObject.SetRefreshSQL(Value: TStrings);
4975	>	procedure TIBDataSetUpdateObject.SetRefreshSQL(value: TStrings);
4976		begin
4977		FRefreshSQL.Assign(Value);
4978		end;
4979
4980	+	procedure TIBDataSetUpdateObject.InternalSetParams(Params: ISQLParams;
4981	+	buff: PChar);
4982	+	begin
4983	+	if not Assigned(DataSet) then Exit;
4984	+	DataSet.SetInternalSQLParams(Params, buff);
4985	+	end;
4986	+
4987	+	procedure TIBDataSetUpdateObject.InternalSetParams(Query: TIBSQL; buff: PChar);
4988	+	begin
4989	+	InternalSetParams(Query.Params,buff);
4990	+	end;
4991	+
4992	+	procedure TIBDataSetUpdateObject.UpdateRecordFromQuery(QryResults: IResults;
4993	+	Buffer: PChar);
4994	+	begin
4995	+	if not Assigned(DataSet) then Exit;
4996	+	DataSet.UpdateRecordFromQuery(QryResults, Buffer);
4997	+	end;
4998	+
4999	+	function TIBDSBlobStream.GetSize: Int64;
5000	+	begin
5001	+	Result := FBlobStream.BlobSize;
5002	+	end;
5003	+
5004		{ TIBDSBlobStream }
5005		constructor TIBDSBlobStream.Create(AField: TField; ABlobStream: TIBBlobStream;
5006		Mode: TBlobStreamMode);
#	Line 3859 \| Line 5009 \| begin
5009		FBlobStream := ABlobStream;
5010		FBlobStream.Seek(0, soFromBeginning);
5011		if (Mode = bmWrite) then
5012	+	begin
5013		FBlobStream.Truncate;
5014	+	TIBCustomDataSet(FField.DataSet).RecordModified(True);
5015	+	TBlobField(FField).Modified := true;
5016	+	FHasWritten := true;
5017	+	end;
5018	+	end;
5019	+
5020	+	destructor TIBDSBlobStream.Destroy;
5021	+	begin
5022	+	if FHasWritten then
5023	+	TIBCustomDataSet(FField.DataSet).DataEvent(deFieldChange, PtrInt(FField));
5024	+	inherited Destroy;
5025		end;
5026
5027		function TIBDSBlobStream.Read(var Buffer; Count: Longint): Longint;
#	Line 3884 \| Line 5046 \| begin
5046		TIBCustomDataSet(FField.DataSet).RecordModified(True);
5047		TBlobField(FField).Modified := true;
5048		result := FBlobStream.Write(Buffer, Count);
5049	<	TIBCustomDataSet(FField.DataSet).DataEvent(deFieldChange, Longint(FField));
5049	>	FHasWritten := true;
5050	>	{ TIBCustomDataSet(FField.DataSet).DataEvent(deFieldChange, PtrInt(FField));
5051	>	Removed as this caused a seek to beginning of the blob stream thus corrupting
5052	>	the blob stream. Moved to the destructor i.e. called after blob written}
5053		end;
5054
5055		{ TIBGenerator }
5056
5057		procedure TIBGenerator.SetIncrement(const AValue: integer);
5058		begin
5059	+	if FIncrement = AValue then Exit;
5060		if AValue < 0 then
5061	<	raise Exception.Create('A Generator Increment cannot be negative');
5062	<	FIncrement := AValue
5061	>	IBError(ibxeNegativeGenerator,[]);
5062	>	FIncrement := AValue;
5063	>	SetQuerySQL;
5064		end;
5065
5066	<	function TIBGenerator.GetSelectSQL: string;
5066	>	procedure TIBGenerator.SetTransaction(AValue: TIBTransaction);
5067		begin
5068	<	Result := FOwner.SelectSQL.Text
5068	>	FQuery.Transaction := AValue;
5069		end;
5070
5071	<	function TIBGenerator.GetNextValue(ADatabase: TIBDatabase;
3905	<	ATransaction: TIBTransaction): integer;
5071	>	procedure TIBGenerator.SetQuerySQL;
5072		begin
5073	<	with TIBSQL.Create(nil) do
5074	<	try
5075	<	Database := ADatabase;
5076	<	Transaction := ATransaction;
5077	<	if not assigned(Database) then
5078	<	IBError(ibxeCannotSetDatabase,[]);
5079	<	if not assigned(Transaction) then
5080	<	IBError(ibxeCannotSetTransaction,[]);
5081	<	with Transaction do
5082	<	if not InTransaction then StartTransaction;
5083	<	SQL.Text := Format('Select Gen_ID(%s,%d) as ID From RDB$Database',[GeneratorName,Increment]);
5084	<	Prepare;
5073	>	FQuery.SQL.Text := Format('Select Gen_ID(%s,%d) From RDB$Database',[FGeneratorName,Increment]);
5074	>	end;
5075	>
5076	>	function TIBGenerator.GetDatabase: TIBDatabase;
5077	>	begin
5078	>	Result := FQuery.Database;
5079	>	end;
5080	>
5081	>	function TIBGenerator.GetTransaction: TIBTransaction;
5082	>	begin
5083	>	Result := FQuery.Transaction;
5084	>	end;
5085	>
5086	>	procedure TIBGenerator.SetDatabase(AValue: TIBDatabase);
5087	>	begin
5088	>	FQuery.Database := AValue;
5089	>	end;
5090	>
5091	>	procedure TIBGenerator.SetGeneratorName(AValue: string);
5092	>	begin
5093	>	if FGeneratorName = AValue then Exit;
5094	>	FGeneratorName := AValue;
5095	>	SetQuerySQL;
5096	>	end;
5097	>
5098	>	function TIBGenerator.GetNextValue: integer;
5099	>	begin
5100	>	with FQuery do
5101	>	begin
5102	>	Transaction.Active := true;
5103		ExecQuery;
5104		try
5105	<	Result := FieldByName('ID').AsInteger
5105	>	Result := Fields[0].AsInteger
5106		finally
5107		Close
5108		end;
3925	–	finally
3926	–	Free
5109		end;
5110		end;
5111
#	Line 3931 \| Line 5113 \| constructor TIBGenerator.Create(Owner: T
5113		begin
5114		FOwner := Owner;
5115		FIncrement := 1;
5116	+	FQuery := TIBSQL.Create(nil);
5117	+	end;
5118	+
5119	+	destructor TIBGenerator.Destroy;
5120	+	begin
5121	+	if assigned(FQuery) then FQuery.Free;
5122	+	inherited Destroy;
5123		end;
5124
5125
5126		procedure TIBGenerator.Apply;
5127		begin
5128	<	if (GeneratorName <> '') and (FieldName <> '') then
5129	<	Owner.FieldByName(FieldName).AsInteger := GetNextValue(Owner.Database,Owner.Transaction);
5128	>	if assigned(Database) and assigned(Transaction) and
5129	>	(FGeneratorName <> '') and (FFieldName <> '') and Owner.FieldByName(FFieldName).IsNull then
5130	>	Owner.FieldByName(FFieldName).AsInteger := GetNextValue;
5131		end;
5132
5133	+
5134		end.

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing ibx/trunk/runtime/IBCustomDataSet.pas (file contents): Revision 5 by tony, Fri Feb 18 16:26:16 2011 UTC vs. Revision 106 by tony, Thu Jan 18 14:37:35 2018 UTC

Diff Legend

Comparing ibx/trunk/runtime/IBCustomDataSet.pas (file contents):
Revision 5 by tony, Fri Feb 18 16:26:16 2011 UTC vs.
Revision 106 by tony, Thu Jan 18 14:37:35 2018 UTC