ViewVC Help

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

root/public/ibx/branches/journaling/fbintf/IB.pas

Comparing:
ibx/trunk/fbintf/IB.pas (file contents), Revision 241 by tony, Thu Oct 25 13:57:12 2018 UTC vs.
ibx/branches/journaling/fbintf/IB.pas (file contents), Revision 363 by tony, Tue Dec 7 13:30:05 2021 UTC

#	Line 73 | Line 73 | unit IB;
73		{$IFEND}
74		{$ENDIF}
75
76	+	{$IFNDEF LEGACYFIREBIRDAPIONLY}
77		{$DEFINE USEFIREBIRD3API}
78	+	{$ENDIF}
79	+	{$IFNDEF FIREBIRD3APIONLY}
80		{$DEFINE USELEGACYFIREBIRDAPI}
81	+	{$ENDIF}
82
83		{
84		This unit defines the interfaces used to provide the Pascal Language
#	Line 122 | Line 126 | unit IB;
126		interface
127
128		uses
129	<	Classes, SysUtils, DB, FBMessages, IBExternals;
129	>	Classes,
130	>	{$IFDEF WINDOWS}Windows, {$ENDIF}
131	>	{$IFDEF FPC} Dynlibs, {$ENDIF}
132	>	SysUtils, DB, FBMessages, IBExternals, FmtBcd;
133
134		const
135		{Interface version information}
136		FBIntf_Major = 1;
137	<	FBIntf_Minor = 1;
138	<	FBIntf_Release = 3;
139	<	FBIntf_Version = '1.1.3';
137	>	FBIntf_Minor = 3;
138	>	FBIntf_Release = 2;
139	>	FBIntf_Version = '1.3.2';
140	>
141	>	const
142	>	{DPB, TPB and SPB Parameter Block Name Prefixes}
143	>	DPBPrefix = 'isc_dpb_';
144	>	TPBPrefix = 'isc_tpb_';
145	>
146	>	const
147	>	{Time Zone ID constraint}
148	>	MaxOffsetTimeZoneID = 2879; {lower values represent a time zone offset between
149	>	-23:59 and 23:59. Higher values are keys to the
150	>	Time Zone database.}
151	>
152	>	TimeZoneID_GMT = 23*minsPerHour + 59;
153	>	decimillisecondsPerSecond = 10000;
154	>	TimeZoneDisplacementDelta = 60*23 + 59; {23:59 in minutes}
155
156		{These include files are converted from the 'C' originals in the Firebird API
157		and define the various constants used by the API}
158
159		{$I 'include/consts_pub.inc'}
160	+	{$I 'include/dyn_consts.inc'}
161		{$I 'include/inf_pub.inc'}
162		{$I 'include/configkeys.inc'}
163	+	{$I 'include/blr.inc'}
164
165		{The following constants define the values return by calls to the GetSQLType
166		methods provided by several of the interfaces defined below.}
#	Line 158 | Line 182 | const
182		SQL_TYPE_TIME                  =        560;
183		SQL_TYPE_DATE                  =        570;
184		SQL_INT64                      =        580;
185	+	SQL_TIMESTAMP_TZ_EX            =        32748;
186	+	SQL_TIME_TZ_EX                 =        32750;
187	+	SQL_INT128                     =        32752;
188		SQL_BOOLEAN                    =        32764;
189	+	SQL_TIMESTAMP_TZ               =        32754;
190	+	SQL_TIME_TZ                    =        32756;
191	+	SQL_DEC_FIXED                  =        32758;    {FB4 Beta 1 only}
192	+	SQL_DEC16                      =        32760;
193	+	SQL_DEC34                      =        32762;
194	+	SQL_NULL                       =        32766;
195		SQL_DATE                       =        SQL_TIMESTAMP;
196
197		type
#	Line 173 | Line 206 | type
206		PISC_QUAD            = ^TISC_QUAD;
207
208		{$IFNDEF FPC}
209	+	{Delphi missing definitions}
210	+	type
211	+	TLibHandle = THandle;
212	+
213	+	const
214	+	NilHandle = 0;
215	+	DirectorySeparator = '\';
216	+
217		{Delphi only seems to define CP_UTF8 and CP_UTF16}
218		const
219		CP_ACP     = 0;     // default to ANSI code page
#	Line 195 | Line 236 | type
236		SQLGetSegment, SQLPutSegment,
237		SQLExecProcedure, SQLStartTransaction,
238		SQLCommit, SQLRollback,
239	<	SQLSelectForUpdate, SQLSetGenerator);
239	>	SQLSelectForUpdate, SQLSetGenerator,
240	>	SQLSavePoint);
241
242		TFBStatusCode = cardinal;
243		TByteArray = array of byte;
244	+	TFBTimeZoneID = ISC_USHORT;
245
246	+	IFirebirdAPI = interface;
247		IAttachment = interface;
248		ITransaction = interface;
249	+	IStatement = interface;
250
251		{The IParameterBlock interface provides the template for all parameter
252		block interfaces}
#	Line 216 | Line 261 | type
261		property Items[index: integer]: _IItem read getItems; default;
262		end;
263
264	+	IParameterBlockWithTypeNames<_IItem> = interface(IParameterBlock<_IItem>)
265	+	function AddByTypeName(ParamTypeName: AnsiString): _IItem;
266	+	function GetDPBParamTypeName(ParamType: byte): Ansistring; deprecated 'Use Get ParamTypeName';
267	+	function GetParamTypeName(ParamType: byte): Ansistring;
268	+	end;
269	+
270		{IParameterBlockItem is not used on its own but instead provides a base type for
271		different parameter block items }
272
#	Line 233 | Line 284 | type
284		property AsInteger: integer read getAsInteger write SetAsInteger;
285		end;
286
287	+	IParameterBlockItemWithTypeName = interface(IParameterBlockItem)
288	+	function getParamTypeName: AnsiString;
289	+	end;
290
291		{The IStatus interface provides access to error information, if any, returned
292		by the last API call. It can also be used to customise the error message
#	Line 241 | Line 295 | type
295		This interface can be accessed from IFirebirdAPI.
296		}
297
298	+	TIBDataBaseErrorMessage    = (ShowSQLCode,
299	+	ShowIBMessage,
300	+	ShowSQLMessage);
301	+
302	+	TIBDataBaseErrorMessages   = set of TIBDataBaseErrorMessage;
303	+
304	+	TStatusCode = long;
305	+
306		IStatus = interface
307		['{34167722-af38-4831-b08a-93162d58ede3}']
308	<	function GetIBErrorCode: Long;
309	<	function Getsqlcode: Long;
308	>	function GetIBErrorCode: TStatusCode;
309	>	function Getsqlcode: TStatusCode;
310		function GetMessage: AnsiString;
311		function CheckStatusVector(ErrorCodes: array of TFBStatusCode): Boolean;
312		function GetIBDataBaseErrorMessages: TIBDataBaseErrorMessages;
#	Line 267 | Line 329 | type
329		function GetSQLTypeName: AnsiString;
330		function GetScale: integer;
331		function GetSize: cardinal;
332	+	function GetCharSetWidth: integer;
333		function GetCharSetID: cardinal;
334		function GetTableName: AnsiString;
335		function GetColumnName: AnsiString;
#	Line 305 | Line 368 | type
368		function GetAsBoolean(index: array of integer): boolean;
369		function GetAsCurrency(index: array of integer): Currency;
370		function GetAsInt64(index: array of integer): Int64;
371	<	function GetAsDateTime(index: array of integer): TDateTime;
371	>	function GetAsDateTime(index: array of integer): TDateTime; overload;
372	>	procedure GetAsDateTime(index: array of integer; var aDateTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID); overload;
373	>	procedure GetAsDateTime(index: array of integer; var aDateTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString); overload;
374	>	procedure GetAsTime(index: array of integer; var aTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID; OnDate: TDateTime); overload;
375	>	procedure GetAsTime(index: array of integer; var aTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString; OnDate: TDateTime); overload;
376	>	function GetAsUTCDateTime(index: array of integer): TDateTime;
377		function GetAsDouble(index: array of integer): Double;
378		function GetAsFloat(index: array of integer): Float;
379		function GetAsLong(index: array of integer): Long;
380		function GetAsShort(index: array of integer): Short;
381		function GetAsString(index: array of integer): AnsiString;
382		function GetAsVariant(index: array of integer): Variant;
383	+	function GetAsBCD(index: array of integer): tBCD;
384		procedure SetAsInteger(index: array of integer; AValue: integer);
385		procedure SetAsBoolean(index: array of integer; AValue: boolean);
386		procedure SetAsCurrency(index: array of integer; Value: Currency);
387		procedure SetAsInt64(index: array of integer; Value: Int64);
388		procedure SetAsDate(index: array of integer; Value: TDateTime);
389	+	procedure SetAsDateTime(index: array of integer; Value: TDateTime); overload;
390	+	procedure SetAsDateTime(index: array of integer; aValue: TDateTime; aTimeZoneID: TFBTimeZoneID); overload;
391	+	procedure SetAsDateTime(index: array of integer; aValue: TDateTime; aTimeZone: AnsiString); overload;
392	+	procedure SetAsTime(index: array of integer; Value: TDateTime); overload;
393	+	procedure SetAsTime(index: array of integer; aValue: TDateTime; OnDate: TDateTime; aTimeZoneID: TFBTimeZoneID); overload;
394	+	procedure SetAsTime(index: array of integer; aValue: TDateTime; OnDate: TDateTime; aTimeZone: AnsiString); overload;
395	+	procedure SetAsUTCDateTime(index: array of integer; aUTCTime: TDateTime);
396		procedure SetAsLong(index: array of integer; Value: Long);
321	–	procedure SetAsTime(index: array of integer; Value: TDateTime);
322	–	procedure SetAsDateTime(index: array of integer; Value: TDateTime);
397		procedure SetAsDouble(index: array of integer; Value: Double);
398		procedure SetAsFloat(index: array of integer; Value: Float);
399		procedure SetAsShort(index: array of integer; Value: Short);
400		procedure SetAsString(index: array of integer; Value: AnsiString);
401		procedure SetAsVariant(index: array of integer; Value: Variant);
402	+	procedure SetAsBcd(index: array of integer; aValue: tBCD);
403		procedure SetBounds(dim, UpperBound, LowerBound: integer);
404		function GetAttachment: IAttachment;
405		function GetTransaction: ITransaction;
#	Line 395 | Line 470 | type
470		the output of an SQL Statement.
471		}
472
473	+	TIBDateTimeFormats = (dfTimestamp, {SQL TIMESTAMP}
474	+	dfDateTime,   {SQL DATETIME}
475	+	dfTime,      {SQL TIME}
476	+	dfTimestampTZ, {SQL_TIMESTAMP_TZ}
477	+	dfTimeTZ);       {SQLTIME_TZ
478	+
479		{ IColumnMetaData }
480
481		IColumnMetaData = interface
#	Line 411 | Line 492 | type
492		function getScale: integer;
493		function getCharSetID: cardinal;
494		function getCodePage: TSystemCodePage;
495	+	function GetCharSetWidth: integer;
496		function getIsNullable: boolean;
497		function GetSize: cardinal;
498		function GetArrayMetaData: IArrayMetaData; {Valid only for Array SQL Type}
499		function GetBlobMetaData: IBlobMetaData; {Valid only for Blob SQL Type}
500	+	function GetDateTimeStrLength(DateTimeFormat: TIBDateTimeFormats): integer;
501	+	function GetStatement: IStatement;
502	+	function GetTransaction: ITransaction;
503		property Name: AnsiString read GetName;
504		property Size: cardinal read GetSize;
505		property SQLType: cardinal read GetSQLType;
#	Line 456 | Line 541 | type
541
542		ISQLData = interface(IColumnMetaData)
543		['{3f493e31-7e3f-4606-a07c-b210b9e3619d}']
544	+	function GetStrDataLength: short;
545		function GetAsBoolean: boolean;
546		function GetAsCurrency: Currency;
547		function GetAsInt64: Int64;
548	<	function GetAsDateTime: TDateTime;
548	>	function GetAsDateTime: TDateTime; overload;
549	>	procedure GetAsDateTime(var aDateTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID); overload;
550	>	procedure GetAsDateTime(var aDateTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString); overload;
551	>	procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID; OnDate: TDateTime); overload;
552	>	procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString; OnDate: TDateTime); overload;
553	>	procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID); overload;
554	>	procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString); overload;
555	>	function GetAsUTCDateTime: TDateTime;
556		function GetAsDouble: Double;
557		function GetAsFloat: Float;
558		function GetAsLong: Long;
#	Line 472 | Line 565 | type
565		function GetAsBlob: IBlob; overload;
566		function GetAsBlob(BPB: IBPB): IBlob; overload;
567		function GetAsArray: IArray;
568	+	function GetAsBCD: tBCD;
569		property AsDate: TDateTime read GetAsDateTime;
570		property AsBoolean:boolean read GetAsBoolean;
571		property AsTime: TDateTime read GetAsDateTime;
#	Line 489 | Line 583 | type
583		property AsVariant: Variant read GetAsVariant ;
584		property AsBlob: IBlob read GetAsBlob;
585		property AsArray: IArray read GetAsArray;
586	+	property AsBCD: tBCD read GetAsBCD;
587		property IsNull: Boolean read GetIsNull;
588		property Value: Variant read GetAsVariant;
589		end;
#	Line 502 | Line 597 | type
597		IResults = interface
598		['{e836b2bb-93d1-4bbf-a8eb-7ce535de3bb5}']
599		function getCount: integer;
600	+	function GetStatement: IStatement;
601		function GetTransaction: ITransaction;
602		function ByName(Idx: AnsiString): ISQLData;
603		function getSQLData(index: integer): ISQLData;
#	Line 518 | Line 614 | type
614		}
615		IResultSet = interface(IResults)
616		['{0ae4979b-7857-4e8c-8918-ec6f155b51a0}']
617	<	function FetchNext: boolean;
617	>	function FetchNext: boolean; {fetch next record}
618	>	function FetchPrior: boolean; {fetch previous record}
619	>	function FetchFirst:boolean; {fetch first record}
620	>	function FetchLast: boolean; {fetch last record}
621	>	function FetchAbsolute(position: Integer): boolean; {fetch record by its absolute position in result set}
622	>	function FetchRelative(offset: Integer): boolean; {fetch record by position relative to current}
623		function GetCursorName: AnsiString;
624	+	function IsBof: boolean;
625		function IsEof: boolean;
626		procedure Close;
627		end;
628
629		{The ISQLParam interface is used to provide access to each parameter in a
630	<	parametised SQL Statement. It subclasses IColumnMetaData and this part of
529	<	the interface may be used to access information on the expected SQL Type, etc.
530	<
531	<	It also subclasses ISQLData and this part of the interface may be used to access
532	<	current values for each parameter.
533	<
534	<	Otherwise, the interface comprises the Setter Methods and properties used to
630	>	parametised SQL Statement. The interface comprises the Setter Methods and properties used to
631		set the value of each parameter.
632
633		Automatic conversion is provided to and from strings. That is GetAsString and
634		SetAsString are safe to use for sql types other than boolean - provided automatic
635		conversion is possible.
636	+
637	+	ISQLParam is subclassed from the IParamMetaData interface. This interface provides
638	+	access to the parameter metadata. This metadata is mutable and can change after
639	+	a parameter is set to a given value. This is acceptable as long as the parameter
640	+	metadata is type compatible with the underlying column metadata and hence the
641	+	parameter value can be converted by Firebird into a value acceptable by the
642	+	underlying column. The column metadata, which is unmutable, can be obtained
643	+	by the ISQLParam.getColMetadata interface. When a statement is prepared, the
644	+	parameter metadata is always initialised to the column metadata.
645		}
646
647	<	ISQLParam = interface
648	<	['{b22b4578-6d41-4807-a9a9-d2ec8d1d5a14}']
544	<	function GetIndex: integer;
647	>	IParamMetaData = interface
648	>	['{4e148c4e-2d48-4991-a263-f66eca05c6aa}']
649		function GetSQLType: cardinal;
650		function GetSQLTypeName: AnsiString;
651		function getSubtype: integer;
548	–	function getName: AnsiString;
652		function getScale: integer;
653		function getCharSetID: cardinal;
654		function getCodePage: TSystemCodePage;
655		function getIsNullable: boolean;
656		function GetSize: cardinal;
657	+	property SQLType: cardinal read GetSQLType;
658	+	end;
659	+
660	+	ISQLParam = interface(IParamMetaData)
661	+	['{b22b4578-6d41-4807-a9a9-d2ec8d1d5a14}']
662	+	function getColMetadata: IParamMetaData;
663	+	function GetIndex: integer;
664	+	function getName: AnsiString;
665		function GetAsBoolean: boolean;
666		function GetAsCurrency: Currency;
667		function GetAsInt64: Int64;
668	<	function GetAsDateTime: TDateTime;
668	>	function GetAsDateTime: TDateTime; overload;
669	>	procedure GetAsDateTime(var aDateTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID); overload;
670	>	procedure GetAsDateTime(var aDateTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString); overload;
671	>	procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID; OnDate: TDateTime); overload;
672	>	procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString; OnDate: TDateTime); overload;
673	>	procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID); overload;
674	>	procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString); overload;
675	>	function GetAsUTCDateTime: TDateTime;
676		function GetAsDouble: Double;
677		function GetAsFloat: Float;
678		function GetAsLong: Long;
#	Line 566 | Line 684 | type
684		function GetAsVariant: Variant;
685		function GetAsBlob: IBlob;
686		function GetAsArray: IArray;
687	+	function GetAsBCD: tBCD;
688	+	function GetStatement: IStatement;
689	+	function GetTransaction: ITransaction;
690		procedure Clear;
691		function GetModified: boolean;
692		procedure SetAsBoolean(AValue: boolean);
#	Line 573 | Line 694 | type
694		procedure SetAsInt64(aValue: Int64);
695		procedure SetAsDate(aValue: TDateTime);
696		procedure SetAsLong(aValue: Long);
697	<	procedure SetAsTime(aValue: TDateTime);
698	<	procedure SetAsDateTime(aValue: TDateTime);
697	>	procedure SetAsTime(aValue: TDateTime); overload;
698	>	procedure SetAsTime(aValue: TDateTime; OnDate: TDateTime; aTimeZoneID: TFBTimeZoneID); overload;
699	>	procedure SetAsTime(aValue: TDateTime; OnDate: TDateTime; aTimeZone: AnsiString); overload;
700	>	procedure SetAsTime(aValue: TDateTime; aTimeZoneID: TFBTimeZoneID); overload;
701	>	procedure SetAsTime(aValue: TDateTime; aTimeZone: AnsiString); overload;
702	>	procedure SetAsDateTime(aValue: TDateTime); overload;
703	>	procedure SetAsDateTime(aValue: TDateTime; aTimeZoneID: TFBTimeZoneID); overload;
704	>	procedure SetAsDateTime(aValue: TDateTime; aTimeZone: AnsiString); overload;
705	>	procedure SetAsUTCDateTime(aUTCTime: TDateTime);
706		procedure SetAsDouble(aValue: Double);
707		procedure SetAsFloat(aValue: Float);
708		procedure SetAsPointer(aValue: Pointer);
#	Line 586 | Line 714 | type
714		procedure SetAsArray(anArray: IArray);
715		procedure SetAsQuad(aValue: TISC_QUAD);
716		procedure SetCharSetID(aValue: cardinal);
717	+	procedure SetAsBcd(aValue: tBCD);
718		property AsDate: TDateTime read GetAsDateTime write SetAsDate;
719		property AsBoolean:boolean read GetAsBoolean write SetAsBoolean;
720		property AsTime: TDateTime read GetAsDateTime write SetAsTime;
#	Line 602 | Line 731 | type
731		property AsVariant: Variant read GetAsVariant write SetAsVariant;
732		property AsBlob: IBlob read GetAsBlob write SetAsBlob;
733		property AsArray: IArray read GetAsArray write SetAsArray;
734	+	property AsBCD: tBCD read GetAsBCD write SetAsBCD;
735		property AsQuad: TISC_QUAD read GetAsQuad write SetAsQuad;
736		property Value: Variant read GetAsVariant write SetAsVariant;
737		property IsNull: Boolean read GetIsNull write SetIsNull;
738		property IsNullable: Boolean read GetIsNullable;
739		property Modified: Boolean read getModified;
740		property Name: AnsiString read GetName;
611	–	property SQLType: cardinal read GetSQLType;
741		end;
742
743		{
#	Line 622 | Line 751 | type
751		function getSQLParam(index: integer): ISQLParam;
752		function ByName(Idx: AnsiString): ISQLParam ;
753		function GetModified: Boolean;
754	+	function GetHasCaseSensitiveParams: Boolean;
755		property Modified: Boolean read GetModified;
756		property Params[index: integer]: ISQLParam read getSQLParam; default;
757		property Count: integer read getCount;
#	Line 634 | Line 764 | type
764
765		TPerfCounters = array[TPerfStats] of Int64;
766
767	+	{Batch Query Execution Support}
768	+
769	+	TBatchCompletionState = (bcExecuteFailed, bcSuccessNoInfo, bcNoMoreErrors);
770	+
771	+	IBatchCompletion = interface
772	+	['{9bc3d49d-16d9-4606-94e5-ee987103ad92}']
773	+	function getTotalProcessed: cardinal;
774	+	function getState(updateNo: cardinal): TBatchCompletionState;
775	+	function getStatusMessage(updateNo: cardinal): AnsiString;
776	+	function getUpdated: integer;
777	+	function getErrorStatus(var RowNo: integer; var status: IStatus): boolean;
778	+	end;
779	+
780		{The IStatement interface provides access to an SQL Statement once it has been
781		initially prepared. The interface is returned from the IAttachment interface.
782		}
783
784	+	TStatementFlag = (stHasCursor,stRepeatExecute,stScrollable);
785	+	TStatementFlags = set of TStatementFlag;
786	+
787		IStatement = interface
788		['{a260576d-a07d-4a66-b02d-1b72543fd7cf}']
789		function GetMetaData: IMetaData;  {Output Metadata}
#	Line 645 | Line 791 | type
791		function GetPlan: AnsiString;
792		function GetRowsAffected(var SelectCount, InsertCount, UpdateCount, DeleteCount: integer): boolean;
793		function GetSQLStatementType: TIBSQLStatementTypes;
794	+	function GetSQLStatementTypeName: AnsiString;
795		function GetSQLText: AnsiString;
796	+	function GetProcessedSQLText: AnsiString;
797		function GetSQLDialect: integer;
798	+	function GetFlags: TStatementFlags;
799		function IsPrepared: boolean;
800	<	procedure Prepare(aTransaction: ITransaction=nil);
800	>	function HasBatchMode: boolean;
801	>	function IsInBatchMode: boolean;
802	>	procedure Prepare(aTransaction: ITransaction=nil); overload;
803	>	procedure Prepare(CursorName: AnsiString; aTransaction: ITransaction=nil); overload;
804		function Execute(aTransaction: ITransaction=nil): IResults;
805	<	function OpenCursor(aTransaction: ITransaction=nil): IResultSet;
805	>	function OpenCursor(aTransaction: ITransaction=nil): IResultSet; overload;
806	>	function OpenCursor(Scrollable: boolean; aTransaction: ITransaction=nil): IResultSet; overload;
807		function GetAttachment: IAttachment;
808		function GetTransaction: ITransaction;
809		procedure SetRetainInterfaces(aValue: boolean);
810		procedure EnableStatistics(aValue: boolean);
811		function GetPerfStatistics(var stats: TPerfCounters): boolean;
812	+	{IBatch interface support}
813	+	procedure AddToBatch;
814	+	function ExecuteBatch(aTransaction: ITransaction=nil): IBatchCompletion;
815	+	procedure CancelBatch;
816	+	function GetBatchCompletion: IBatchCompletion;
817	+	function GetBatchRowLimit: integer;
818	+	procedure SetBatchRowLimit(aLimit: integer);
819	+	{Stale Reference Check}
820	+	procedure SetStaleReferenceChecks(Enable:boolean); {default true}
821	+	function GetStaleReferenceChecks: boolean;
822	+
823		property MetaData: IMetaData read GetMetaData;
824		property SQLParams: ISQLParams read GetSQLParams;
825		property SQLStatementType: TIBSQLStatementTypes read GetSQLStatementType;
826		end;
827
828	+	ITrInfoItem = interface
829	+	['{41455e1a-f84e-4e26-aff0-1a78e8b69cfe}']
830	+	function getItemType: byte;
831	+	function getSize: integer;
832	+	function getAsString: AnsiString;
833	+	function getAsInteger: int64;
834	+	procedure DecodeTraIsolation(var IsolationType, RecVersion: byte);
835	+	end;
836	+
837	+	{ ITrInformation }
838	+
839	+	ITrInformation = interface
840	+	['{e6ea4a52-c1a1-44ba-9609-c8bcc7cba7b2}']
841	+	function GetCount: integer;
842	+	function GetItem(index: integer): ITrInfoItem;
843	+	function Find(ItemType: byte): ITrInfoItem;
844	+	procedure PrintBuf; {can be used to print buffer in hex for debugging}
845	+	property Count: integer read GetCount;
846	+	property Items[index: integer]: ITrInfoItem read getItem; default;
847	+	end;
848	+
849		{Transaction Parameter Block: (TPB)
850
851		The TPB provides the parameters used when starting a transaction. It is allocated
#	Line 672 | Line 857 | type
857		found in the Interbase 6.0 API Guide.
858		}
859
860	<	ITPBItem = interface(IParameterBlockItem)
860	>	ITPBItem = interface(IParameterBlockItemWithTypeName)
861		['{544c1f2b-7c12-4a87-a4a5-face7ea72671}']
862		end;
863
864	<	ITPB = interface(IParameterBlock<ITPBItem>)
864	>	ITPB = interface(IParameterBlockWithTypeNames<ITPBItem>)
865		['{7369b0ff-defe-437b-81fe-19b211d42d25}']
866	+	function AsText: AnsiString;
867		end;
868
869		{The ITransactionAction interface provides access to a Transaction once it
#	Line 696 | Line 882 | type
882		function getTPB: ITPB;
883		procedure Start(DefaultCompletion: TTransactionCompletion=taCommit);
884		function GetInTransaction: boolean;
885	+	function GetIsReadOnly: boolean;
886	+	function GetTransactionID: integer;
887	+	function GetJournalingActive(attachment: IAttachment): boolean;
888	+	function GetDefaultCompletion: TTransactionCompletion;
889		procedure PrepareForCommit; {Two phase commit - stage 1}
890		procedure Commit(Force: boolean=false);
891		procedure CommitRetaining;
#	Line 704 | Line 894 | type
894		procedure RollbackRetaining;
895		function GetAttachmentCount: integer;
896		function GetAttachment(index: integer): IAttachment;
897	+	function GetTrInformation(Requests: array of byte): ITrInformation; overload;
898	+	function GetTrInformation(Request: byte): ITrInformation; overload;
899	+	function GetTransactionName: AnsiString;
900	+	procedure SetTransactionName(aValue: AnsiString);
901		property InTransaction: boolean read GetInTransaction;
902	+	property TransactionName: AnsiString read GetTransactionName write SetTransactionName;
903		end;
904
905		{ The IEvents Interface is used to handle events from a single database. The
#	Line 742 | Line 937 | type
937		function GetAttachment: IAttachment;
938		end;
939
940	+	TTZTextOptions = (tzOffset,      {Time Zone Rendered as an offset to GMT}
941	+	tzGMT,         {No Time Zone. Time part is always rendered in GMT}
942	+	tzOriginalID); {Time Zone shown as originally entered}
943	+
944	+	{The ITimeZoneServices interface provides access to the time zone database
945	+	used for the attachment. It may be used in support of TIMESTAMP WITH TIME ZONE
946	+	and TIME WITH TIME ZONE data types.}
947	+
948	+	ITimeZoneServices = interface
949	+	['{163821f5-ebef-42b9-ac60-8ac4b5c09954}']
950	+	{utility functions}
951	+	function TimeZoneID2TimeZoneName(aTimeZoneID: TFBTimeZoneID): AnsiString;
952	+	function TimeZoneName2TimeZoneID(aTimeZone: AnsiString): TFBTimeZoneID;
953	+	function LocalTimeToGMT(aLocalTime: TDateTime; aTimeZone: AnsiString): TDateTime; overload;
954	+	function LocalTimeToGMT(aLocalTime: TDateTime; aTimeZoneID: TFBTimeZoneID): TDateTime; overload;
955	+	function GMTToLocalTime(aGMTTime: TDateTime; aTimeZone: AnsiString): TDateTime; overload;
956	+	function GMTToLocalTime(aGMTTime: TDateTime; aTimeZoneID: TFBTimeZoneID): TDateTime; overload;
957	+	function GetEffectiveOffsetMins(aLocalTime: TDateTime; aTimeZone: AnsiString): integer; overload;
958	+	function GetEffectiveOffsetMins(aLocalTime: TDateTime; aTimeZoneID: TFBTimeZoneID): integer; overload;
959	+
960	+	{Time Zone DB Information}
961	+	function UsingRemoteTZDB: boolean;
962	+	procedure SetUseLocalTZDB(useLocalTZDB: boolean);
963	+	function GetLocalTimeZoneName: AnsiString;
964	+	function GetLocalTimeZoneID: TFBTimeZoneID;
965	+	procedure GetTimeZoneInfo(aTimeZone: AnsiString; OnDate: TDateTime;
966	+	var ZoneOffset, DSTOffset, EffectiveOffset: integer);
967	+	{Configurable Options}
968	+	function GetTimeTZDate: TDateTime;
969	+	procedure SetTimeTZDate(aDate: TDateTime);
970	+	function GetTZTextOption: TTZTextOptions;
971	+	procedure SetTZTextOption(aOptionValue: TTZTextOptions);
972	+	end;
973	+
974		{The IDBInformation Interface.
975
976		An IDBInformation interface is returned by the  IAttachment GetDBInformation
#	Line 770 | Line 999 | type
999		function getSize: integer;
1000		procedure getRawBytes(var Buffer);
1001		function getAsString: AnsiString;
1002	<	function getAsInteger: integer;
1002	>	function getAsInteger: int64;
1003		procedure DecodeIDCluster(var ConnectionType: integer; var DBFileName, DBSiteName: AnsiString);
1004		function getAsBytes: TByteArray;
1005		function getAsDateTime: TDateTime;
#	Line 782 | Line 1011 | type
1011		function GetCount: integer;
1012		function GetItem(index: integer): IDBInfoItem;
1013		function Find(ItemType: byte): IDBInfoItem;
1014	<	property AsInteger: integer read getAsInteger;
1014	>	property AsInteger: int64 read getAsInteger;
1015		property AsString: AnsiString read GetAsString;
1016		property Count: integer read GetCount;
1017		property Items[index: integer]: IDBInfoItem read getItem; default;
#	Line 825 | Line 1054 | type
1054		found in the Interbase 6.0 API Guide.
1055		}
1056
1057	<	IDPBItem = interface(IParameterBlockItem)
1057	>	IDPBItem = interface(IParameterBlockItemWithTypeName)
1058		['{123d4ad0-087a-4cd1-a344-1b3d03b30673}']
1059		end;
1060
1061	<	IDPB = interface(IParameterBlock<IDPBItem>)
1062	<	['{e676067b-1cf4-4eba-9256-9724f57e0d16}']
1063	<	end;
1061	>	IDPB = interface(IParameterBlockWithTypeNames<IDPBItem>)
1062	>	['{e676067b-1cf4-4eba-9256-9724f57e0d16}']
1063	>	end;
1064	>
1065	>	{Journaling options. Default is [joReadWriteTransactions,joModifyQueries] }
1066	>
1067	>	TJournalOption = (joReadOnlyTransactions, joReadWriteTransactions,
1068	>	joModifyQueries, joReadOnlyQueries);
1069	>
1070	>	TJournalOptions = set of TJournalOption;
1071
1072		{The IAttachment interface provides access to a Database Connection. It may be
1073		used to:
#	Line 862 | Line 1098 | type
1098
1099		IAttachment = interface
1100		['{466e9b67-9def-4807-b3e7-e08a35e7185c}']
1101	+	function getFirebirdAPI: IFirebirdAPI;
1102		function getDPB: IDPB;
1103		function AllocateBPB: IBPB;
1104		function AllocateDIRB: IDIRB;
#	Line 869 | Line 1106 | type
1106		procedure Disconnect(Force: boolean=false);
1107		function IsConnected: boolean;
1108		procedure DropDatabase;
1109	<	function StartTransaction(TPB: array of byte; DefaultCompletion: TTransactionCompletion=taCommit): ITransaction; overload;
1110	<	function StartTransaction(TPB: ITPB; DefaultCompletion: TTransactionCompletion=taCommit): ITransaction; overload;
1109	>	function StartTransaction(TPB: array of byte;
1110	>	DefaultCompletion: TTransactionCompletion=taCommit;
1111	>	aName: AnsiString=''): ITransaction; overload;
1112	>	function StartTransaction(TPB: ITPB;
1113	>	DefaultCompletion: TTransactionCompletion=taCommit;
1114	>	aName: AnsiString=''): ITransaction; overload;
1115		procedure ExecImmediate(transaction: ITransaction; sql: AnsiString; SQLDialect: integer); overload;
1116		procedure ExecImmediate(TPB: array of byte; sql: AnsiString; SQLDialect: integer); overload;
1117		procedure ExecImmediate(transaction: ITransaction; sql: AnsiString); overload;
#	Line 879 | Line 1120 | type
1120		function ExecuteSQL(transaction: ITransaction; sql: AnsiString; SQLDialect: integer; params: array of const): IResults; overload;
1121		function ExecuteSQL(TPB: array of byte; sql: AnsiString; params: array of const): IResults; overload;
1122		function ExecuteSQL(transaction: ITransaction; sql: AnsiString; params: array of const): IResults; overload;
882	–	function OpenCursor(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer): IResultSet; overload;
1123		function OpenCursor(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer;
1124	+	Scrollable: boolean=false): IResultSet; overload;
1125	+	function OpenCursor(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer;
1126	+	params: array of const): IResultSet; overload;
1127	+	function OpenCursor(transaction: ITransaction; sql: AnsiString; Scrollable: boolean=false): IResultSet; overload;
1128	+	function OpenCursor(transaction: ITransaction; sql: AnsiString; Scrollable: boolean;
1129		params: array of const): IResultSet; overload;
885	–	function OpenCursor(transaction: ITransaction; sql: AnsiString): IResultSet; overload;
1130		function OpenCursor(transaction: ITransaction; sql: AnsiString;
1131		params: array of const): IResultSet; overload;
1132	<	function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer): IResultSet; overload;
1132	>	function OpenCursor(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer; Scrollable: boolean;
1133	>	params: array of const): IResultSet; overload;
1134	>	function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer;
1135	>	Scrollable: boolean=false): IResultSet; overload;
1136		function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer;
1137		params: array of const): IResultSet; overload;
1138	<	function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString): IResultSet; overload;
1138	>	function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer; Scrollable: boolean;
1139	>	params: array of const): IResultSet; overload;
1140	>	function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString; Scrollable: boolean=false): IResultSet; overload;
1141		function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString;
1142		params: array of const): IResultSet; overload;
1143	<	function OpenCursorAtStart(sql: AnsiString): IResultSet; overload;
1143	>	function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString; Scrollable: boolean;
1144	>	params: array of const): IResultSet; overload;
1145	>	function OpenCursorAtStart(sql: AnsiString; Scrollable: boolean=false): IResultSet; overload;
1146	>	function OpenCursorAtStart(sql: AnsiString; Scrollable: boolean;
1147	>	params: array of const): IResultSet; overload;
1148		function OpenCursorAtStart(sql: AnsiString;
1149		params: array of const): IResultSet; overload;
1150	<	function Prepare(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer): IStatement; overload;
1151	<	function Prepare(transaction: ITransaction; sql: AnsiString): IStatement; overload;
1150	>	function Prepare(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer; CursorName: AnsiString=''): IStatement; overload;
1151	>	function Prepare(transaction: ITransaction; sql: AnsiString; CursorName: AnsiString=''): IStatement; overload;
1152		function PrepareWithNamedParameters(transaction: ITransaction; sql: AnsiString;
1153	<	aSQLDialect: integer; GenerateParamNames: boolean=false): IStatement; overload;
1153	>	aSQLDialect: integer; GenerateParamNames: boolean=false;
1154	>	CaseSensitiveParams: boolean = false; CursorName: AnsiString=''): IStatement; overload;
1155		function PrepareWithNamedParameters(transaction: ITransaction; sql: AnsiString;
1156	<	GenerateParamNames: boolean=false): IStatement; overload;
1156	>	GenerateParamNames: boolean=false;
1157	>	CaseSensitiveParams: boolean = false; CursorName: AnsiString=''): IStatement; overload;
1158
1159		{Events}
1160		function GetEventHandler(Events: TStrings): IEvents; overload;
#	Line 910 | Line 1165 | type
1165		function CreateBlob(transaction: ITransaction; RelationName, ColumnName: AnsiString; BPB: IBPB=nil): IBlob; overload;
1166		function CreateBlob(transaction: ITransaction; BlobMetaData: IBlobMetaData; BPB: IBPB=nil): IBlob; overload;
1167		function CreateBlob(transaction: ITransaction; SubType: integer; CharSetID: cardinal=0; BPB: IBPB=nil): IBlob; overload;
1168	<	function OpenBlob(transaction: ITransaction; RelationName, ColumnName: AnsiString; BlobID: TISC_QUAD; BPB: IBPB=nil): IBlob;
1168	>	function OpenBlob(transaction: ITransaction; RelationName, ColumnName: AnsiString; BlobID: TISC_QUAD; BPB: IBPB=nil): IBlob; overload;
1169	>	function OpenBlob(transaction: ITransaction; BlobMetaData: IBlobMetaData; BlobID: TISC_QUAD; BPB: IBPB=nil): IBlob;  overload;
1170	>	function GetInlineBlobLimit: integer;
1171	>	procedure SetInlineBlobLimit(limit: integer);
1172
1173		{Array - may use to open existing arrays. However, ISQLData.AsArray is preferred}
1174
1175	<	function OpenArray(transaction: ITransaction; RelationName, ColumnName: AnsiString; ArrayID: TISC_QUAD): IArray;
1175	>	function OpenArray(transaction: ITransaction; RelationName, ColumnName: AnsiString; ArrayID: TISC_QUAD): IArray; overload;
1176	>	function OpenArray(transaction: ITransaction; ArrayMetaData: IArrayMetaData; ArrayID: TISC_QUAD): IArray; overload;
1177		function CreateArray(transaction: ITransaction; RelationName, ColumnName: AnsiString): IArray; overload;
1178		function CreateArray(transaction: ITransaction; ArrayMetaData: IArrayMetaData): IArray; overload;
1179		function CreateArrayMetaData(SQLType: cardinal; tableName: AnsiString; columnName: AnsiString;
#	Line 923 | Line 1182 | type
1182
1183		{Database Information}
1184		function GetSQLDialect: integer;
1185	+	function GetAttachmentID: integer;
1186		function GetBlobMetaData(Transaction: ITransaction; tableName, columnName: AnsiString): IBlobMetaData;
1187		function GetArrayMetaData(Transaction: ITransaction; tableName, columnName: AnsiString): IArrayMetaData;
1188		function GetDBInformation(Requests: array of byte): IDBInformation; overload;
#	Line 934 | Line 1194 | type
1194		function GetSecurityDatabase: AnsiString;
1195		function GetODSMajorVersion: integer;
1196		function GetODSMinorVersion: integer;
1197	+	procedure getFBVersion(version: TStrings);
1198		function HasActivity: boolean;
1199	+	function HasDecFloatSupport: boolean;
1200	+	function HasBatchMode: boolean;
1201	+	function HasScollableCursors: boolean;
1202	+	function HasTable(aTableName: AnsiString): boolean;
1203
1204		{Character Sets}
1205		function HasDefaultCharSet: boolean;
#	Line 946 | Line 1211 | type
1211		function CharSetWidth(CharSetID: integer; var Width: integer): boolean;
1212		procedure RegisterCharSet(CharSetName: AnsiString; CodePage: TSystemCodePage;
1213		AllowReverseLookup:boolean; out CharSetID: integer);
1214	<	end;
1214	>
1215	>	{Time Zone Database}
1216	>	function GetTimeZoneServices: ITimeZoneServices;
1217	>	function HasTimeZoneSupport: boolean;
1218	>
1219	>	{Client side Journaling}
1220	>	function JournalingActive: boolean;
1221	>	function GetJournalOptions: TJournalOptions;
1222	>	function StartJournaling(aJournalLogFile: AnsiString): integer; overload;
1223	>	function StartJournaling(aJournalLogFile: AnsiString; Options: TJournalOptions): integer; overload;
1224	>	procedure StopJournaling(RetainJournal: boolean);
1225	>	end;
1226
1227		TProtocolAll = (TCP, SPX, NamedPipe, Local, inet, inet4, inet6, wnet, xnet, unknownProtocol);
1228		TProtocol = TCP..xnet;
#	Line 963 | Line 1239 | type
1239
1240		}
1241
1242	<	ISPBItem = interface(IParameterBlockItem)
1242	>	ISPBItem = interface(IParameterBlockItemWithTypeName)
1243		['{5d08ae2b-4519-41bd-8b40-97cd451c3f6a}']
1244		end;
1245
1246	<	ISPB = interface(IParameterBlock<ISPBItem>)
1246	>	ISPB = interface(IParameterBlockWithTypeNames<ISPBItem>)
1247		['{2c5836fd-41ed-4426-9b7d-5af580ec2659}']
1248		end;
1249
#	Line 1027 | Line 1303 | type
1303		function getSize: integer;
1304		procedure getRawBytes(var Buffer);
1305		function getAsString: AnsiString;
1306	<	function getAsInteger: integer;
1306	>	function getAsInteger: int64;
1307		function getAsByte: byte;
1308		function CopyTo(stream: TStream; count: integer): integer;
1309		property AsString: AnsiString read getAsString;
1310	<	property AsInteger: integer read getAsInteger;
1310	>	property AsInteger: int64 read getAsInteger;
1311		property AsByte: byte read getAsByte;
1312		end;
1313
#	Line 1054 | Line 1330 | type
1330		property Count: integer read getCount;
1331		end;
1332
1333	+	IFirebirdLibrary = interface;
1334	+
1335		{The IServiceManager interface provides access to a service manager. It can
1336		used to Detach and re-attach to Service Manager, to start services and to
1337		query the service manager.
#	Line 1065 | Line 1343 | type
1343
1344		IServiceManager = interface
1345		['{905b587d-1e1f-4e40-a3f8-a3519f852e48}']
1346	+	function getFirebirdAPI: IFirebirdAPI;
1347		function getSPB: ISPB;
1348		function getServerName: AnsiString;
1349		function getProtocol: TProtocol;
#	Line 1079 | Line 1358 | type
1358		function Query(Request: ISRB; RaiseExceptionOnError: boolean=true) :IServiceQueryResults; overload;
1359		end;
1360
1361	+	{Tbe Firebird Library API used to get information about the Firebird library}
1362	+
1363	+
1364	+	IFirebirdLibrary = interface
1365	+	['{3c04e0a1-12e0-428a-b2e1-bc6fcd97b79b}']
1366	+	function GetHandle: TLibHandle;
1367	+	function GetLibraryName: string;
1368	+	function GetLibraryFilePath: string;
1369	+	function GetFirebirdAPI: IFirebirdAPI;
1370	+	end;
1371	+
1372		{The Firebird API.
1373
1374		This is the base interface and is used to create/open a database connection, to
#	Line 1087 | Line 1377 | type
1377		The interface is returned by the FirebirdAPI function.
1378		}
1379
1380	+	{ IFirebirdAPI }
1381	+
1382		IFirebirdAPI = interface
1383		['{edeee691-c8d3-4dcf-a780-cd7e432821d5}']
1384		{Database connections}
#	Line 1098 | Line 1390 | type
1390		{Start Transaction against multiple databases}
1391		function AllocateTPB: ITPB;
1392		function StartTransaction(Attachments: array of IAttachment;
1393	<	TPB: array of byte; DefaultCompletion: TTransactionCompletion=taCommit): ITransaction; overload;
1393	>	TPB: array of byte; DefaultCompletion: TTransactionCompletion=taCommit;
1394	>	aName: AnsiString=''): ITransaction; overload;
1395		function StartTransaction(Attachments: array of IAttachment;
1396	<	TPB: ITPB; DefaultCompletion: TTransactionCompletion=taCommit): ITransaction; overload;
1396	>	TPB: ITPB; DefaultCompletion: TTransactionCompletion=taCommit;
1397	>	aName: AnsiString=''): ITransaction; overload;
1398
1399		{Service Manager}
1400		function HasServiceAPI: boolean;
#	Line 1110 | Line 1404 | type
1404
1405		{Information}
1406		function GetStatus: IStatus;
1113	–	function GetLibraryName: string;
1407		function HasRollbackRetaining: boolean;
1408		function IsEmbeddedServer: boolean;
1409		function GetImplementationVersion: AnsiString;
1410	+	function GetClientMajor: integer;
1411	+	function GetClientMinor: integer;
1412	+	function HasDecFloatSupport: boolean;
1413	+	function HasLocalTZDB: boolean;
1414	+	function HasTimeZoneSupport: boolean;
1415	+	function HasExtendedTZSupport: boolean;
1416
1417		{Firebird 3 API}
1418		function HasMasterIntf: boolean;
1419	<	function GetIMaster: TObject;
1419	>	function GetIMaster: TObject;  deprecated 'Use FirebirdAPI.QueryInterface and FBClientLib.pas IFBIMasterProvider instead';
1420	>	function GetFBLibrary: IFirebirdLibrary;
1421		end;
1422
1423		type
#	Line 1152 | Line 1452 | type
1452		{IB Client Exceptions}
1453		EIBClientError = class(EIBError);
1454
1455	<	{IBError is used internally and by IBX to throw an EIBClientError}
1456	<
1157	<	procedure IBError(ErrMess: TIBClientError; const Args: array of const);
1455	>	{Used to explicitly report a Batch Buffer overflow}
1456	>	EIBBatchBufferOverflow = class(EIBError);
1457
1458		{The Firebird API function is used to access the IFirebirdAPI interface.
1459
#	Line 1165 | Line 1464 | procedure IBError(ErrMess: TIBClientErro
1464		function FirebirdAPI: IFirebirdAPI;
1465
1466		{IBX support functions. Probably best ignored i.e. always used the FirebirdAPI
1467	<	functino to load the library and check if it's loaded.}
1467	>	function to load the library and check if it's loaded.}
1468
1469		function TryIBLoad: Boolean;
1470		procedure CheckIBLoaded;
1471
1472	+	{If you want to explicitly load the Firebird library from a
1473	+	non-default location then use this function and its GetFirebirdAPI function
1474	+	to get the API.}
1475	+
1476	+	function LoadFBLibrary(aLibPathName: string): IFirebirdLibrary;
1477	+
1478	+	{$if not declared(NULL)} {Needed for Delphi}
1479	+	function Null: Variant;       // Null standard constant
1480	+	{$define NEEDNULLFUNCTION}
1481	+	{$ifend}
1482	+
1483		implementation
1484
1485	<	uses FBClientAPI
1485	>	uses FBClientAPI {$if not declared(NULL)}, Variants {$ifend}
1486		{$IFDEF USELEGACYFIREBIRDAPI}, FB25ClientAPI {$ENDIF}
1487		{$IFDEF USEFIREBIRD3API}, FB30ClientAPI {$ENDIF};
1488
1489	<	var FFirebirdAPI: IFirebirdAPI;
1489	>	var FDefaultFBLibrary: IFirebirdLibrary;
1490	>
1491	>	type
1492	>
1493	>	{ TFBLibrary }
1494	>
1495	>	TFBLibraryImpl = class(TFBLibrary)
1496	>	protected
1497	>	function GetFirebird3API: IFirebirdAPI; override;
1498	>	function GetLegacyFirebirdAPI: IFirebirdAPI; override;
1499	>	end;
1500	>
1501	>	function TFBLibraryImpl.GetFirebird3API: IFirebirdAPI;
1502	>	begin
1503	>	{$IFDEF USEFIREBIRD3API}
1504	>	Result := TFB30ClientAPI.Create(self);
1505	>	{$ELSE}
1506	>	Result := nil;
1507	>	{$ENDIF}
1508	>	end;
1509	>
1510	>	function TFBLibraryImpl.GetLegacyFirebirdAPI: IFirebirdAPI;
1511	>	begin
1512	>	{$IFDEF USELEGACYFIREBIRDAPI}
1513	>	Result := TFB25ClientAPI.Create(self);
1514	>	{$ELSE}
1515	>	Result := nil;
1516	>	{$ENDIF}
1517	>	end;
1518
1519		function FirebirdAPI: IFirebirdAPI;
1520		begin
1521	<	if FFirebirdAPI = nil then
1521	>	if FDefaultFBLibrary = nil then
1522		CheckIBLoaded;
1523	<	Result := FFirebirdAPI;
1523	>	Result := FDefaultFBLibrary.GetFirebirdAPI;
1524		end;
1525
1526		function TryIBLoad: Boolean;
1527	+	var fblib: IFirebirdLibrary;
1528		begin
1529	<	Result := FFirebirdAPI <> nil;
1529	>	Result := FDefaultFBLibrary <> nil;
1530		try
1192	–	{$IFDEF USEFIREBIRD3API}
1193	–	if not Result then
1194	–	begin
1195	–	FFirebirdAPI := TFB30ClientAPI.Create;
1196	–	Result := FFirebirdAPI.HasMasterIntf;
1197	–	end;
1198	–	{$ENDIF}
1199	–	{$IFDEF USELEGACYFIREBIRDAPI}
1531		if not Result then
1532		begin
1533	<	FFirebirdAPI := nil;
1534	<	FFirebirdAPI := TFB25ClientAPI.Create;
1535	<	Result := true;
1536	<	end;
1206	<	{$ENDIF}
1207	<	if Result and not (FFirebirdAPI as TFBClientAPI).IsLibraryLoaded then
1208	<	begin
1209	<	Result := false;
1210	<	FFirebirdAPI := nil;
1533	>	fblib := TFBLibraryImpl.Create;
1534	>	if (fblib <> nil) and (fblib.GetFirebirdAPI <> nil) then
1535	>	FDefaultFBLibrary := fblib;
1536	>	Result := FDefaultFBLibrary <> nil;
1537		end;
1538		except
1539		SysUtils.showexception(ExceptObject,ExceptAddr);
#	Line 1221 | Line 1547 | begin
1547		IBError(ibxeInterBaseMissing, [nil]);
1548		end;
1549
1550	+	function LoadFBLibrary(aLibPathName: string): IFirebirdLibrary;
1551	+	var fblib: IFirebirdLibrary;
1552	+	begin
1553	+	if trim(aLibPathName) = '' then
1554	+	begin
1555	+	CheckIBLoaded;
1556	+	Result := FDefaultFBLibrary;
1557	+	end
1558	+	else
1559	+	begin
1560	+	fblib := TFBLibraryImpl.GetFBLibrary(aLibPathName);
1561	+	if (fblib = nil) or (fblib.GetFirebirdAPI = nil) then
1562	+	IBError(ibxeInterBaseMissing, [nil]);
1563	+	Result := fblib;
1564	+	end;
1565	+	end;
1566	+
1567		{ EIBError }
1568
1569		constructor EIBError.Create(ASQLCode: Long; Msg: AnsiString);
#	Line 1244 | Line 1587 | begin
1587		FIBErrorCode := AIBErrorCode;
1588		end;
1589
1590	<	procedure IBError(ErrMess: TIBClientError; const Args: array of const);
1591	<	begin
1592	<	raise EIBClientError.Create(Ord(ErrMess),
1593	<	Format(GetErrorMessage(ErrMess), Args));
1594	<	end;
1590	>	{$ifdef NEEDNULLFUNCTION}
1591	>	function Null: Variant;       // Null standard constant
1592	>	begin
1593	>	VarClearProc(TVarData(Result));
1594	>	TVarData(Result).VType := varnull;
1595	>	end;
1596	>	{$endif}
1597
1598		initialization
1599	<	FFirebirdAPI := nil;
1599	>	FDefaultFBLibrary := nil;
1600
1601		finalization
1602	<	FFirebirdAPI := nil;
1602	>	FDefaultFBLibrary := nil;
1603
1604		end.
1605

Diff Legend

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