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 109 by tony, Thu Jan 18 14:37:48 2018 UTC vs.
Revision 349 by tony, Mon Oct 18 08:39:40 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 = 0;
137	>	FBIntf_Minor = 3;
138		FBIntf_Release = 2;
139	<	FBIntf_Version = '1.0.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 525 | Line 621 | type
621		end;
622
623		{The ISQLParam interface is used to provide access to each parameter in a
624	<	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
624	>	parametised SQL Statement. The interface comprises the Setter Methods and properties used to
625		set the value of each parameter.
626
627		Automatic conversion is provided to and from strings. That is GetAsString and
628		SetAsString are safe to use for sql types other than boolean - provided automatic
629		conversion is possible.
630	+
631	+	ISQLParam is subclassed from the IParamMetaData interface. This interface provides
632	+	access to the parameter metadata. This metadata is mutable and can change after
633	+	a parameter is set to a given value. This is acceptable as long as the parameter
634	+	metadata is type compatible with the underlying column metadata and hence the
635	+	parameter value can be converted by Firebird into a value acceptable by the
636	+	underlying column. The column metadata, which is unmutable, can be obtained
637	+	by the ISQLParam.getColMetadata interface. When a statement is prepared, the
638	+	parameter metadata is always initialised to the column metadata.
639		}
640
641	<	ISQLParam = interface
642	<	['{b22b4578-6d41-4807-a9a9-d2ec8d1d5a14}']
544	<	function GetIndex: integer;
641	>	IParamMetaData = interface
642	>	['{4e148c4e-2d48-4991-a263-f66eca05c6aa}']
643		function GetSQLType: cardinal;
644		function GetSQLTypeName: AnsiString;
645		function getSubtype: integer;
548	–	function getName: AnsiString;
646		function getScale: integer;
647		function getCharSetID: cardinal;
648		function getCodePage: TSystemCodePage;
649		function getIsNullable: boolean;
650		function GetSize: cardinal;
651	+	property SQLType: cardinal read GetSQLType;
652	+	end;
653	+
654	+	ISQLParam = interface(IParamMetaData)
655	+	['{b22b4578-6d41-4807-a9a9-d2ec8d1d5a14}']
656	+	function getColMetadata: IParamMetaData;
657	+	function GetIndex: integer;
658	+	function getName: AnsiString;
659		function GetAsBoolean: boolean;
660		function GetAsCurrency: Currency;
661		function GetAsInt64: Int64;
662	<	function GetAsDateTime: TDateTime;
662	>	function GetAsDateTime: TDateTime; overload;
663	>	procedure GetAsDateTime(var aDateTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID); overload;
664	>	procedure GetAsDateTime(var aDateTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString); overload;
665	>	procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID; OnDate: TDateTime); overload;
666	>	procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString; OnDate: TDateTime); overload;
667	>	procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID); overload;
668	>	procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString); overload;
669	>	function GetAsUTCDateTime: TDateTime;
670		function GetAsDouble: Double;
671		function GetAsFloat: Float;
672		function GetAsLong: Long;
#	Line 566 | Line 678 | type
678		function GetAsVariant: Variant;
679		function GetAsBlob: IBlob;
680		function GetAsArray: IArray;
681	+	function GetAsBCD: tBCD;
682	+	function GetStatement: IStatement;
683	+	function GetTransaction: ITransaction;
684		procedure Clear;
685		function GetModified: boolean;
686		procedure SetAsBoolean(AValue: boolean);
#	Line 573 | Line 688 | type
688		procedure SetAsInt64(aValue: Int64);
689		procedure SetAsDate(aValue: TDateTime);
690		procedure SetAsLong(aValue: Long);
691	<	procedure SetAsTime(aValue: TDateTime);
692	<	procedure SetAsDateTime(aValue: TDateTime);
691	>	procedure SetAsTime(aValue: TDateTime); overload;
692	>	procedure SetAsTime(aValue: TDateTime; OnDate: TDateTime; aTimeZoneID: TFBTimeZoneID); overload;
693	>	procedure SetAsTime(aValue: TDateTime; OnDate: TDateTime; aTimeZone: AnsiString); overload;
694	>	procedure SetAsTime(aValue: TDateTime; aTimeZoneID: TFBTimeZoneID); overload;
695	>	procedure SetAsTime(aValue: TDateTime; aTimeZone: AnsiString); overload;
696	>	procedure SetAsDateTime(aValue: TDateTime); overload;
697	>	procedure SetAsDateTime(aValue: TDateTime; aTimeZoneID: TFBTimeZoneID); overload;
698	>	procedure SetAsDateTime(aValue: TDateTime; aTimeZone: AnsiString); overload;
699	>	procedure SetAsUTCDateTime(aUTCTime: TDateTime);
700		procedure SetAsDouble(aValue: Double);
701		procedure SetAsFloat(aValue: Float);
702		procedure SetAsPointer(aValue: Pointer);
#	Line 586 | Line 708 | type
708		procedure SetAsArray(anArray: IArray);
709		procedure SetAsQuad(aValue: TISC_QUAD);
710		procedure SetCharSetID(aValue: cardinal);
711	+	procedure SetAsBcd(aValue: tBCD);
712		property AsDate: TDateTime read GetAsDateTime write SetAsDate;
713		property AsBoolean:boolean read GetAsBoolean write SetAsBoolean;
714		property AsTime: TDateTime read GetAsDateTime write SetAsTime;
#	Line 602 | Line 725 | type
725		property AsVariant: Variant read GetAsVariant write SetAsVariant;
726		property AsBlob: IBlob read GetAsBlob write SetAsBlob;
727		property AsArray: IArray read GetAsArray write SetAsArray;
728	+	property AsBCD: tBCD read GetAsBCD write SetAsBCD;
729		property AsQuad: TISC_QUAD read GetAsQuad write SetAsQuad;
730		property Value: Variant read GetAsVariant write SetAsVariant;
731		property IsNull: Boolean read GetIsNull write SetIsNull;
732		property IsNullable: Boolean read GetIsNullable;
733		property Modified: Boolean read getModified;
734		property Name: AnsiString read GetName;
611	–	property SQLType: cardinal read GetSQLType;
735		end;
736
737		{
#	Line 622 | Line 745 | type
745		function getSQLParam(index: integer): ISQLParam;
746		function ByName(Idx: AnsiString): ISQLParam ;
747		function GetModified: Boolean;
748	+	function GetHasCaseSensitiveParams: Boolean;
749		property Modified: Boolean read GetModified;
750		property Params[index: integer]: ISQLParam read getSQLParam; default;
751		property Count: integer read getCount;
#	Line 632 | Line 756 | type
756		psRealTime, psUserTime, psBuffers,
757		psReads, psWrites, psFetches,psDeltaMemory);
758
759	<	TPerfCounters = array[TPerfStats] of comp;
759	>	TPerfCounters = array[TPerfStats] of Int64;
760	>
761	>	{Batch Query Execution Support}
762	>
763	>	TBatchCompletionState = (bcExecuteFailed, bcSuccessNoInfo, bcNoMoreErrors);
764	>
765	>	IBatchCompletion = interface
766	>	['{9bc3d49d-16d9-4606-94e5-ee987103ad92}']
767	>	function getTotalProcessed: cardinal;
768	>	function getState(updateNo: cardinal): TBatchCompletionState;
769	>	function getStatusMessage(updateNo: cardinal): AnsiString;
770	>	function getUpdated: integer;
771	>	function getErrorStatus(var RowNo: integer; var status: IStatus): boolean;
772	>	end;
773
774		{The IStatement interface provides access to an SQL Statement once it has been
775		initially prepared. The interface is returned from the IAttachment interface.
#	Line 645 | Line 782 | type
782		function GetPlan: AnsiString;
783		function GetRowsAffected(var SelectCount, InsertCount, UpdateCount, DeleteCount: integer): boolean;
784		function GetSQLStatementType: TIBSQLStatementTypes;
785	+	function GetSQLStatementTypeName: AnsiString;
786		function GetSQLText: AnsiString;
787	+	function GetProcessedSQLText: AnsiString;
788		function GetSQLDialect: integer;
789		function IsPrepared: boolean;
790	+	function HasBatchMode: boolean;
791	+	function IsInBatchMode: boolean;
792		procedure Prepare(aTransaction: ITransaction=nil);
793		function Execute(aTransaction: ITransaction=nil): IResults;
794		function OpenCursor(aTransaction: ITransaction=nil): IResultSet;
#	Line 656 | Line 797 | type
797		procedure SetRetainInterfaces(aValue: boolean);
798		procedure EnableStatistics(aValue: boolean);
799		function GetPerfStatistics(var stats: TPerfCounters): boolean;
800	+	{IBatch interface support}
801	+	procedure AddToBatch;
802	+	function ExecuteBatch(aTransaction: ITransaction=nil): IBatchCompletion;
803	+	procedure CancelBatch;
804	+	function GetBatchCompletion: IBatchCompletion;
805	+	function GetBatchRowLimit: integer;
806	+	procedure SetBatchRowLimit(aLimit: integer);
807	+	{Stale Reference Check}
808	+	procedure SetStaleReferenceChecks(Enable:boolean); {default true}
809	+	function GetStaleReferenceChecks: boolean;
810	+
811		property MetaData: IMetaData read GetMetaData;
812		property SQLParams: ISQLParams read GetSQLParams;
813		property SQLStatementType: TIBSQLStatementTypes read GetSQLStatementType;
#	Line 672 | Line 824 | type
824		found in the Interbase 6.0 API Guide.
825		}
826
827	<	ITPBItem = interface(IParameterBlockItem)
827	>	ITPBItem = interface(IParameterBlockItemWithTypeName)
828		['{544c1f2b-7c12-4a87-a4a5-face7ea72671}']
829	+	function getParamTypeName: AnsiString;
830		end;
831
832	<	ITPB = interface(IParameterBlock<ITPBItem>)
832	>	ITPB = interface(IParameterBlockWithTypeNames<ITPBItem>)
833		['{7369b0ff-defe-437b-81fe-19b211d42d25}']
834		end;
835
#	Line 742 | Line 895 | type
895		function GetAttachment: IAttachment;
896		end;
897
898	+	TTZTextOptions = (tzOffset,      {Time Zone Rendered as an offset to GMT}
899	+	tzGMT,         {No Time Zone. Time part is always rendered in GMT}
900	+	tzOriginalID); {Time Zone shown as originally entered}
901	+
902	+	{The ITimeZoneServices interface provides access to the time zone database
903	+	used for the attachment. It may be used in support of TIMESTAMP WITH TIME ZONE
904	+	and TIME WITH TIME ZONE data types.}
905	+
906	+	ITimeZoneServices = interface
907	+	['{163821f5-ebef-42b9-ac60-8ac4b5c09954}']
908	+	{utility functions}
909	+	function TimeZoneID2TimeZoneName(aTimeZoneID: TFBTimeZoneID): AnsiString;
910	+	function TimeZoneName2TimeZoneID(aTimeZone: AnsiString): TFBTimeZoneID;
911	+	function LocalTimeToGMT(aLocalTime: TDateTime; aTimeZone: AnsiString): TDateTime; overload;
912	+	function LocalTimeToGMT(aLocalTime: TDateTime; aTimeZoneID: TFBTimeZoneID): TDateTime; overload;
913	+	function GMTToLocalTime(aGMTTime: TDateTime; aTimeZone: AnsiString): TDateTime; overload;
914	+	function GMTToLocalTime(aGMTTime: TDateTime; aTimeZoneID: TFBTimeZoneID): TDateTime; overload;
915	+	function GetEffectiveOffsetMins(aLocalTime: TDateTime; aTimeZone: AnsiString): integer; overload;
916	+	function GetEffectiveOffsetMins(aLocalTime: TDateTime; aTimeZoneID: TFBTimeZoneID): integer; overload;
917	+
918	+	{Time Zone DB Information}
919	+	function UsingRemoteTZDB: boolean;
920	+	procedure SetUseLocalTZDB(useLocalTZDB: boolean);
921	+	function GetLocalTimeZoneName: AnsiString;
922	+	function GetLocalTimeZoneID: TFBTimeZoneID;
923	+	procedure GetTimeZoneInfo(aTimeZone: AnsiString; OnDate: TDateTime;
924	+	var ZoneOffset, DSTOffset, EffectiveOffset: integer);
925	+	{Configurable Options}
926	+	function GetTimeTZDate: TDateTime;
927	+	procedure SetTimeTZDate(aDate: TDateTime);
928	+	function GetTZTextOption: TTZTextOptions;
929	+	procedure SetTZTextOption(aOptionValue: TTZTextOptions);
930	+	end;
931	+
932		{The IDBInformation Interface.
933
934		An IDBInformation interface is returned by the  IAttachment GetDBInformation
#	Line 770 | Line 957 | type
957		function getSize: integer;
958		procedure getRawBytes(var Buffer);
959		function getAsString: AnsiString;
960	<	function getAsInteger: integer;
960	>	function getAsInteger: int64;
961		procedure DecodeIDCluster(var ConnectionType: integer; var DBFileName, DBSiteName: AnsiString);
962		function getAsBytes: TByteArray;
963	+	function getAsDateTime: TDateTime;
964		procedure DecodeVersionString(var Version: byte; var VersionString: AnsiString);
965		function getOperationCounts: TDBOperationCounts;
966		procedure DecodeUserNames(UserNames: TStrings);
#	Line 781 | Line 969 | type
969		function GetCount: integer;
970		function GetItem(index: integer): IDBInfoItem;
971		function Find(ItemType: byte): IDBInfoItem;
972	<	property AsInteger: integer read getAsInteger;
972	>	property AsInteger: int64 read getAsInteger;
973		property AsString: AnsiString read GetAsString;
974		property Count: integer read GetCount;
975		property Items[index: integer]: IDBInfoItem read getItem; default;
#	Line 799 | Line 987 | type
987		property Items[index: integer]: IDBInfoItem read getItem; default;
988		end;
989
990	+	{The Database Information Request Block is used to pass requests for
991	+	database information where at least one item requested has a parameter.
992	+	At present, this is only fb_info_page_contents which has a single
993	+	integer parameter.}
994	+
995	+	IDIRBItem = interface(IParameterBlockItem)
996	+	['{d34a7511-8435-4a24-81a7-5103d218d234}']
997	+	end;
998	+
999	+	IDIRB = interface(IParameterBlock<IDIRBItem>)
1000	+	['{1010e5ac-0a8f-403b-a302-91625e9d9579}']
1001	+	end;
1002	+
1003	+
1004		{The Database Parameter Block (DPB).
1005
1006		The DPB provides the parameters used when connecting to a database. It is allocated
#	Line 810 | Line 1012 | type
1012		found in the Interbase 6.0 API Guide.
1013		}
1014
1015	<	IDPBItem = interface(IParameterBlockItem)
1015	>	IDPBItem = interface(IParameterBlockItemWithTypeName)
1016		['{123d4ad0-087a-4cd1-a344-1b3d03b30673}']
1017		end;
1018
1019	<	IDPB = interface(IParameterBlock<IDPBItem>)
1020	<	['{e676067b-1cf4-4eba-9256-9724f57e0d16}']
1021	<	end;
1019	>	IDPB = interface(IParameterBlockWithTypeNames<IDPBItem>)
1020	>	['{e676067b-1cf4-4eba-9256-9724f57e0d16}']
1021	>	end;
1022
1023		{The IAttachment interface provides access to a Database Connection. It may be
1024		used to:
#	Line 847 | Line 1049 | type
1049
1050		IAttachment = interface
1051		['{466e9b67-9def-4807-b3e7-e08a35e7185c}']
1052	+	function getFirebirdAPI: IFirebirdAPI;
1053		function getDPB: IDPB;
1054		function AllocateBPB: IBPB;
1055	+	function AllocateDIRB: IDIRB;
1056		procedure Connect;
1057		procedure Disconnect(Force: boolean=false);
1058		function IsConnected: boolean;
#	Line 881 | Line 1085 | type
1085		function Prepare(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer): IStatement; overload;
1086		function Prepare(transaction: ITransaction; sql: AnsiString): IStatement; overload;
1087		function PrepareWithNamedParameters(transaction: ITransaction; sql: AnsiString;
1088	<	aSQLDialect: integer; GenerateParamNames: boolean=false): IStatement; overload;
1088	>	aSQLDialect: integer; GenerateParamNames: boolean=false;
1089	>	CaseSensitiveParams: boolean = false): IStatement; overload;
1090		function PrepareWithNamedParameters(transaction: ITransaction; sql: AnsiString;
1091	<	GenerateParamNames: boolean=false): IStatement; overload;
1091	>	GenerateParamNames: boolean=false;
1092	>	CaseSensitiveParams: boolean = false): IStatement; overload;
1093
1094		{Events}
1095		function GetEventHandler(Events: TStrings): IEvents; overload;
#	Line 894 | Line 1100 | type
1100		function CreateBlob(transaction: ITransaction; RelationName, ColumnName: AnsiString; BPB: IBPB=nil): IBlob; overload;
1101		function CreateBlob(transaction: ITransaction; BlobMetaData: IBlobMetaData; BPB: IBPB=nil): IBlob; overload;
1102		function CreateBlob(transaction: ITransaction; SubType: integer; CharSetID: cardinal=0; BPB: IBPB=nil): IBlob; overload;
1103	<	function OpenBlob(transaction: ITransaction; RelationName, ColumnName: AnsiString; BlobID: TISC_QUAD; BPB: IBPB=nil): IBlob;
1103	>	function OpenBlob(transaction: ITransaction; RelationName, ColumnName: AnsiString; BlobID: TISC_QUAD; BPB: IBPB=nil): IBlob; overload;
1104	>	function OpenBlob(transaction: ITransaction; BlobMetaData: IBlobMetaData; BlobID: TISC_QUAD; BPB: IBPB=nil): IBlob;  overload;
1105	>	function GetInlineBlobLimit: integer;
1106	>	procedure SetInlineBlobLimit(limit: integer);
1107
1108		{Array - may use to open existing arrays. However, ISQLData.AsArray is preferred}
1109
1110	<	function OpenArray(transaction: ITransaction; RelationName, ColumnName: AnsiString; ArrayID: TISC_QUAD): IArray;
1110	>	function OpenArray(transaction: ITransaction; RelationName, ColumnName: AnsiString; ArrayID: TISC_QUAD): IArray; overload;
1111	>	function OpenArray(transaction: ITransaction; ArrayMetaData: IArrayMetaData; ArrayID: TISC_QUAD): IArray; overload;
1112		function CreateArray(transaction: ITransaction; RelationName, ColumnName: AnsiString): IArray; overload;
1113		function CreateArray(transaction: ITransaction; ArrayMetaData: IArrayMetaData): IArray; overload;
1114		function CreateArrayMetaData(SQLType: cardinal; tableName: AnsiString; columnName: AnsiString;
#	Line 911 | Line 1121 | type
1121		function GetArrayMetaData(Transaction: ITransaction; tableName, columnName: AnsiString): IArrayMetaData;
1122		function GetDBInformation(Requests: array of byte): IDBInformation; overload;
1123		function GetDBInformation(Request: byte): IDBInformation; overload;
1124	+	function GetDBInformation(Requests: IDIRB): IDBInformation; overload;
1125	+	function GetConnectString: AnsiString;
1126	+	function GetRemoteProtocol: AnsiString;
1127	+	function GetAuthenticationMethod: AnsiString;
1128	+	function GetSecurityDatabase: AnsiString;
1129	+	function GetODSMajorVersion: integer;
1130	+	function GetODSMinorVersion: integer;
1131	+	procedure getFBVersion(version: TStrings);
1132		function HasActivity: boolean;
1133	+	function HasDecFloatSupport: boolean;
1134	+	function HasBatchMode: boolean;
1135
1136		{Character Sets}
1137		function HasDefaultCharSet: boolean;
#	Line 923 | Line 1143 | type
1143		function CharSetWidth(CharSetID: integer; var Width: integer): boolean;
1144		procedure RegisterCharSet(CharSetName: AnsiString; CodePage: TSystemCodePage;
1145		AllowReverseLookup:boolean; out CharSetID: integer);
926	–	end;
1146
1147	<	TProtocol = (TCP, SPX, NamedPipe, Local);
1147	>	{Time Zone Database}
1148	>	function GetTimeZoneServices: ITimeZoneServices;
1149	>	function HasTimeZoneSupport: boolean;
1150	>	end;
1151	>
1152	>	TProtocolAll = (TCP, SPX, NamedPipe, Local, inet, inet4, inet6, wnet, xnet, unknownProtocol);
1153	>	TProtocol = TCP..xnet;
1154
1155		{Service Parameter Block (SPB).
1156
#	Line 939 | Line 1164 | type
1164
1165		}
1166
1167	<	ISPBItem = interface(IParameterBlockItem)
1167	>	ISPBItem = interface(IParameterBlockItemWithTypeName)
1168		['{5d08ae2b-4519-41bd-8b40-97cd451c3f6a}']
1169		end;
1170
1171	<	ISPB = interface(IParameterBlock<ISPBItem>)
1171	>	ISPB = interface(IParameterBlockWithTypeNames<ISPBItem>)
1172		['{2c5836fd-41ed-4426-9b7d-5af580ec2659}']
1173		end;
1174
#	Line 1003 | Line 1228 | type
1228		function getSize: integer;
1229		procedure getRawBytes(var Buffer);
1230		function getAsString: AnsiString;
1231	<	function getAsInteger: integer;
1231	>	function getAsInteger: int64;
1232		function getAsByte: byte;
1233		function CopyTo(stream: TStream; count: integer): integer;
1234		property AsString: AnsiString read getAsString;
1235	<	property AsInteger: integer read getAsInteger;
1235	>	property AsInteger: int64 read getAsInteger;
1236		property AsByte: byte read getAsByte;
1237		end;
1238
#	Line 1030 | Line 1255 | type
1255		property Count: integer read getCount;
1256		end;
1257
1258	+	IFirebirdLibrary = interface;
1259	+
1260		{The IServiceManager interface provides access to a service manager. It can
1261		used to Detach and re-attach to Service Manager, to start services and to
1262		query the service manager.
#	Line 1041 | Line 1268 | type
1268
1269		IServiceManager = interface
1270		['{905b587d-1e1f-4e40-a3f8-a3519f852e48}']
1271	+	function getFirebirdAPI: IFirebirdAPI;
1272		function getSPB: ISPB;
1273		function getServerName: AnsiString;
1274	+	function getProtocol: TProtocol;
1275	+	function getPortNo: AnsiString;
1276		procedure Attach;
1277		procedure Detach(Force: boolean=false);
1278		function IsAttached: boolean;
1279		function AllocateSRB: ISRB;
1280		function AllocateSQPB: ISQPB;
1281	<	procedure Start(Request: ISRB);
1282	<	function Query(SQPB: ISQPB; Request: ISRB) :IServiceQueryResults; overload;
1283	<	function Query(Request: ISRB) :IServiceQueryResults; overload;
1281	>	function Start(Request: ISRB; RaiseExceptionOnError: boolean=true): boolean;
1282	>	function Query(SQPB: ISQPB; Request: ISRB; RaiseExceptionOnError: boolean=true) :IServiceQueryResults; overload;
1283	>	function Query(Request: ISRB; RaiseExceptionOnError: boolean=true) :IServiceQueryResults; overload;
1284	>	end;
1285	>
1286	>	{Tbe Firebird Library API used to get information about the Firebird library}
1287	>
1288	>
1289	>	IFirebirdLibrary = interface
1290	>	['{3c04e0a1-12e0-428a-b2e1-bc6fcd97b79b}']
1291	>	function GetHandle: TLibHandle;
1292	>	function GetLibraryName: string;
1293	>	function GetLibraryFilePath: string;
1294	>	function GetFirebirdAPI: IFirebirdAPI;
1295		end;
1296
1297		{The Firebird API.
#	Line 1061 | Line 1302 | type
1302		The interface is returned by the FirebirdAPI function.
1303		}
1304
1305	+	{ IFirebirdAPI }
1306	+
1307		IFirebirdAPI = interface
1308		['{edeee691-c8d3-4dcf-a780-cd7e432821d5}']
1309		{Database connections}
#	Line 1079 | Line 1322 | type
1322		{Service Manager}
1323		function HasServiceAPI: boolean;
1324		function AllocateSPB: ISPB;
1325	<	function GetServiceManager(ServerName: AnsiString; Protocol: TProtocol; SPB: ISPB): IServiceManager;
1325	>	function GetServiceManager(ServerName: AnsiString; Protocol: TProtocol; SPB: ISPB): IServiceManager; overload;
1326	>	function GetServiceManager(ServerName: AnsiString; Port: AnsiString; Protocol: TProtocol; SPB: ISPB): IServiceManager; overload;
1327
1328		{Information}
1329		function GetStatus: IStatus;
1086	–	function GetLibraryName: string;
1330		function HasRollbackRetaining: boolean;
1331		function IsEmbeddedServer: boolean;
1332		function GetImplementationVersion: AnsiString;
1333	+	function GetClientMajor: integer;
1334	+	function GetClientMinor: integer;
1335	+	function HasDecFloatSupport: boolean;
1336	+	function HasLocalTZDB: boolean;
1337	+	function HasTimeZoneSupport: boolean;
1338	+	function HasExtendedTZSupport: boolean;
1339
1340		{Firebird 3 API}
1341		function HasMasterIntf: boolean;
1342	<	function GetIMaster: TObject;
1342	>	function GetIMaster: TObject;  deprecated 'Use FirebirdAPI.QueryInterface and FBClientLib.pas IFBIMasterProvider instead';
1343	>	function GetFBLibrary: IFirebirdLibrary;
1344		end;
1345
1346		type
#	Line 1125 | Line 1375 | type
1375		{IB Client Exceptions}
1376		EIBClientError = class(EIBError);
1377
1378	<	{IBError is used internally and by IBX to throw an EIBClientError}
1379	<
1130	<	procedure IBError(ErrMess: TIBClientError; const Args: array of const);
1378	>	{Used to explicitly report a Batch Buffer overflow}
1379	>	EIBBatchBufferOverflow = class(EIBError);
1380
1381		{The Firebird API function is used to access the IFirebirdAPI interface.
1382
#	Line 1138 | Line 1387 | procedure IBError(ErrMess: TIBClientErro
1387		function FirebirdAPI: IFirebirdAPI;
1388
1389		{IBX support functions. Probably best ignored i.e. always used the FirebirdAPI
1390	<	functino to load the library and check if it's loaded.}
1390	>	function to load the library and check if it's loaded.}
1391
1392		function TryIBLoad: Boolean;
1393		procedure CheckIBLoaded;
1394
1395	+	{If you want to explicitly load the Firebird library from a
1396	+	non-default location then use this function and its GetFirebirdAPI function
1397	+	to get the API.}
1398	+
1399	+	function LoadFBLibrary(aLibPathName: string): IFirebirdLibrary;
1400	+
1401	+
1402		implementation
1403
1404		uses FBClientAPI
1405		{$IFDEF USELEGACYFIREBIRDAPI}, FB25ClientAPI {$ENDIF}
1406		{$IFDEF USEFIREBIRD3API}, FB30ClientAPI {$ENDIF};
1407
1408	<	var FFirebirdAPI: IFirebirdAPI;
1408	>	var FDefaultFBLibrary: IFirebirdLibrary;
1409	>
1410	>	type
1411	>
1412	>	{ TFBLibrary }
1413	>
1414	>	TFBLibraryImpl = class(TFBLibrary)
1415	>	protected
1416	>	function GetFirebird3API: IFirebirdAPI; override;
1417	>	function GetLegacyFirebirdAPI: IFirebirdAPI; override;
1418	>	end;
1419	>
1420	>	function TFBLibraryImpl.GetFirebird3API: IFirebirdAPI;
1421	>	begin
1422	>	{$IFDEF USEFIREBIRD3API}
1423	>	Result := TFB30ClientAPI.Create(self);
1424	>	{$ELSE}
1425	>	Result := nil;
1426	>	{$ENDIF}
1427	>	end;
1428	>
1429	>	function TFBLibraryImpl.GetLegacyFirebirdAPI: IFirebirdAPI;
1430	>	begin
1431	>	{$IFDEF USELEGACYFIREBIRDAPI}
1432	>	Result := TFB25ClientAPI.Create(self);
1433	>	{$ELSE}
1434	>	Result := nil;
1435	>	{$ENDIF}
1436	>	end;
1437
1438		function FirebirdAPI: IFirebirdAPI;
1439		begin
1440	<	if FFirebirdAPI = nil then
1440	>	if FDefaultFBLibrary = nil then
1441		CheckIBLoaded;
1442	<	Result := FFirebirdAPI;
1442	>	Result := FDefaultFBLibrary.GetFirebirdAPI;
1443		end;
1444
1445		function TryIBLoad: Boolean;
1446	+	var fblib: IFirebirdLibrary;
1447		begin
1448	<	Result := FFirebirdAPI <> nil;
1448	>	Result := FDefaultFBLibrary <> nil;
1449		try
1165	–	{$IFDEF USEFIREBIRD3API}
1450		if not Result then
1451		begin
1452	<	FFirebirdAPI := TFB30ClientAPI.Create;
1453	<	Result := FFirebirdAPI.HasMasterIntf;
1454	<	end;
1455	<	{$ENDIF}
1172	<	{$IFDEF USELEGACYFIREBIRDAPI}
1173	<	if not Result then
1174	<	begin
1175	<	FFirebirdAPI := nil;
1176	<	FFirebirdAPI := TFB25ClientAPI.Create;
1177	<	Result := true;
1178	<	end;
1179	<	{$ENDIF}
1180	<	if Result and not (FFirebirdAPI as TFBClientAPI).IsLibraryLoaded then
1181	<	begin
1182	<	Result := false;
1183	<	FFirebirdAPI := nil;
1452	>	fblib := TFBLibraryImpl.Create;
1453	>	if (fblib <> nil) and (fblib.GetFirebirdAPI <> nil) then
1454	>	FDefaultFBLibrary := fblib;
1455	>	Result := FDefaultFBLibrary <> nil;
1456		end;
1457		except
1458		SysUtils.showexception(ExceptObject,ExceptAddr);
#	Line 1194 | Line 1466 | begin
1466		IBError(ibxeInterBaseMissing, [nil]);
1467		end;
1468
1469	+	function LoadFBLibrary(aLibPathName: string): IFirebirdLibrary;
1470	+	var fblib: IFirebirdLibrary;
1471	+	begin
1472	+	if trim(aLibPathName) = '' then
1473	+	begin
1474	+	CheckIBLoaded;
1475	+	Result := FDefaultFBLibrary;
1476	+	end
1477	+	else
1478	+	begin
1479	+	fblib := TFBLibraryImpl.GetFBLibrary(aLibPathName);
1480	+	if (fblib = nil) or (fblib.GetFirebirdAPI = nil) then
1481	+	IBError(ibxeInterBaseMissing, [nil]);
1482	+	Result := fblib;
1483	+	end;
1484	+	end;
1485	+
1486		{ EIBError }
1487
1488		constructor EIBError.Create(ASQLCode: Long; Msg: AnsiString);
#	Line 1217 | Line 1506 | begin
1506		FIBErrorCode := AIBErrorCode;
1507		end;
1508
1220	–	procedure IBError(ErrMess: TIBClientError; const Args: array of const);
1221	–	begin
1222	–	raise EIBClientError.Create(Ord(ErrMess),
1223	–	Format(GetErrorMessage(ErrMess), Args));
1224	–	end;
1509
1510		initialization
1511	<	FFirebirdAPI := nil;
1511	>	FDefaultFBLibrary := nil;
1512
1513	+	finalization
1514	+	FDefaultFBLibrary := nil;
1515
1516		end.
1517

Diff Legend

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