ViewVC Help

View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing

root/public/ibx/trunk/runtime/IBCustomDataSet.pas

Comparing ibx/trunk/runtime/IBCustomDataSet.pas (file contents):
Revision 41 by tony, Sat Jul 16 12:25:48 2016 UTC vs.
Revision 104 by tony, Thu Jan 18 14:37:29 2018 UTC

#	Line 33 | Line 33
33
34		unit IBCustomDataSet;
35
36	–	{$IF FPC_FULLVERSION >= 20700 }
37	–	{$codepage UTF8}
38	–	{$DEFINE HAS_ANSISTRING_CODEPAGE}
39	–	{$DEFINE NEW_TBOOKMARK}
40	–	{$ENDIF}
41	–
36		{$R-}
37
38	+	{$IFDEF FPC}
39		{$Mode Delphi}
40	+	{$codepage UTF8}
41	+	{$ENDIF}
42
43		{$IFDEF DELPHI}
44		{$DEFINE TDBDFIELD_IS_BCD}
#	Line 55 | Line 52 | uses
52		{$ELSE}
53		unix,
54		{$ENDIF}
55	<	SysUtils, Classes, IBDatabase, IBExternals, IB, IBHeader,  IBSQL, Db,
56	<	IBUtils, IBBlob, IBSQLParser;
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 77 | Line 74 | type
74		procedure SetDataSet(ADataSet: TIBCustomDataSet); virtual; abstract;
75		procedure Apply(UpdateKind: TUpdateKind; buff: PChar); virtual; abstract;
76		function GetSQL(UpdateKind: TUpdateKind): TStrings; virtual; abstract;
77	<	procedure InternalSetParams(Query: TIBSQL; buff: PChar);
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 88 | 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 110 | 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;
#	Line 122 | 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	<	function GetDefaultWidth: Longint; override;
188	>	procedure Bind(Binding: Boolean); override;
189	>	function GetDataSize: Integer; override;
190		public
191		constructor Create(aOwner: TComponent); override;
192		class procedure CheckTypeSize(Value: Integer); override;
#	Line 139 | Line 196 | type
196		procedure SetAsString(const Value: string); override;
197		property CharacterSetName: RawByteString read FCharacterSetName write FCharacterSetName;
198		property CharacterSetSize: integer read FCharacterSetSize write FCharacterSetSize;
199	<	{$IFDEF HAS_ANSISTRING_CODEPAGE}
200	<	private
201	<	FCodePage: TSystemCodePage;
145	<	public
146	<	property CodePage: TSystemCodePage read FCodePage write FCodePage;
147	<	{$ENDIF}
148	<	end;
149	<
150	<	{ TIBWideStringField }
151	<
152	<	TIBWideStringField = class(TWideStringField)
153	<	private
154	<	FCharacterSetName: RawByteString;
155	<	FCharacterSetSize: integer;
156	<	public
157	<	property CharacterSetName: RawByteString read FCharacterSetName write FCharacterSetName;
158	<	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 166 | 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 174 | 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}
#	Line 189 | Line 272 | type
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;
#	Line 200 | Line 284 | type
284		published
285		property DisplayTextAsClassName: boolean read FDisplayTextAsClassName
286		write FDisplayTextAsClassName;
203	–	{$IFDEF HAS_ANSISTRING_CODEPAGE}
287		private
288		FCodePage: TSystemCodePage;
289		FFCodePage: TSystemCodePage;
290		public
291		property CodePage: TSystemCodePage read FFCodePage write FFCodePage;
209	–	{$ENDIF}
210	–	end;
211	–
212	–	{ TIBWideMemoField }
213	–
214	–	TIBWideMemoField = class(TWideMemoField)
215	–	private
216	–	FCharacterSetName: RawByteString;
217	–	FCharacterSetSize: integer;
218	–	FDisplayTextAsClassName: boolean;
219	–	function GetTruncatedText: string;
220	–	protected
221	–	function GetDefaultWidth: Longint; override;
222	–	procedure GetText(var AText: string; ADisplayText: Boolean); override;
223	–	public
224	–	constructor Create(AOwner: TComponent); override;
225	–	property CharacterSetName: RawByteString read FCharacterSetName write FCharacterSetName;
226	–	property CharacterSetSize: integer read FCharacterSetSize write FCharacterSetSize;
227	–	published
228	–	property DisplayTextAsClassName: boolean read FDisplayTextAsClassName
229	–	write FDisplayTextAsClassName;
292		end;
293
294		TIBDataLink = class(TDetailDataLink)
#	Line 253 | Line 315 | type
315		FFieldName: string;
316		FGeneratorName: string;
317		FIncrement: integer;
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 Database: TIBDatabase read GetDatabase write SetDatabase;
334	+	property Transaction: TIBTransaction read GetTransaction write SetTransaction;
335		published
336	<	property Generator: string read FGeneratorName write FGeneratorName;
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;
#	Line 284 | Line 356 | type
356		TIBAutoCommit = (acDisabled, acCommitRetaining);
357
358		{ TIBCustomDataSet }
359	+
360		TIBUpdateAction = (uaFail, uaAbort, uaSkip, uaRetry, uaApply, uaApplied);
361
362		TIBUpdateErrorEvent = procedure(DataSet: TDataSet; E: EDatabaseError;
#	Line 300 | Line 373 | type
373
374		TIBCustomDataSet = class(TDataset)
375		private
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;
309	–	FIBLoaded: Boolean;
385		FBase: TIBBase;
386		FBlobCacheOffset: Integer;
387		FBlobStreamList: TList;
388	+	FArrayList: TList;
389		FBufferChunks: Integer;
390		FBufferCache,
391		FOldBufferCache: PChar;
#	Line 335 | Line 411 | type
411		FQRefresh,
412		FQSelect,
413		FQModify: TIBSQL;
414	+	FDatabaseInfo: TIBDatabaseInfo;
415		FRecordBufferSize: Integer;
416		FRecordCount: Integer;
417		FRecordSize: Integer;
#	Line 363 | Line 440 | type
440		FCloseAction: TTransactionAction;
441		FInTransactionEnd: boolean;
442		FIBLinks: TList;
443	<	function GetSelectStmtHandle: TISC_STMT_HANDLE;
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 375 | 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);
#	Line 386 | Line 468 | type
468		procedure FetchCurrentRecordToBuffer(Qry: TIBSQL; RecordNumber: Integer;
469		Buffer: PChar);
470		function GetDatabase: TIBDatabase;
389	–	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;
398	–	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;
#	Line 410 | Line 490 | type
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;
502		function AdjustPosition(FCache: PChar; Offset: DWORD;
503		Origin: Integer): DWORD;
#	Line 450 | Line 531 | type
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 463 | 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 527 | Line 608 | type
608		protected
609		{Likely to be made public by descendant classes}
610		property AutoCommit: TIBAutoCommit read FAutoCommit write FAutoCommit default acDisabled;
611	<	property SQLParams: TIBXSQLDA read GetSQLParams;
612	<	property Params: TIBXSQLDA read GetSQLParams;
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;
#	Line 587 | Line 668 | type
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;*)
#	Line 600 | Line 683 | type
683		function UpdateStatus: TUpdateStatus; override;
684		function IsSequenced: Boolean; override;
685		procedure Post; override;
686	<	function ParamByName(ParamName: String): TIBXSQLVAR;
687	<	property DBHandle: PISC_DB_HANDLE read GetDBHandle;
605	<	property TRHandle: PISC_TR_HANDLE read GetTRHandle;
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
#	Line 611 | Line 693 | type
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 751 | Line 835 | type
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 777 | Line 886 | DefaultFieldClasses: array[TFieldType] o
886		TBlobField,         { ftTypedBinary }
887		nil,                { ftCursor }
888		TStringField,       { ftFixedChar }
889	<	TIBWideStringField,    { 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 792 | Line 901 | DefaultFieldClasses: array[TFieldType] o
901		TDateTimeField,    {ftTimestamp}
902		TIBBCDField,       {ftFMTBcd}
903		nil,  {ftFixedWideChar}
904	<	TIBWideMemoField);   {ftWideMemo}
904	>	nil);   {ftWideMemo}
905		(*
906		TADTField,          { ftADT }
907		TArrayField,        { ftArray }
#	Line 809 | Line 918 | DefaultFieldClasses: array[TFieldType] o
918
919		implementation
920
921	<	uses IBIntf, Variants, FmtBCD, LazUTF8;
921	>	uses Variants, FmtBCD, LazUTF8, FBMessages, IBQuery;
922
923		const FILE_BEGIN = 0;
924		FILE_CURRENT = 1;
#	Line 822 | 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 832 | Line 942 | type
942		NextRelation : TRelationNode;
943		end;
944
835	–	{Extended Field Def for character set info}
836	–
837	–	{ TIBFieldDef }
838	–
839	–	TIBFieldDef = class(TFieldDef)
840	–	private
841	–	FCharacterSetName: RawByteString;
842	–	FCharacterSetSize: integer;
843	–	{$IFDEF HAS_ANSISTRING_CODEPAGE}
844	–	FCodePage: TSystemCodePage;
845	–	{$ENDIF}
846	–	published
847	–	property CharacterSetName: RawByteString read FCharacterSetName write FCharacterSetName;
848	–	property CharacterSetSize: integer read FCharacterSetSize write FCharacterSetSize;
849	–	{$IFDEF HAS_ANSISTRING_CODEPAGE}
850	–	property CodePage: TSystemCodePage read FCodePage write FCodePage;
851	–	{$ENDIF}
852	–	end;
853	–
945
946		{  Copied from LCLProc in order to avoid LCL dependency
947
#	Line 893 | Line 984 | type
984		Result := str;
985		end;
986
987	<	{ TIBWideMemoField }
987	>	{ TIBLargeIntField }
988
989	<	function TIBWideMemoField.GetTruncatedText: string;
989	>	procedure TIBLargeIntField.Bind(Binding: Boolean);
990		begin
991	<	Result := GetAsString;
991	>	inherited Bind(Binding);
992	>	if Binding and (FieldDef <> nil) then
993	>	FIdentityColumn := (FieldDef as TIBFieldDef).IdentityColumn;
994	>	end;
995
996	<	if Result <> '' then
997	<	if DisplayWidth = 0 then
998	<	Result := TextToSingleLine(Result)
999	<	else
1000	<	if Length(Result) > DisplayWidth then {Show truncation with elipses}
1001	<	Result := TextToSingleLine(system.copy(Result,1,DisplayWidth-3)) + '...';
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	<	function TIBWideMemoField.GetDefaultWidth: Longint;
1005	>	{ TIBSmallintField }
1006	>
1007	>	procedure TIBSmallintField.Bind(Binding: Boolean);
1008		begin
1009	<	Result := 128;
1009	>	inherited Bind(Binding);
1010	>	if Binding and (FieldDef <> nil) then
1011	>	FIdentityColumn := (FieldDef as TIBFieldDef).IdentityColumn;
1012		end;
1013
1014	<	procedure TIBWideMemoField.GetText(var AText: string; ADisplayText: Boolean);
1014	>	{ TIBArray }
1015	>
1016	>	procedure TIBArray.EventHandler(Sender: IArray; Reason: TArrayEventReason);
1017		begin
1018	<	if ADisplayText then
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	<	if not DisplayTextAsClassName and (CharacterSetName<> '') then
1082	<	AText := GetTruncatedText
1083	<	else
1084	<	inherited GetText(AText, ADisplayText);
1085	<	end
1086	<	else
1087	<	AText := GetAsString;
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 TIBWideMemoField.Create(AOwner: TComponent);
1092	>	constructor TIBArrayField.Create(AOwner: TComponent);
1093		begin
1094		inherited Create(AOwner);
1095	<	BlobType := ftWideMemo;
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 }
#	Line 950 | Line 1120 | begin
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 routine work for this codeset}
1123	>	4: {Include GB18030 - assuming UTF8 routines work for this codeset}
1124		if DisplayWidth = 0 then
1125		Result := ValidUTF8String(TextToSingleLine(Result))
1126		else
#	Line 960 | Line 1130 | begin
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;
967	–	{$IFDEF HAS_ANSISTRING_CODEPAGE}
1150		SetCodePage(s,CodePage,false);
1151	<	{$ENDIF}
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
#	Line 995 | Line 1178 | procedure TIBMemoField.SetAsString(const
1178		var s: RawByteString;
1179		begin
1180		s := AValue;
1181	<	{$IFDEF HAS_ANSISTRING_CODEPAGE}
1182	<	if StringCodePage(Value) <> CodePage then
1000	<	SetCodePage(s,CodePage,true);
1001	<	{$ENDIF}
1181	>	if StringCodePage(s) <> CodePage then
1182	>	SetCodePage(s,CodePage,CodePage<>CP_NONE);
1183		inherited SetAsString(s);
1184		end;
1185
#	Line 1006 | Line 1187 | constructor TIBMemoField.Create(AOwner:
1187		begin
1188		inherited Create(AOwner);
1189		BlobType := ftMemo;
1009	–	{$IFDEF HAS_ANSISTRING_CODEPAGE}
1190		FCodePage := CP_NONE;
1011	–	{$ENDIF}
1191		end;
1192
1193		{ TIBControlLink }
#	Line 1042 | Line 1221 | end;
1221
1222		{ TIBStringField}
1223
1224	<	function TIBStringField.GetDefaultWidth: Longint;
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 := Size div CharacterSetSize;
1242	>	Result := FDataSize;
1243		end;
1244
1245		constructor TIBStringField.Create(aOwner: TComponent);
1246		begin
1247		inherited Create(aOwner);
1248		FCharacterSetSize := 1;
1054	–	{$IFDEF HAS_ANSISTRING_CODEPAGE}
1249		FCodePage := CP_NONE;
1250	<	{$ENDIF}
1250	>	FAutoFieldSize := true;
1251		end;
1252
1253		class procedure TIBStringField.CheckTypeSize(Value: Integer);
#	Line 1079 | Line 1273 | var
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	<	{$IFDEF HAS_ANSISTRING_CODEPAGE}
1088	<	s := 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);
1092	–	{$ELSE}
1093	–	Value := string(Buffer);
1094	–	{$ENDIF}
1287		if Transliterate and (Value <> '') then
1288		DataSet.Translate(PChar(Value), PChar(Value), False);
1289		end
#	Line 1106 | Line 1298 | var
1298		s: RawByteString;
1299		begin
1300		Buffer := nil;
1301	<	IBAlloc(Buffer, 0, Size + 1);
1301	>	IBAlloc(Buffer, 0, DataSize);
1302		try
1303		s := Value;
1112	–	{$IFDEF HAS_ANSISTRING_CODEPAGE}
1304		if StringCodePage(s) <> CodePage then
1305	<	SetCodePage(s,CodePage,true);
1306	<	{$ENDIF}
1116	<	StrLCopy(Buffer, PChar(s), Size);
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 1132 | 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 1216 | Line 1413 | end;
1413		constructor TIBCustomDataSet.Create(AOwner: TComponent);
1414		begin
1415		inherited Create(AOwner);
1219	–	FIBLoaded := False;
1220	–	CheckIBLoaded;
1221	–	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	+	FArrayList := TList.Create;
1425		FGeneratorField := TIBGenerator.Create(self);
1426		FDataLink := TIBDataLink.Create(Self);
1427		FQDelete := TIBSQL.Create(Self);
#	Line 1269 | Line 1465 | end;
1465		destructor TIBCustomDataSet.Destroy;
1466		begin
1467		if Active then Active := false;
1468	<	if FIBLoaded then
1469	<	begin
1470	<	if assigned(FGeneratorField) then FGeneratorField.Free;
1471	<	FDataLink.Free;
1472	<	FBase.Free;
1473	<	ClearBlobCache;
1474	<	ClearIBLinks;
1475	<	FIBLinks.Free;
1476	<	FBlobStreamList.Free;
1477	<	FreeMem(FBufferCache);
1478	<	FBufferCache := nil;
1479	<	FreeMem(FOldBufferCache);
1480	<	FOldBufferCache := nil;
1481	<	FCacheSize := 0;
1482	<	FOldCacheSize := 0;
1287	<	FMappedFieldPosition := nil;
1288	<	end;
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;
#	Line 1310 | 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 1329 | Line 1523 | end;
1523
1524		procedure TIBCustomDataSet.ApplyUpdates;
1525		var
1332	–	{$IFDEF NEW_TBOOKMARK }
1526		CurBookmark: TBookmark;
1334	–	{$ELSE}
1335	–	CurBookmark: string;
1336	–	{$ENDIF}
1527		Buffer: PRecordData;
1528		CurUpdateTypes: TIBUpdateRecordTypes;
1529		UpdateAction: TIBUpdateAction;
#	Line 1564 | Line 1754 | end;
1754		function TIBCustomDataSet.ActivateTransaction: Boolean;
1755		begin
1756		Result := False;
1757	<	if not Assigned(Transaction) then
1568	<	IBError(ibxeTransactionNotAssigned, [nil]);
1569	<	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 1695 | 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 1704 | 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 1742 | 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 1758 | 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
1766	<	p: PRecordData;
1767	<	pbd: PBlobDataArray;
1768	<	i, j: Integer;
1769	<	LocalData: Pointer;
1770	<	LocalDate, LocalDouble: Double;
1771	<	LocalInt: Integer;
1772	<	LocalBool: wordBool;
1773	<	LocalInt64: Int64;
1774	<	LocalCurrency: Currency;
1775	<	FieldsLoaded: Integer;
1776	<	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);
1779	–	{ Make sure blob cache is empty }
1780	–	pbd := PBlobDataArray(Buffer + FBlobCacheOffset);
1781	–	if RecordNumber > -1 then
1782	–	for i := 0 to BlobFieldCount - 1 do
1783	–	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, LocalDouble: Double;
2078	>	LocalInt: Integer;
2079	>	LocalBool: wordBool;
2080	>	LocalInt64: Int64;
2081	>	LocalCurrency: Currency;
2082	>	p: PRecordData;
2083	>	ColData: ISQLData;
2084	>	begin
2085	>	p := PRecordData(Buffer);
2086	>	LocalData := nil;
2087	>	with p^.rdFields[FieldIndex], FFieldColumns^[FieldIndex] do
2088	>	begin
2089	>	QryResults.GetData(ColumnIndex,fdIsNull,fdDataLength,LocalData);
2090	>	if not fdIsNull then
2091		begin
2092	<	rdFields[j].fdDataType :=
2093	<	Qry.Current[i].Data^.sqltype and (not 1);
1819	<	rdFields[j].fdDataScale :=
1820	<	Qry.Current[i].Data^.sqlscale;
1821	<	rdFields[j].fdNullable :=
1822	<	(Qry.Current[i].Data^.sqltype and 1 = 1);
1823	<	rdFields[j].fdIsNull :=
1824	<	(rdFields[j].fdNullable and (Qry.Current[i].Data^.sqlind^ = -1));
1825	<	LocalData := Qry.Current[i].Data^.sqldata;
1826	<	case rdFields[j].fdDataType of
2092	>	ColData := QryResults[ColumnIndex];
2093	>	case fdDataType of  {Get Formatted data for column types that need formatting}
2094		SQL_TIMESTAMP:
2095		begin
2096	<	rdFields[j].fdDataSize := SizeOf(TDateTime);
2097	<	if RecordNumber >= 0 then
1831	<	LocalDate := TimeStampToMSecs(DateTimeToTimeStamp(Qry.Current[i].AsDateTime));
1832	<	LocalData := PChar(@LocalDate);
2096	>	LocalDate := TimeStampToMSecs(DateTimeToTimeStamp(ColData.AsDateTime));
2097	>	LocalData := PByte(@LocalDate);
2098		end;
2099		SQL_TYPE_DATE:
2100		begin
2101	<	rdFields[j].fdDataSize := SizeOf(TDateTime);
2102	<	if RecordNumber >= 0 then
1838	<	LocalInt := DateTimeToTimeStamp(Qry.Current[i].AsDateTime).Date;
1839	<	LocalData := PChar(@LocalInt);
2101	>	LocalInt := DateTimeToTimeStamp(ColData.AsDateTime).Date;
2102	>	LocalData := PByte(@LocalInt);
2103		end;
2104		SQL_TYPE_TIME:
2105		begin
2106	<	rdFields[j].fdDataSize := SizeOf(TDateTime);
2107	<	if RecordNumber >= 0 then
1845	<	LocalInt := DateTimeToTimeStamp(Qry.Current[i].AsDateTime).Time;
1846	<	LocalData := PChar(@LocalInt);
2106	>	LocalInt := DateTimeToTimeStamp(ColData.AsDateTime).Time;
2107	>	LocalData := PByte(@LocalInt);
2108		end;
2109		SQL_SHORT, SQL_LONG:
2110		begin
2111	<	if (rdFields[j].fdDataScale = 0) then
2111	>	if (fdDataScale = 0) then
2112		begin
2113	<	rdFields[j].fdDataSize := SizeOf(Integer);
2114	<	if RecordNumber >= 0 then
1854	<	LocalInt := Qry.Current[i].AsLong;
1855	<	LocalData := PChar(@LocalInt);
2113	>	LocalInt := ColData.AsLong;
2114	>	LocalData := PByte(@LocalInt);
2115		end
2116	<	else if (rdFields[j].fdDataScale >= (-4)) then
2117	<	begin
2118	<	rdFields[j].fdDataSize := SizeOf(Currency);
2119	<	if RecordNumber >= 0 then
2120	<	LocalCurrency := Qry.Current[i].AsCurrency;
2121	<	LocalData := PChar(@LocalCurrency);
2122	<	end
2123	<	else begin
2124	<	rdFields[j].fdDataSize := SizeOf(Double);
2125	<	if RecordNumber >= 0 then
2126	<	LocalDouble := Qry.Current[i].AsDouble;
1868	<	LocalData := PChar(@LocalDouble);
1869	<	end;
2116	>	else
2117	>	if (fdDataScale >= (-4)) then
2118	>	begin
2119	>	LocalCurrency := ColData.AsCurrency;
2120	>	LocalData := PByte(@LocalCurrency);
2121	>	end
2122	>	else
2123	>	begin
2124	>	LocalDouble := ColData.AsDouble;
2125	>	LocalData := PByte(@LocalDouble);
2126	>	end;
2127		end;
2128		SQL_INT64:
2129		begin
2130	<	if (rdFields[j].fdDataScale = 0) then
2130	>	if (fdDataScale = 0) then
2131		begin
2132	<	rdFields[j].fdDataSize := SizeOf(Int64);
2133	<	if RecordNumber >= 0 then
1877	<	LocalInt64 := Qry.Current[i].AsInt64;
1878	<	LocalData := PChar(@LocalInt64);
2132	>	LocalInt64 := ColData.AsInt64;
2133	>	LocalData := PByte(@LocalInt64);
2134		end
2135	<	else if (rdFields[j].fdDataScale >= (-4)) then
2136	<	begin
1882	<	rdFields[j].fdDataSize := SizeOf(Currency);
1883	<	if RecordNumber >= 0 then
1884	<	LocalCurrency := Qry.Current[i].AsCurrency;
1885	<	LocalData := PChar(@LocalCurrency);
1886	<	end
1887	<	else begin
1888	<	rdFields[j].fdDataSize := SizeOf(Double);
1889	<	if RecordNumber >= 0 then
1890	<	LocalDouble := Qry.Current[i].AsDouble;
1891	<	LocalData := PChar(@LocalDouble);
1892	<	end
1893	<	end;
1894	<	SQL_DOUBLE, SQL_FLOAT, SQL_D_FLOAT:
1895	<	begin
1896	<	rdFields[j].fdDataSize := SizeOf(Double);
1897	<	if RecordNumber >= 0 then
1898	<	LocalDouble := Qry.Current[i].AsDouble;
1899	<	LocalData := PChar(@LocalDouble);
1900	<	end;
1901	<	SQL_VARYING:
1902	<	begin
1903	<	rdFields[j].fdDataSize := Qry.Current[i].Data^.sqllen;
1904	<	rdFields[j].fdDataLength := isc_vax_integer(Qry.Current[i].Data^.sqldata, 2);
1905	<	if RecordNumber >= 0 then
2135	>	else
2136	>	if (fdDataScale >= (-4)) then
2137		begin
2138	<	if (rdFields[j].fdDataLength = 0) then
2139	<	LocalData := nil
2138	>	LocalCurrency := ColData.AsCurrency;
2139	>	LocalData := PByte(@LocalCurrency);
2140	>	end
2141		else
2142		begin
2143	<	temp :=  Qry.Current[i];
2144	<	LocalData := @temp.Data^.sqldata[2];
2145	<	(*              LocalData := @Qry.Current[i].Data^.sqldata[2];*)
1914	<	end;
1915	<	end;
2143	>	LocalDouble := ColData.AsDouble;
2144	>	LocalData := PByte(@LocalDouble);
2145	>	end
2146		end;
2147	<	SQL_BOOLEAN:
2147	>	SQL_DOUBLE, SQL_FLOAT, SQL_D_FLOAT:
2148		begin
2149	<	LocalBool:= false;
2150	<	rdFields[j].fdDataSize := SizeOf(wordBool);
1921	<	if RecordNumber >= 0 then
1922	<	LocalBool := Qry.Current[i].AsBoolean;
1923	<	LocalData := PChar(@LocalBool);
2149	>	LocalDouble := ColData.AsDouble;
2150	>	LocalData := PByte(@LocalDouble);
2151		end;
2152	<	else { SQL_TEXT, SQL_BLOB, SQL_ARRAY, SQL_QUAD }
2152	>	SQL_BOOLEAN:
2153		begin
2154	<	rdFields[j].fdDataSize := Qry.Current[i].Data^.sqllen;
2155	<	if (rdFields[j].fdDataType = SQL_TEXT) then
1929	<	rdFields[j].fdDataLength := rdFields[j].fdDataSize;
2154	>	LocalBool := ColData.AsBoolean;
2155	>	LocalData := PByte(@LocalBool);
2156		end;
2157		end;
2158	<	if RecordNumber < 0 then
2158	>
2159	>	if fdDataType = SQL_VARYING then
2160	>	Move(LocalData^, Buffer[fdDataOfs], fdDataLength)
2161	>	else
2162	>	Move(LocalData^, Buffer[fdDataOfs], fdDataSize)
2163	>	end
2164	>	else {Null column}
2165	>	if fdDataType = SQL_VARYING then
2166	>	FillChar(Buffer[fdDataOfs],fdDataLength,0)
2167	>	else
2168	>	FillChar(Buffer[fdDataOfs],fdDataSize,0);
2169	>	end;
2170	>	end;
2171	>
2172	>	{ Read the record from FQSelect.Current into the record buffer
2173	>	Then write the buffer to in memory cache }
2174	>	procedure TIBCustomDataSet.FetchCurrentRecordToBuffer(Qry: TIBSQL;
2175	>	RecordNumber: Integer; Buffer: PChar);
2176	>	var
2177	>	pbd: PBlobDataArray;
2178	>	pda: PArrayDataArray;
2179	>	i, j: Integer;
2180	>	FieldsLoaded: Integer;
2181	>	p: PRecordData;
2182	>	begin
2183	>	if RecordNumber = -1 then
2184	>	begin
2185	>	InitModelBuffer(Qry,Buffer);
2186	>	Exit;
2187	>	end;
2188	>	p := PRecordData(Buffer);
2189	>	{ Make sure blob cache is empty }
2190	>	pbd := PBlobDataArray(Buffer + FBlobCacheOffset);
2191	>	pda := PArrayDataArray(Buffer + FArrayCacheOffset);
2192	>	for i := 0 to BlobFieldCount - 1 do
2193	>	pbd^[i] := nil;
2194	>	for i := 0 to ArrayFieldCount - 1 do
2195	>	pda^[i] := nil;
2196	>
2197	>	{ Get record information }
2198	>	p^.rdBookmarkFlag := bfCurrent;
2199	>	p^.rdFieldCount := Qry.FieldCount;
2200	>	p^.rdRecordNumber := RecordNumber;
2201	>	p^.rdUpdateStatus := usUnmodified;
2202	>	p^.rdCachedUpdateStatus := cusUnmodified;
2203	>	p^.rdSavedOffset := $FFFFFFFF;
2204	>
2205	>	{ Load up the fields }
2206	>	FieldsLoaded := FQSelect.MetaData.Count;
2207	>	j := 1;
2208	>	for i := 0 to Qry.FieldCount - 1 do
2209	>	begin
2210	>	if (Qry = FQSelect) then
2211	>	j := i + 1
2212	>	else
2213	>	begin
2214	>	if FieldsLoaded = 0 then
2215	>	break;
2216	>	j := FQSelect.FieldIndex[Qry[i].Name] + 1;
2217	>	if j < 1 then
2218	>	continue
2219	>	else
2220	>	Dec(FieldsLoaded);
2221	>	end;
2222	>	with FQSelect.MetaData[j - 1] do
2223	>	if GetAliasname = 'IBX_INTERNAL_DBKEY' then {do not localize}
2224		begin
2225	<	rdFields[j].fdIsNull := True;
2226	<	rdFields[j].fdDataOfs := FRecordSize;
2227	<	Inc(FRecordSize, rdFields[j].fdDataSize);
1937	<	end
1938	<	else begin
1939	<	if rdFields[j].fdDataType = SQL_VARYING then
1940	<	begin
1941	<	if LocalData <> nil then
1942	<	Move(LocalData^, Buffer[rdFields[j].fdDataOfs], rdFields[j].fdDataLength)
1943	<	end
1944	<	else
1945	<	Move(LocalData^, Buffer[rdFields[j].fdDataOfs], rdFields[j].fdDataSize)
2225	>	if (GetSize <= 8) then
2226	>	p^.rdDBKey := PIBDBKEY(Qry[i].AsPointer)^;
2227	>	continue;
2228		end;
2229	<	end;
2229	>	if j > 0 then
2230	>	ColumnDataToBuffer(Qry.Current,i,j,Buffer);
2231		end;
2232	<	WriteRecordCache(RecordNumber, PChar(p));
2232	>	WriteRecordCache(RecordNumber, Buffer);
2233		end;
2234
2235		function TIBCustomDataSet.GetActiveBuf: PChar;
#	Line 1991 | Line 2274 | begin
2274		result := FBase.Database;
2275		end;
2276
1994	–	function TIBCustomDataSet.GetDBHandle: PISC_DB_HANDLE;
1995	–	begin
1996	–	result := FBase.DBHandle;
1997	–	end;
1998	–
2277		function TIBCustomDataSet.GetDeleteSQL: TStrings;
2278		begin
2279		result := FQDelete.SQL;
#	Line 2006 | Line 2284 | begin
2284		result := FQInsert.SQL;
2285		end;
2286
2287	<	function TIBCustomDataSet.GetSQLParams: TIBXSQLDA;
2287	>	function TIBCustomDataSet.GetSQLParams: ISQLParams;
2288		begin
2289		if not FInternalPrepared then
2290		InternalPrepare;
#	Line 2023 | Line 2301 | begin
2301		result := FQSelect.SQL;
2302		end;
2303
2304	<	function TIBCustomDataSet.GetStatementType: TIBSQLTypes;
2304	>	function TIBCustomDataSet.GetStatementType: TIBSQLStatementTypes;
2305		begin
2306	<	result := FQSelect.SQLType;
2306	>	result := FQSelect.SQLStatementType;
2307		end;
2308
2309		function TIBCustomDataSet.GetModifySQL: TStrings;
#	Line 2038 | Line 2316 | begin
2316		result := FBase.Transaction;
2317		end;
2318
2041	–	function TIBCustomDataSet.GetTRHandle: PISC_TR_HANDLE;
2042	–	begin
2043	–	result := FBase.TRHandle;
2044	–	end;
2045	–
2319		procedure TIBCustomDataSet.InternalDeleteRecord(Qry: TIBSQL; Buff: Pointer);
2320		begin
2321		if (Assigned(FUpdateObject) and (FUpdateObject.GetSQL(ukDelete).Text <> '')) then
2322		FUpdateObject.Apply(ukDelete,Buff)
2323		else
2324		begin
2325	<	SetInternalSQLParams(FQDelete, Buff);
2325	>	SetInternalSQLParams(FQDelete.Params, Buff);
2326		FQDelete.ExecQuery;
2327		end;
2328		with PRecordData(Buff)^ do
#	Line 2064 | Line 2337 | function TIBCustomDataSet.InternalLocate
2337		const KeyValues: Variant; Options: TLocateOptions): Boolean;
2338		var
2339		keyFieldList: TList;
2067	–	{$IFDEF NEW_TBOOKMARK }
2340		CurBookmark: TBookmark;
2069	–	{$ELSE}
2070	–	CurBookmark: string;
2071	–	{$ENDIF}
2341		fieldValue: Variant;
2342		lookupValues: array of variant;
2343		i, fieldCount: Integer;
#	Line 2150 | Line 2419 | end;
2419
2420		procedure TIBCustomDataSet.InternalPostRecord(Qry: TIBSQL; Buff: Pointer);
2421		var
2422	<	i, j, k: Integer;
2422	>	i, j, k, arr: Integer;
2423		pbd: PBlobDataArray;
2424	+	pda: PArrayDataArray;
2425		begin
2426		pbd := PBlobDataArray(PChar(Buff) + FBlobCacheOffset);
2427	<	j := 0;
2427	>	pda := PArrayDataArray(PChar(Buff) + FArrayCacheOffset);
2428	>	j := 0; arr := 0;
2429		for i := 0 to FieldCount - 1 do
2430		if Fields[i].IsBlob then
2431		begin
#	Line 2163 | Line 2434 | begin
2434		begin
2435		pbd^[j].Finalize;
2436		PISC_QUAD(
2437	<	PChar(Buff) + PRecordData(Buff)^.rdFields[k].fdDataOfs)^ :=
2437	>	PChar(Buff) + FFieldColumns^[k].fdDataOfs)^ :=
2438		pbd^[j].BlobID;
2439		PRecordData(Buff)^.rdFields[k].fdIsNull := pbd^[j].Size = 0;
2440	+	end
2441	+	else
2442	+	begin
2443	+	PRecordData(Buff)^.rdFields[k].fdIsNull := true;
2444	+	with PISC_QUAD(PChar(Buff) + FFieldColumns^[k].fdDataOfs)^ do
2445	+	begin
2446	+	gds_quad_high := 0;
2447	+	gds_quad_low := 0;
2448	+	end;
2449		end;
2450		Inc(j);
2451	+	end
2452	+	else
2453	+	if Fields[i] is TIBArrayField then
2454	+	begin
2455	+	if pda^[arr] <> nil then
2456	+	begin
2457	+	k := FMappedFieldPosition[Fields[i].FieldNo -1];
2458	+	PISC_QUAD(
2459	+	PChar(Buff) + FFieldColumns^[k].fdDataOfs)^ :=  pda^[arr].ArrayIntf.GetArrayID;
2460	+	PRecordData(Buff)^.rdFields[k].fdIsNull := pda^[arr].ArrayIntf.IsEmpty;
2461	+	end;
2462	+	Inc(arr);
2463		end;
2464		if Assigned(FUpdateObject) then
2465		begin
#	Line 2179 | Line 2471 | begin
2471		FUpdateObject.Apply(ukModify,Buff);
2472		end
2473		else begin
2474	<	SetInternalSQLParams(Qry, Buff);
2474	>	SetInternalSQLParams(Qry.Params, Buff);
2475		Qry.ExecQuery;
2476		end;
2477	+	if Qry.FieldCount > 0 then {Has RETURNING Clause}
2478	+	UpdateRecordFromQuery(Qry.Current,Buff);
2479		PRecordData(Buff)^.rdUpdateStatus := usUnmodified;
2480		PRecordData(Buff)^.rdCachedUpdateStatus := cusUnmodified;
2481		SetModified(False);
#	Line 2213 | Line 2507 | begin
2507		end
2508		else
2509		Qry := FQRefresh;
2510	<	SetInternalSQLParams(Qry, Buff);
2510	>	SetInternalSQLParams(Qry.Params, Buff);
2511		Qry.ExecQuery;
2512		try
2513	<	if (Qry.SQLType = SQLExecProcedure) or
2220	<	(Qry.Next <> nil) then
2513	>	if (Qry.SQLStatementType = SQLExecProcedure) or Qry.Next then
2514		begin
2515		ofs := PRecordData(Buff)^.rdSavedOffset;
2516		FetchCurrentRecordToBuffer(Qry,
#	Line 2310 | Line 2603 | begin
2603		end;
2604
2605		procedure TIBCustomDataSet.InternalPrepare;
2313	–	var
2314	–	DidActivate: Boolean;
2606		begin
2607		if FInternalPrepared then
2608		Exit;
2318	–	DidActivate := False;
2609		FBase.SetCursor;
2610		try
2611		ActivateConnection;
2612	<	DidActivate := ActivateTransaction;
2612	>	ActivateTransaction;
2613		FBase.CheckDatabase;
2614		FBase.CheckTransaction;
2615		if HasParser and (FParser.SQLText <> FQSelect.SQL.Text) then
#	Line 2357 | Line 2647 | begin
2647		end else
2648		IBError(ibxeEmptyQuery, [nil]);
2649		finally
2360	–	if DidActivate then
2361	–	DeactivateTransaction;
2650		FBase.RestoreCursor;
2651		end;
2652		end;
#	Line 2388 | Line 2676 | var
2676		begin
2677		CopyRecordBuffer(Buffer, OldBuffer);
2678		if BlobFieldCount > 0 then
2679	<	FillChar(PChar(OldBuffer)[FBlobCacheOffset], BlobFieldCount * SizeOf(TIBBlobStream),
2679	>	FillChar(PChar(OldBuffer)[FBlobCacheOffset],
2680	>	BlobFieldCount * SizeOf(TIBBlobStream) + ArrayFieldCount * SizeOf(IArray),
2681		0);
2682		end;
2683
#	Line 2430 | Line 2719 | begin
2719		if (FBase.Database <> Value) then
2720		begin
2721		CheckDatasetClosed;
2722	+	InternalUnPrepare;
2723		FBase.Database := Value;
2724		FQDelete.Database := Value;
2725		FQInsert.Database := Value;
2726		FQRefresh.Database := Value;
2727		FQSelect.Database := Value;
2728		FQModify.Database := Value;
2729	+	FDatabaseInfo.Database := Value;
2730	+	FGeneratorField.Database := Value;
2731		end;
2732		end;
2733
#	Line 2457 | Line 2749 | begin
2749		end;
2750		end;
2751
2752	<	procedure TIBCustomDataSet.SetInternalSQLParams(Qry: TIBSQL; Buffer: Pointer);
2752	>	procedure TIBCustomDataSet.SetInternalSQLParams(Params: ISQLParams; Buffer: Pointer);
2753		var
2754		i, j: Integer;
2755		cr, data: PChar;
2756	<	fn, st: string;
2756	>	fn: string;
2757	>	st: RawByteString;
2758		OldBuffer: Pointer;
2759		ts: TTimeStamp;
2760	+	Param: ISQLParam;
2761		begin
2762		if (Buffer = nil) then
2763		IBError(ibxeBufferNotSet, [nil]);
#	Line 2471 | Line 2765 | begin
2765		InternalPrepare;
2766		OldBuffer := nil;
2767		try
2768	<	for i := 0 to Qry.Params.Count - 1 do
2768	>	for i := 0 to Params.GetCount - 1 do
2769		begin
2770	<	fn := Qry.Params[i].Name;
2770	>	Param := Params[i];
2771	>	fn := Param.Name;
2772		if (Pos('OLD_', fn) = 1) then {mbcs ok}
2773		begin
2774		fn := Copy(fn, 5, Length(fn));
#	Line 2493 | Line 2788 | begin
2788		cr := Buffer;
2789		j := FQSelect.FieldIndex[fn] + 1;
2790		if (j > 0) then
2791	<	with PRecordData(cr)^ do
2791	>	with PRecordData(cr)^,rdFields[j], FFieldColumns^[j] do
2792		begin
2793	<	if Qry.Params[i].name = 'IBX_INTERNAL_DBKEY' then {do not localize}
2793	>	if Param.name = 'IBX_INTERNAL_DBKEY' then {do not localize}
2794		begin
2795	<	PIBDBKey(Qry.Params[i].AsPointer)^ := rdDBKey;
2795	>	PIBDBKey(Param.AsPointer)^ := rdDBKey;
2796		continue;
2797		end;
2798	<	if rdFields[j].fdIsNull then
2799	<	Qry.Params[i].IsNull := True
2798	>	if fdIsNull then
2799	>	Param.IsNull := True
2800		else begin
2801	<	Qry.Params[i].IsNull := False;
2802	<	data := cr + rdFields[j].fdDataOfs;
2803	<	case rdFields[j].fdDataType of
2801	>	Param.IsNull := False;
2802	>	data := cr + fdDataOfs;
2803	>	case fdDataType of
2804		SQL_TEXT, SQL_VARYING:
2805		begin
2806	<	SetString(st, data, rdFields[j].fdDataLength);
2807	<	Qry.Params[i].AsString := st;
2806	>	SetString(st, data, fdDataLength);
2807	>	SetCodePage(st,fdCodePage,false);
2808	>	Param.AsString := st;
2809		end;
2810		SQL_FLOAT, SQL_DOUBLE, SQL_D_FLOAT:
2811	<	Qry.Params[i].AsDouble := PDouble(data)^;
2811	>	Param.AsDouble := PDouble(data)^;
2812		SQL_SHORT, SQL_LONG:
2813		begin
2814	<	if rdFields[j].fdDataScale = 0 then
2815	<	Qry.Params[i].AsLong := PLong(data)^
2520	<	else if rdFields[j].fdDataScale >= (-4) then
2521	<	Qry.Params[i].AsCurrency := PCurrency(data)^
2814	>	if fdDataScale = 0 then
2815	>	Param.AsLong := PLong(data)^
2816		else
2817	<	Qry.Params[i].AsDouble := PDouble(data)^;
2817	>	if fdDataScale >= (-4) then
2818	>	Param.AsCurrency := PCurrency(data)^
2819	>	else
2820	>	Param.AsDouble := PDouble(data)^;
2821		end;
2822		SQL_INT64:
2823		begin
2824	<	if rdFields[j].fdDataScale = 0 then
2825	<	Qry.Params[i].AsInt64 := PInt64(data)^
2826	<	else if rdFields[j].fdDataScale >= (-4) then
2827	<	Qry.Params[i].AsCurrency := PCurrency(data)^
2824	>	if fdDataScale = 0 then
2825	>	Param.AsInt64 := PInt64(data)^
2826	>	else
2827	>	if fdDataScale >= (-4) then
2828	>	Param.AsCurrency := PCurrency(data)^
2829		else
2830	<	Qry.Params[i].AsDouble := PDouble(data)^;
2830	>	Param.AsDouble := PDouble(data)^;
2831		end;
2832		SQL_BLOB, SQL_ARRAY, SQL_QUAD:
2833	<	Qry.Params[i].AsQuad := PISC_QUAD(data)^;
2833	>	Param.AsQuad := PISC_QUAD(data)^;
2834		SQL_TYPE_DATE:
2835		begin
2836		ts.Date := PInt(data)^;
2837		ts.Time := 0;
2838	<	Qry.Params[i].AsDate :=
2541	<	TimeStampToDateTime(ts);
2838	>	Param.AsDate := TimeStampToDateTime(ts);
2839		end;
2840		SQL_TYPE_TIME:
2841		begin
2842		ts.Date := 0;
2843		ts.Time := PInt(data)^;
2844	<	Qry.Params[i].AsTime :=
2548	<	TimeStampToDateTime(ts);
2844	>	Param.AsTime := TimeStampToDateTime(ts);
2845		end;
2846		SQL_TIMESTAMP:
2847	<	Qry.Params[i].AsDateTime :=
2847	>	Param.AsDateTime :=
2848		TimeStampToDateTime(MSecsToTimeStamp(trunc(PDouble(data)^)));
2849		SQL_BOOLEAN:
2850	<	Qry.Params[i].AsBoolean := PWordBool(data)^;
2850	>	Param.AsBoolean := PWordBool(data)^;
2851		end;
2852		end;
2853		end;
#	Line 2600 | Line 2896 | begin
2896		FQRefresh.Transaction := Value;
2897		FQSelect.Transaction := Value;
2898		FQModify.Transaction := Value;
2899	+	FGeneratorField.Transaction := Value;
2900		end;
2901		end;
2902
#	Line 2707 | Line 3004 | begin
3004		Result := Assigned( FQSelect ) and FQSelect.EOF;
3005		end;
3006
3007	<	function TIBCustomDataSet.ParamByName(ParamName: String): TIBXSQLVAR;
3007	>	function TIBCustomDataSet.ParamByName(ParamName: String): ISQLParam;
3008		begin
3009		ActivateConnection;
3010		ActivateTransaction;
#	Line 2844 | Line 3141 | var
3141		Buff: PChar;
3142		bTr, bDB: Boolean;
3143		begin
3144	+	if (Field = nil) or (Field.DataSet <> self) then
3145	+	IBError(ibxFieldNotinDataSet,[Field.Name,Name]);
3146		Buff := GetActiveBuf;
3147		if Buff = nil then
3148		begin
3149		fs := TIBBlobStream.Create;
3150		fs.Mode := bmReadWrite;
3151	+	fs.Database := Database;
3152	+	fs.Transaction := Transaction;
3153	+	fs.SetField(Field);
3154		FBlobStreamList.Add(Pointer(fs));
3155		result := TIBDSBlobStream.Create(Field, fs, Mode);
3156		exit;
#	Line 2863 | Line 3165 | begin
3165		fs.Mode := bmReadWrite;
3166		fs.Database := Database;
3167		fs.Transaction := Transaction;
3168	+	fs.SetField(Field);
3169		fs.BlobID :=
3170	<	PISC_QUAD(@Buff[PRecordData(Buff)^.rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdDataOfs])^;
3170	>	PISC_QUAD(@Buff[FFieldColumns^[FMappedFieldPosition[Field.FieldNo - 1]].fdDataOfs])^;
3171		if (CachedUpdates) then
3172		begin
3173		bTr := not Transaction.InTransaction;
#	Line 2885 | Line 3188 | begin
3188		result := TIBDSBlobStream.Create(Field, fs, Mode);
3189		end;
3190
3191	+	function TIBCustomDataSet.GetArray(Field: TIBArrayField): IArray;
3192	+	var Buff: PChar;
3193	+	pda: PArrayDataArray;
3194	+	bTr, bDB: Boolean;
3195	+	begin
3196	+	if (Field = nil) or (Field.DataSet <> self) then
3197	+	IBError(ibxFieldNotinDataSet,[Field.Name,Name]);
3198	+	Buff := GetActiveBuf;
3199	+	if Buff = nil then
3200	+	Result := Database.Attachment.CreateArray(Transaction.TransactionIntf,
3201	+	Field.FRelationName,Field.FieldName)
3202	+	else
3203	+	begin
3204	+	pda := PArrayDataArray(Buff + FArrayCacheOffset);
3205	+	if pda^[Field.FCacheOffset] = nil then
3206	+	begin
3207	+	AdjustRecordOnInsert(Buff);
3208	+	if Field.IsNull then
3209	+	Result := Database.Attachment.CreateArray(Transaction.TransactionIntf,
3210	+	Field.FRelationName,Field.FieldName)
3211	+	else
3212	+	Result := Database.Attachment.OpenArray(Transaction.TransactionIntf,
3213	+	Field.FRelationName,Field.FieldName,Field.ArrayID);
3214	+	pda^[Field.FCacheOffset] := TIBArray.Create(Field,Result);
3215	+	FArrayList.Add(pda^[Field.FCacheOffset]);
3216	+	if (CachedUpdates) then
3217	+	begin
3218	+	bTr := not Transaction.InTransaction;
3219	+	bDB := not Database.Connected;
3220	+	if bDB then
3221	+	Database.Open;
3222	+	if bTr then
3223	+	Transaction.StartTransaction;
3224	+	pda^[Field.FCacheOffset].ArrayIntf.PreLoad;
3225	+	if bTr then
3226	+	Transaction.Commit;
3227	+	if bDB then
3228	+	Database.Close;
3229	+	end;
3230	+	WriteRecordCache(PRecordData(Buff)^.rdRecordNumber, Pointer(Buff));
3231	+	end
3232	+	else
3233	+	Result := pda^[Field.FCacheOffset].ArrayIntf;
3234	+	end;
3235	+	end;
3236	+
3237	+	procedure TIBCustomDataSet.SetArrayIntf(AnArray: IArray; Field: TIBArrayField);
3238	+	var Buff: PChar;
3239	+	pda: PArrayDataArray;
3240	+	begin
3241	+	if (Field = nil) or (Field.DataSet <> self) then
3242	+	IBError(ibxFieldNotinDataSet,[Field.Name,Name]);
3243	+	Buff := GetActiveBuf;
3244	+	if Buff <> nil then
3245	+	begin
3246	+	AdjustRecordOnInsert(Buff);
3247	+	pda := PArrayDataArray(Buff + FArrayCacheOffset);
3248	+	pda^[Field.FCacheOffset].FArray := AnArray;
3249	+	WriteRecordCache(PRecordData(Buff)^.rdRecordNumber, Pointer(Buff));
3250	+	end;
3251	+	end;
3252	+
3253		function TIBCustomDataSet.CompareBookmarks(Bookmark1, Bookmark2: TBookmark): Integer;
3254		const
3255		CMPLess = -1;
#	Line 2965 | Line 3330 | end;
3330		procedure TIBCustomDataSet.DoBeforeClose;
3331		begin
3332		inherited DoBeforeClose;
3333	+	if FInTransactionEnd and (FCloseAction = TARollback) then
3334	+	Exit;
3335		if State in [dsInsert,dsEdit] then
3336		begin
2970	–	if FInTransactionEnd and (FCloseAction = TARollback) then
2971	–	Exit;
2972	–
3337		if DataSetCloseAction = dcSaveChanges then
3338		Post;
3339		{Note this can fail with an exception e.g. due to
3340		database validation error. In which case the dataset remains open }
3341		end;
3342	+	if FCachedUpdates and FUpdatesPending and (DataSetCloseAction = dcSaveChanges) then
3343	+	ApplyUpdates;
3344		end;
3345
3346		procedure TIBCustomDataSet.DoBeforeOpen;
#	Line 3006 | Line 3372 | end;
3372
3373		procedure TIBCustomDataSet.FetchAll;
3374		var
3009	–	{$IFDEF NEW_TBOOKMARK }
3375		CurBookmark: TBookmark;
3011	–	{$ELSE}
3012	–	CurBookmark: string;
3013	–	{$ENDIF}
3376		begin
3377		FBase.SetCursor;
3378		try
#	Line 3121 | Line 3483 | begin
3483		if result and (Buffer <> nil) then
3484		Move(Buff[1], Buffer^, Field.DataSize);
3485		end
3486	<	else if (FMappedFieldPosition[Field.FieldNo - 1] > 0) and
3486	>	else
3487	>	if (FMappedFieldPosition[Field.FieldNo - 1] > 0) and
3488		(FMappedFieldPosition[Field.FieldNo - 1] <= CurrentRecord^.rdFieldCount) then
3489	+	with CurrentRecord^.rdFields[FMappedFieldPosition[Field.FieldNo - 1]],
3490	+	FFieldColumns^[FMappedFieldPosition[Field.FieldNo - 1]] do
3491		begin
3492	<	result := not CurrentRecord^.rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdIsNull;
3492	>	result := not fdIsNull;
3493		if result and (Buffer <> nil) then
3129	–	with CurrentRecord^.rdFields[FMappedFieldPosition[Field.FieldNo - 1]] do
3494		begin
3495	<	Data := Buff + CurrentRecord^.rdFields[FMappedFieldPosition[Field.FieldNo - 1]].fdDataOfs;
3495	>	Data := Buff + fdDataOfs;
3496		if (fdDataType = SQL_VARYING) or (fdDataType = SQL_TEXT) then
3497		begin
3498		if fdDataLength < Field.DataSize then
#	Line 3199 | Line 3563 | begin
3563		if FCurrentRecord < FRecordCount then
3564		ReadRecordCache(FCurrentRecord, Buffer, False)
3565		else begin
3566	<	while (not FQSelect.EOF) and
3203	<	(FQSelect.Next <> nil) and
3566	>	while (not FQSelect.EOF) and FQSelect.Next  and
3567		(FCurrentRecord >= FRecordCount) do begin
3568		FetchCurrentRecordToBuffer(FQSelect, FRecordCount, Buffer);
3569		Inc(FRecordCount);
#	Line 3311 | Line 3674 | procedure TIBCustomDataSet.InternalCance
3674		var
3675		Buff: PChar;
3676		CurRec: Integer;
3677	+	pda: PArrayDataArray;
3678	+	i: integer;
3679		begin
3680		inherited InternalCancel;
3681		Buff := GetActiveBuf;
3682	<	if Buff <> nil then begin
3682	>	if Buff <> nil then
3683	>	begin
3684	>	pda := PArrayDataArray(Buff + FArrayCacheOffset);
3685	>	for i := 0 to ArrayFieldCount - 1 do
3686	>	pda^[i].ArrayIntf.CancelChanges;
3687		CurRec := FCurrentRecord;
3688		AdjustRecordOnInsert(Buff);
3689		if (State = dsEdit) then begin
#	Line 3337 | Line 3706 | begin
3706		DeactivateTransaction;
3707		FQSelect.Close;
3708		ClearBlobCache;
3709	+	ClearArrayCache;
3710		FreeRecordBuffer(FModelBuffer);
3711		FreeRecordBuffer(FOldBuffer);
3712		FCurrentRecord := -1;
#	Line 3352 | Line 3722 | begin
3722		FOBEnd := 0;
3723		FreeMem(FBufferCache);
3724		FBufferCache := nil;
3725	+	FreeMem(FFieldColumns);
3726	+	FFieldColumns := nil;
3727		FreeMem(FOldBufferCache);
3728		FOldBufferCache := nil;
3729		BindFields(False);
#	Line 3426 | Line 3798 | const
3798		'and R.RDB$FIELD_SOURCE = F.RDB$FIELD_NAME '+ {do not localize}
3799		'and ((not F.RDB$COMPUTED_BLR is NULL) or ' + {do not localize}
3800		'     (not F.RDB$DEFAULT_VALUE is NULL)) '; {do not localize}
3801	+
3802	+	DefaultSQLODS12 = 'Select F.RDB$COMPUTED_BLR, ' + {do not localize}
3803	+	'F.RDB$DEFAULT_VALUE, R.RDB$FIELD_NAME, R.RDB$IDENTITY_TYPE ' + {do not localize}
3804	+	'from RDB$RELATION_FIELDS R, RDB$FIELDS F ' + {do not localize}
3805	+	'where R.RDB$RELATION_NAME = :RELATION ' +  {do not localize}
3806	+	'and R.RDB$FIELD_SOURCE = F.RDB$FIELD_NAME '+ {do not localize}
3807	+	'and ((not F.RDB$COMPUTED_BLR is NULL) or ' + {do not localize}
3808	+	'     (not F.RDB$DEFAULT_VALUE is NULL) or ' + {do not localize}
3809	+	'     ( not R.RDB$IDENTITY_TYPE is NULL))' ; {do not localize}
3810	+
3811		var
3812		FieldType: TFieldType;
3813		FieldSize: Word;
3814	+	FieldDataSize: integer;
3815		charSetID: short;
3816		CharSetSize: integer;
3817		CharSetName: RawByteString;
3435	–	{$IFDEF HAS_ANSISTRING_CODEPAGE}
3818		FieldCodePage: TSystemCodePage;
3437	–	{$ENDIF}
3819		FieldNullable : Boolean;
3820		i, FieldPosition, FieldPrecision: Integer;
3821		FieldAliasName, DBAliasName: string;
3822	<	RelationName, FieldName: string;
3822	>	aRelationName, FieldName: string;
3823		Query : TIBSQL;
3824		FieldIndex: Integer;
3825		FRelationNodes : TRelationNode;
3826	+	aArrayDimensions: integer;
3827	+	aArrayBounds: TArrayBounds;
3828	+	ArrayMetaData: IArrayMetaData;
3829
3830		function Add_Node(Relation, Field : String) : TRelationNode;
3831		var
#	Line 3464 | Line 3848 | var
3848		FField.FieldName := Query.Fields[2].AsString;
3849		FField.DEFAULT_VALUE := not Query.Fields[1].IsNull;
3850		FField.COMPUTED_BLR := not Query.Fields[0].IsNull;
3851	+	FField.IDENTITY_COLUMN := (Query.FieldCount > 3) and not Query.Fields[3].IsNull;
3852		FField.NextField := Result.FieldNodes;
3853		Result.FieldNodes := FField;
3854		Query.Next;
#	Line 3517 | Line 3902 | var
3902		FField := Ffield.NextField;
3903		end;
3904
3905	+	function Is_IDENTITY_COLUMN(Relation, Field : String) : Boolean;
3906	+	var
3907	+	FRelation : TRelationNode;
3908	+	FField : TFieldNode;
3909	+	begin
3910	+	FRelation := FRelationNodes;
3911	+	while Assigned(FRelation) and
3912	+	(FRelation.RelationName <> Relation) do
3913	+	FRelation := FRelation.NextRelation;
3914	+	if not Assigned(FRelation) then
3915	+	FRelation := Add_Node(Relation, Field);
3916	+	Result := false;
3917	+	FField := FRelation.FieldNodes;
3918	+	while Assigned(FField) do
3919	+	if FField.FieldName = Field then
3920	+	begin
3921	+	Result := Ffield.IDENTITY_COLUMN;
3922	+	Exit;
3923	+	end
3924	+	else
3925	+	FField := Ffield.NextField;
3926	+	end;
3927	+
3928		Procedure FreeNodes;
3929		var
3930		FRelation : TRelationNode;
#	Line 3539 | Line 3947 | var
3947		begin
3948		FRelationNodes := TRelationNode.Create;
3949		FNeedsRefresh := False;
3950	<	Database.InternalTransaction.StartTransaction;
3950	>	if not Database.InternalTransaction.InTransaction then
3951	>	Database.InternalTransaction.StartTransaction;
3952		Query := TIBSQL.Create(self);
3953		try
3954		Query.Database := DataBase;
#	Line 3547 | Line 3956 | begin
3956		FieldDefs.BeginUpdate;
3957		FieldDefs.Clear;
3958		FieldIndex := 0;
3959	<	if (Length(FMappedFieldPosition) < SourceQuery.Current.Count) then
3960	<	SetLength(FMappedFieldPosition, SourceQuery.Current.Count);
3961	<	Query.SQL.Text := DefaultSQL;
3959	>	if (Length(FMappedFieldPosition) < SourceQuery.MetaData.Count) then
3960	>	SetLength(FMappedFieldPosition, SourceQuery.MetaData.Count);
3961	>	if FDatabaseInfo.ODSMajorVersion >= 12 then
3962	>	Query.SQL.Text := DefaultSQLODS12
3963	>	else
3964	>	Query.SQL.Text := DefaultSQL;
3965		Query.Prepare;
3966	<	SetLength(FAliasNameMap, SourceQuery.Current.Count);
3967	<	SetLength(FAliasNameList, SourceQuery.Current.Count);
3968	<	for i := 0 to SourceQuery.Current.Count - 1 do
3969	<	with SourceQuery.Current[i].Data^ do
3966	>	SetLength(FAliasNameMap, SourceQuery.MetaData.Count);
3967	>	SetLength(FAliasNameList, SourceQuery.MetaData.Count);
3968	>	for i := 0 to SourceQuery.MetaData.GetCount - 1 do
3969	>	with SourceQuery.MetaData[i] do
3970		begin
3971		{ Get the field name }
3972	<	FieldAliasName := SourceQuery.Current[i].Name;
3973	<	SetString(DBAliasName, aliasname, aliasname_length);
3974	<	SetString(RelationName, relname, relname_length);
3975	<	SetString(FieldName, sqlname, sqlname_length);
3972	>	FieldAliasName := GetName;
3973	>	DBAliasName := GetAliasname;
3974	>	aRelationName := getRelationName;
3975	>	FieldName := getSQLName;
3976		FAliasNameList[i] := DBAliasName;
3977		FieldSize := 0;
3978	+	FieldDataSize := GetSize;
3979		FieldPrecision := 0;
3980	<	FieldNullable := SourceQuery.Current[i].IsNullable;
3980	>	FieldNullable := IsNullable;
3981		CharSetSize := 0;
3982		CharSetName := '';
3570	–	{$IFDEF HAS_ANSISTRING_CODEPAGE}
3983		FieldCodePage := CP_NONE;
3984	<	{$ENDIF}
3985	<	case sqltype and not 1 of
3984	>	aArrayDimensions := 0;
3985	>	SetLength(aArrayBounds,0);
3986	>	case SQLType of
3987		{ All VARCHAR's must be converted to strings before recording
3988		their values }
3989		SQL_VARYING, SQL_TEXT:
3990		begin
3991	<	CharSetSize := FBase.GetCharSetSize(sqlsubtype and $FF);
3992	<	CharSetName := FBase.GetCharSetName(sqlsubtype and $FF);
3993	<	{$IFDEF HAS_ANSISTRING_CODEPAGE}
3994	<	FieldCodePage := FBase.GetCodePage(sqlsubtype and $FF);
3995	<	{$ENDIF}
3996	<	{FieldSize is encoded for strings - see TIBStringField.SetSize for decode}
3584	<	FieldSize := sqllen;
3585	<	if CharSetSize = 2 then
3586	<	FieldType := ftWideString
3587	<	else
3588	<	FieldType := ftString;
3991	>	if not Database.Attachment.CharSetWidth(getCharSetID,CharSetSize) then
3992	>	CharSetSize := 1;
3993	>	CharSetName := Database.Attachment.GetCharsetName(getCharSetID);
3994	>	Database.Attachment.CharSetID2CodePage(getCharSetID,FieldCodePage);
3995	>	FieldSize := FieldDataSize div CharSetSize;
3996	>	FieldType := ftString;
3997		end;
3998		{ All Doubles/Floats should be cast to doubles }
3999		SQL_DOUBLE, SQL_FLOAT:
4000		FieldType := ftFloat;
4001		SQL_SHORT:
4002		begin
4003	<	if (sqlscale = 0) then
4003	>	if (getScale = 0) then
4004		FieldType := ftSmallInt
4005		else begin
4006		FieldType := ftBCD;
4007		FieldPrecision := 4;
4008	<	FieldSize := -sqlscale;
4008	>	FieldSize := -getScale;
4009		end;
4010		end;
4011		SQL_LONG:
4012		begin
4013	<	if (sqlscale = 0) then
4013	>	if (getScale = 0) then
4014		FieldType := ftInteger
4015	<	else if (sqlscale >= (-4)) then
4015	>	else if (getScale >= (-4)) then
4016		begin
4017		FieldType := ftBCD;
4018		FieldPrecision := 9;
4019	<	FieldSize := -sqlscale;
4019	>	FieldSize := -getScale;
4020		end
4021		else
4022		if Database.SQLDialect = 1 then
#	Line 3620 | Line 4028 | begin
4028		begin
4029		FieldType := ftFMTBCD;
4030		FieldPrecision := 9;
4031	<	FieldSize := -sqlscale;
4031	>	FieldSize := -getScale;
4032		end;
4033		end;
4034
4035		SQL_INT64:
4036		begin
4037	<	if (sqlscale = 0) then
4037	>	if (getScale = 0) then
4038		FieldType := ftLargeInt
4039	<	else if (sqlscale >= (-4)) then
4039	>	else if (getScale >= (-4)) then
4040		begin
4041		FieldType := ftBCD;
4042		FieldPrecision := 18;
4043	<	FieldSize := -sqlscale;
4043	>	FieldSize := -getScale;
4044		end
4045		else
4046	<	FieldType := ftFloat
4046	>	FieldType := ftFloat;
4047		end;
4048		SQL_TIMESTAMP: FieldType := ftDateTime;
4049		SQL_TYPE_TIME: FieldType := ftTime;
#	Line 3643 | Line 4051 | begin
4051		SQL_BLOB:
4052		begin
4053		FieldSize := sizeof (TISC_QUAD);
4054	<	if (sqlsubtype = 1) then
4054	>	if (getSubtype = 1) then
4055		begin
4056	<	if FBase.GetDefaultCharSetName <> '' then
3649	<	begin
3650	<	CharSetSize := FBase.GetDefaultCharSetSize;
3651	<	CharSetName := FBase.GetDefaultCharSetName;
3652	<	{$IFDEF HAS_ANSISTRING_CODEPAGE}
3653	<	FieldCodePage := FBase.GetDefaultCodePage;
3654	<	{$ENDIF}
3655	<	end
3656	<	else
3657	<	if strpas(sqlname) <> '' then
3658	<	begin
3659	<	charSetID := GetBlobCharSetID(Database.Handle,Database.InternalTransaction.Handle,
3660	<	@relname,@sqlname);
3661	<	CharSetSize := FBase.GetCharSetSize(charSetID);
3662	<	CharSetName := FBase.GetCharSetName(charSetID);
3663	<	{$IFDEF HAS_ANSISTRING_CODEPAGE}
3664	<	FieldCodePage := FBase.GetCodePage(charSetID);
3665	<	{$ENDIF}
3666	<	end
3667	<	else  {Complex SQL with no identifiable column and no connection default}
3668	<	begin
3669	<	CharSetName := '';
4056	>	if not Database.Attachment.CharSetWidth(getCharSetID,CharSetSize) then
4057		CharSetSize := 1;
4058	<	{$IFDEF HAS_ANSISTRING_CODEPAGE}
4059	<	FieldCodePage := CP_NONE;
4060	<	{$ENDIF}
3674	<	end;
3675	<	if CharSetSize = 2 then
3676	<	FieldType := ftWideMemo
3677	<	else
3678	<	FieldType := ftMemo;
4058	>	CharSetName := Database.Attachment.GetCharsetName(getCharSetID);
4059	>	Database.Attachment.CharSetID2CodePage(getCharSetID,FieldCodePage);
4060	>	FieldType := ftMemo;
4061		end
4062		else
4063		FieldType := ftBlob;
#	Line 3683 | Line 4065 | begin
4065		SQL_ARRAY:
4066		begin
4067		FieldSize := sizeof (TISC_QUAD);
4068	<	FieldType := ftUnknown;
4068	>	FieldType := ftArray;
4069	>	ArrayMetaData := GetArrayMetaData;
4070	>	if ArrayMetaData <> nil then
4071	>	begin
4072	>	aArrayDimensions := ArrayMetaData.GetDimensions;
4073	>	aArrayBounds := ArrayMetaData.GetBounds;
4074	>	end;
4075		end;
4076		SQL_BOOLEAN:
4077		FieldType:= ftBoolean;
#	Line 3700 | Line 4088 | begin
4088		Name := FieldAliasName;
4089		FAliasNameMap[FieldNo-1] := DBAliasName;
4090		Size := FieldSize;
4091	+	DataSize := FieldDataSize;
4092		Precision := FieldPrecision;
4093		Required := not FieldNullable;
4094	+	RelationName := aRelationName;
4095		InternalCalcField := False;
4096		CharacterSetSize := CharSetSize;
4097		CharacterSetName := CharSetName;
3708	–	{$IFDEF HAS_ANSISTRING_CODEPAGE}
4098		CodePage := FieldCodePage;
4099	<	{$ENDIF}
4099	>	ArrayDimensions := aArrayDimensions;
4100	>	ArrayBounds := aArrayBounds;
4101		if (FieldName <> '') and (RelationName <> '') then
4102		begin
4103	+	IdentityColumn := Is_IDENTITY_COLUMN(RelationName, FieldName);
4104		if Has_COMPUTED_BLR(RelationName, FieldName) then
4105		begin
4106		Attributes := [faReadOnly];
#	Line 3735 | Line 4126 | begin
4126		FreeNodes;
4127		Database.InternalTransaction.Commit;
4128		FieldDefs.EndUpdate;
4129	+	FieldDefs.Updated := true;
4130		end;
4131		end;
4132
#	Line 3752 | Line 4144 | begin
4144		else begin
4145		Buffer := AllocRecordBuffer;
4146		try
4147	<	while FQSelect.Next <> nil do
4147	>	while FQSelect.Next do
4148		begin
4149		FetchCurrentRecordToBuffer(FQSelect, FRecordCount, Buffer);
4150		Inc(FRecordCount);
#	Line 3767 | Line 4159 | end;
4159		procedure TIBCustomDataSet.InternalSetParamsFromCursor;
4160		var
4161		i: Integer;
4162	<	cur_param: TIBXSQLVAR;
4162	>	cur_param: ISQLParam;
4163		cur_field: TField;
4164		s: TStream;
4165		begin
#	Line 3775 | Line 4167 | begin
4167		IBError(ibxeEmptyQuery, [nil]);
4168		if not FInternalPrepared then
4169		InternalPrepare;
4170	<	if (SQLParams.Count > 0) and (DataSource <> nil) and (DataSource.DataSet <> nil) then
4170	>	if (SQLParams.GetCount > 0) and (DataSource <> nil) and (DataSource.DataSet <> nil) then
4171		begin
4172	<	for i := 0 to SQLParams.Count - 1 do
4172	>	for i := 0 to SQLParams.GetCount - 1 do
4173		begin
4174		cur_field := DataSource.DataSet.FindField(SQLParams[i].Name);
4175		cur_param := SQLParams[i];
#	Line 3811 | Line 4203 | begin
4203		try
4204		s := DataSource.DataSet.
4205		CreateBlobStream(cur_field, bmRead);
4206	<	cur_param.LoadFromStream(s);
4206	>	cur_param.AsBlob := TIBDSBlobStream(s).FBlobStream.Blob;
4207		finally
4208		s.free;
4209		end;
4210		end;
4211	+	ftArray:
4212	+	cur_param.AsArray := TIBArrayField(cur_field).ArrayIntf;
4213		else
4214		IBError(ibxeNotSupported, [nil]);
4215		end;
#	Line 3848 | Line 4242 | procedure TIBCustomDataSet.InternalOpen;
4242		result := SizeOf(TRecordData) + ((n - 1) * SizeOf(TFieldData));
4243		end;
4244
3851	–	function GetFieldDef(aFieldNo: integer): TIBFieldDef;
3852	–	var i: integer;
3853	–	begin
3854	–	Result := nil;
3855	–	for i := 0 to FieldDefs.Count - 1 do
3856	–	if FieldDefs[i].FieldNo = aFieldNo then
3857	–	begin
3858	–	Result := TIBFieldDef(FieldDefs[i]);
3859	–	break;
3860	–	end;
3861	–	end;
3862	–
3863	–	procedure SetExtendedProperties;
3864	–	var i: integer;
3865	–	IBFieldDef: TIBFieldDef;
3866	–	begin
3867	–	for i := 0 to Fields.Count - 1 do
3868	–	if Fields[i].FieldNo > 0 then
3869	–	begin
3870	–	if(Fields[i] is TIBStringField) then
3871	–	with TIBStringField(Fields[i]) do
3872	–	begin
3873	–	IBFieldDef := GetFieldDef(FieldNo);
3874	–	if IBFieldDef <> nil then
3875	–	begin
3876	–	CharacterSetSize := IBFieldDef.CharacterSetSize;
3877	–	CharacterSetName := IBFieldDef.CharacterSetName;
3878	–	{$IFDEF HAS_ANSISTRING_CODEPAGE}
3879	–	CodePage := IBFieldDef.CodePage;
3880	–	{$ENDIF}
3881	–	end;
3882	–	end
3883	–	else
3884	–	if(Fields[i] is TIBWideStringField) then
3885	–	with TIBWideStringField(Fields[i]) do
3886	–	begin
3887	–	IBFieldDef := GetFieldDef(FieldNo);
3888	–	if IBFieldDef <> nil then
3889	–	begin
3890	–	CharacterSetSize := IBFieldDef.CharacterSetSize;
3891	–	CharacterSetName := IBFieldDef.CharacterSetName;
3892	–	end;
3893	–	end
3894	–	else
3895	–	if(Fields[i] is TIBMemoField) then
3896	–	with TIBMemoField(Fields[i]) do
3897	–	begin
3898	–	IBFieldDef := GetFieldDef(FieldNo);
3899	–	if IBFieldDef <> nil then
3900	–	begin
3901	–	CharacterSetSize := IBFieldDef.CharacterSetSize;
3902	–	CharacterSetName := IBFieldDef.CharacterSetName;
3903	–	{$IFDEF HAS_ANSISTRING_CODEPAGE}
3904	–	CodePage := IBFieldDef.CodePage;
3905	–	{$ENDIF}
3906	–	end;
3907	–	end
3908	–	else
3909	–	if(Fields[i] is TIBWideMemoField) then
3910	–	with TIBWideMemoField(Fields[i]) do
3911	–	begin
3912	–	IBFieldDef := GetFieldDef(FieldNo);
3913	–	if IBFieldDef <> nil then
3914	–	begin
3915	–	CharacterSetSize := IBFieldDef.CharacterSetSize;
3916	–	CharacterSetName := IBFieldDef.CharacterSetName;
3917	–	end;
3918	–	end
3919	–	end
3920	–	end;
3921	–
4245		begin
4246		FBase.SetCursor;
4247		try
#	Line 3928 | Line 4251 | begin
4251		IBError(ibxeEmptyQuery, [nil]);
4252		if not FInternalPrepared then
4253		InternalPrepare;
4254	<	if FQSelect.SQLType = SQLSelect then
4254	>	if FQSelect.SQLStatementType = SQLSelect then
4255		begin
4256		if DefaultFields then
4257		CreateFields;
4258	+	FArrayFieldCount := 0;
4259		BindFields(True);
3936	–	SetExtendedProperties;
4260		FCurrentRecord := -1;
4261		FQSelect.ExecQuery;
4262		FOpen := FQSelect.Open;
#	Line 3944 | Line 4267 | begin
4267		3. After the dummy fetch, FRecordSize will be appropriately
4268		adjusted to reflect the additional "weight" of the field
4269		data.
4270	<	4. Set up the FCalcFieldsOffset, FBlobCacheOffset and FRecordBufferSize.
4270	>	4. Set up the FCalcFieldsOffset, FBlobCacheOffset, FArrayCacheOffset and FRecordBufferSize.
4271		5. Now, with the BufferSize available, allocate memory for chunks of records
4272		6. Re-allocate the model buffer, accounting for the new
4273		FRecordBufferSize.
4274		7. Finally, calls to AllocRecordBuffer will work!.
4275		}
4276		{Step 1}
4277	<	FRecordSize := RecordDataLength(FQSelect.Current.Count);
4277	>	FRecordSize := RecordDataLength(FQSelect.FieldCount);
4278		{Step 2, 3}
4279	+	GetMem(FFieldColumns,sizeof(TFieldColumns) * (FQSelect.FieldCount));
4280		IBAlloc(FModelBuffer, 0, FRecordSize);
4281	<	FetchCurrentRecordToBuffer(FQSelect, -1, FModelBuffer);
4281	>	InitModelBuffer(FQSelect, FModelBuffer);
4282		{Step 4}
4283		FCalcFieldsOffset := FRecordSize;
4284		FBlobCacheOffset := FCalcFieldsOffset + CalcFieldsSize;
4285	<	FRecordBufferSize := (FBlobCacheOffset + (BlobFieldCount * SizeOf(TIBBlobStream)));
4285	>	FArrayCacheOffset := (FBlobCacheOffset + (BlobFieldCount * SizeOf(TIBBlobStream)));
4286	>	FRecordBufferSize := FArrayCacheOffset + (ArrayFieldCount * sizeof(IArray));
4287		{Step 5}
4288		if UniDirectional then
4289		FBufferChunkSize := FRecordBufferSize * UniCache
#	Line 3974 | Line 4299 | begin
4299		FCacheSize := FBufferChunkSize;
4300		FOldCacheSize := FBufferChunkSize;
4301		{Step 6}
4302	<	IBAlloc(FModelBuffer, RecordDataLength(FQSelect.Current.Count),
4302	>	IBAlloc(FModelBuffer, RecordDataLength(FQSelect.FieldCount),
4303		FRecordBufferSize);
4304		{Step 7}
4305		FOldBuffer := AllocRecordBuffer;
#	Line 4072 | Line 4397 | end;
4397		function TIBCustomDataSet.Locate(const KeyFields: string; const KeyValues: Variant;
4398		Options: TLocateOptions): Boolean;
4399		var
4075	–	{$IFDEF NEW_TBOOKMARK }
4400		CurBookmark: TBookmark;
4077	–	{$ELSE}
4078	–	CurBookmark: string;
4079	–	{$ENDIF}
4401		begin
4402		DisableControls;
4403		try
#	Line 4094 | Line 4415 | function TIBCustomDataSet.Lookup(const K
4415		const ResultFields: string): Variant;
4416		var
4417		fl: TList;
4097	–	{$IFDEF NEW_TBOOKMARK }
4418		CurBookmark: TBookmark;
4099	–	{$ELSE}
4100	–	CurBookmark: string;
4101	–	{$ENDIF}
4419		begin
4420		DisableControls;
4421		fl := TList.Create;
#	Line 4171 | Line 4488 | begin
4488		MappedFieldPos := FMappedFieldPosition[Field.FieldNo - 1];
4489		if (MappedFieldPos > 0) and
4490		(MappedFieldPos <= rdFieldCount) then
4491	+	with rdFields[MappedFieldPos], FFieldColumns^[MappedFieldPos] do
4492		begin
4493		Field.Validate(Buffer);
4494		if (Buffer = nil) or
4495		(Field is TIBStringField) and (PChar(Buffer)[0] = #0) then
4496	<	rdFields[MappedFieldPos].fdIsNull := True
4497	<	else begin
4498	<	Move(Buffer^, Buff[rdFields[MappedFieldPos].fdDataOfs],
4499	<	rdFields[MappedFieldPos].fdDataSize);
4500	<	if (rdFields[MappedFieldPos].fdDataType = SQL_TEXT) or
4501	<	(rdFields[MappedFieldPos].fdDataType = SQL_VARYING) then
4502	<	rdFields[MappedFieldPos].fdDataLength := StrLen(PChar(Buffer));
4185	<	rdFields[MappedFieldPos].fdIsNull := False;
4496	>	fdIsNull := True
4497	>	else
4498	>	begin
4499	>	Move(Buffer^, Buff[fdDataOfs],fdDataSize);
4500	>	if (fdDataType = SQL_TEXT) or (fdDataType = SQL_VARYING) then
4501	>	fdDataLength := StrLen(PChar(Buffer));
4502	>	fdIsNull := False;
4503		if rdUpdateStatus = usUnmodified then
4504		begin
4505		if CachedUpdates then
#	Line 4283 | Line 4600 | begin
4600		if FInternalPrepared then
4601		begin
4602		CheckDatasetClosed;
4603	+	if FDidActivate then
4604	+	DeactivateTransaction;
4605		FieldDefs.Clear;
4606		FieldDefs.Updated := false;
4607		FInternalPrepared := False;
#	Line 4303 | Line 4622 | begin
4622		IBError(ibxeEmptyQuery, [nil]);
4623		if not FInternalPrepared then
4624		InternalPrepare;
4625	<	if FQSelect.SQLType = SQLSelect then
4625	>	if FQSelect.SQLStatementType = SQLSelect then
4626		begin
4627		IBError(ibxeIsASelectStatement, [nil]);
4628		end
#	Line 4316 | Line 4635 | begin
4635		end;
4636		end;
4637
4638	<	function TIBCustomDataSet.GetSelectStmtHandle: TISC_STMT_HANDLE;
4638	>	function TIBCustomDataSet.GetSelectStmtIntf: IStatement;
4639		begin
4640	<	Result := FQSelect.Handle;
4640	>	Result := FQSelect.Statement;
4641		end;
4642
4643		function TIBCustomDataSet.GetParser: TSelectSQLParser;
#	Line 4373 | Line 4692 | end;
4692
4693		{ TIBDataSet IProviderSupport }
4694
4695	<	(*procedure TIBCustomDataSet.PSEndTransaction(Commit: Boolean);
4695	>	procedure TIBCustomDataSet.PSEndTransaction(Commit: Boolean);
4696		begin
4697		if Commit then
4698		Transaction.Commit else
#	Line 4526 | Line 4845 | begin
4845		Transaction.StartTransaction;
4846		end;
4847
4848	<	function TIBCustomDataSet.PSGetTableName: string;
4848	>	function TIBCustomDataSet.PsGetTableName: string;
4849		begin
4850		//  if not FInternalPrepared then
4851		//    InternalPrepare;
#	Line 4536 | Line 4855 | begin
4855		if not FQSelect.Prepared then
4856		FQSelect.Prepare;
4857		Result := FQSelect.UniqueRelationName;
4858	<	end;*)
4858	>	end;
4859
4860		procedure TIBDataSet.BatchInput(InputObject: TIBBatchInput);
4861		begin
#	Line 4667 | Line 4986 | begin
4986		inherited Destroy;
4987		end;
4988
4989	<	procedure TIBDataSetUpdateObject.SetRefreshSQL(Value: TStrings);
4989	>	procedure TIBDataSetUpdateObject.SetRefreshSQL(value: TStrings);
4990		begin
4991		FRefreshSQL.Assign(Value);
4992		end;
4993
4994	+	procedure TIBDataSetUpdateObject.InternalSetParams(Params: ISQLParams;
4995	+	buff: PChar);
4996	+	begin
4997	+	if not Assigned(DataSet) then Exit;
4998	+	DataSet.SetInternalSQLParams(Params, buff);
4999	+	end;
5000	+
5001		procedure TIBDataSetUpdateObject.InternalSetParams(Query: TIBSQL; buff: PChar);
5002		begin
5003	+	InternalSetParams(Query.Params,buff);
5004	+	end;
5005	+
5006	+	procedure TIBDataSetUpdateObject.UpdateRecordFromQuery(QryResults: IResults;
5007	+	Buffer: PChar);
5008	+	begin
5009		if not Assigned(DataSet) then Exit;
5010	<	DataSet.SetInternalSQLParams(Query, buff);
5010	>	DataSet.UpdateRecordFromQuery(QryResults, Buffer);
5011		end;
5012
5013		function TIBDSBlobStream.GetSize: Int64;
#	Line 4738 | Line 5070 | end;
5070
5071		procedure TIBGenerator.SetIncrement(const AValue: integer);
5072		begin
5073	+	if FIncrement = AValue then Exit;
5074		if AValue < 0 then
5075	<	raise Exception.Create('A Generator Increment cannot be negative');
5076	<	FIncrement := AValue
5075	>	IBError(ibxeNegativeGenerator,[]);
5076	>	FIncrement := AValue;
5077	>	SetQuerySQL;
5078		end;
5079
5080	<	function TIBGenerator.GetNextValue(ADatabase: TIBDatabase;
4747	<	ATransaction: TIBTransaction): integer;
5080	>	procedure TIBGenerator.SetTransaction(AValue: TIBTransaction);
5081		begin
5082	<	with TIBSQL.Create(nil) do
5083	<	try
5084	<	Database := ADatabase;
5085	<	Transaction := ATransaction;
5086	<	if not assigned(Database) then
5087	<	IBError(ibxeCannotSetDatabase,[]);
5088	<	if not assigned(Transaction) then
5089	<	IBError(ibxeCannotSetTransaction,[]);
5090	<	with Transaction do
5091	<	if not InTransaction then StartTransaction;
5092	<	SQL.Text := Format('Select Gen_ID(%s,%d) as ID From RDB$Database',[FGeneratorName,Increment]);
5093	<	Prepare;
5082	>	FQuery.Transaction := AValue;
5083	>	end;
5084	>
5085	>	procedure TIBGenerator.SetQuerySQL;
5086	>	begin
5087	>	FQuery.SQL.Text := Format('Select Gen_ID(%s,%d) From RDB$Database',[FGeneratorName,Increment]);
5088	>	end;
5089	>
5090	>	function TIBGenerator.GetDatabase: TIBDatabase;
5091	>	begin
5092	>	Result := FQuery.Database;
5093	>	end;
5094	>
5095	>	function TIBGenerator.GetTransaction: TIBTransaction;
5096	>	begin
5097	>	Result := FQuery.Transaction;
5098	>	end;
5099	>
5100	>	procedure TIBGenerator.SetDatabase(AValue: TIBDatabase);
5101	>	begin
5102	>	FQuery.Database := AValue;
5103	>	end;
5104	>
5105	>	procedure TIBGenerator.SetGeneratorName(AValue: string);
5106	>	begin
5107	>	if FGeneratorName = AValue then Exit;
5108	>	FGeneratorName := AValue;
5109	>	SetQuerySQL;
5110	>	end;
5111	>
5112	>	function TIBGenerator.GetNextValue: integer;
5113	>	begin
5114	>	with FQuery do
5115	>	begin
5116	>	Transaction.Active := true;
5117		ExecQuery;
5118		try
5119	<	Result := FieldByName('ID').AsInteger
5119	>	Result := Fields[0].AsInteger
5120		finally
5121		Close
5122		end;
4767	–	finally
4768	–	Free
5123		end;
5124		end;
5125
#	Line 4773 | Line 5127 | constructor TIBGenerator.Create(Owner: T
5127		begin
5128		FOwner := Owner;
5129		FIncrement := 1;
5130	+	FQuery := TIBSQL.Create(nil);
5131	+	end;
5132	+
5133	+	destructor TIBGenerator.Destroy;
5134	+	begin
5135	+	if assigned(FQuery) then FQuery.Free;
5136	+	inherited Destroy;
5137		end;
5138
5139
5140		procedure TIBGenerator.Apply;
5141		begin
5142	<	if (FGeneratorName <> '') and (FFieldName <> '') and Owner.FieldByName(FFieldName).IsNull then
5143	<	Owner.FieldByName(FFieldName).AsInteger := GetNextValue(Owner.Database,Owner.Transaction);
5142	>	if assigned(Database) and assigned(Transaction) and
5143	>	(FGeneratorName <> '') and (FFieldName <> '') and Owner.FieldByName(FFieldName).IsNull then
5144	>	Owner.FieldByName(FFieldName).AsInteger := GetNextValue;
5145		end;
5146
5147

Diff Legend

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