ViewVC Help

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

root/public/ibx/branches/udr/client/IB.pas

Comparing:
ibx/trunk/fbintf/IB.pas (file contents), Revision 310 by tony, Tue Jul 21 08:20:03 2020 UTC vs.
ibx/branches/udr/client/IB.pas (file contents), Revision 381 by tony, Sat Jan 15 00:06:22 2022 UTC

#	Line 129 | Line 129 | uses
129		Classes,
130		{$IFDEF WINDOWS}Windows, {$ENDIF}
131		{$IFDEF FPC} Dynlibs, {$ENDIF}
132	<	SysUtils, DB, FBMessages, IBExternals;
132	>	SysUtils, DB, FBMessages, IBExternals, FmtBcd;
133
134		const
135		{Interface version information}
136		FBIntf_Major = 1;
137	<	FBIntf_Minor = 1;
138	<	FBIntf_Release = 6;
139	<	FBIntf_Version = '1.1.6';
137	>	FBIntf_Minor = 4;
138	>	FBIntf_Release = 0;
139	>	FBIntf_Version = '1.4.0';
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 165 | 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 215 | Line 241 | type
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 IFBNumeric interface provides a managed type for Fixed Point integers
252	+	used to hold Firebird Numeric(m,n) types}
253	+
254	+	IFBNumeric = interface
255	+	['{8bdccfe9-d552-446b-bd82-844ca264455d}']
256	+	function getRawValue: Int64;
257	+	function getScale: integer;
258	+	function AdjustScaleTo(aNewScale: integer): IFBNumeric;
259	+	function getAsString: AnsiString;
260	+	function getAsDouble: double;
261	+	function getAsBCD: TBCD;
262	+	function getAsInt64: Int64; {scaled}
263	+	function getAsInteger: integer; {scaled - may be truncated}
264	+	function getAsSmallInt: SmallInt; {scaled - may be truncated}
265	+	function getAsCurrency: Currency;
266	+	end;
267	+
268		{The IParameterBlock interface provides the template for all parameter
269		block interfaces}
270
#	Line 234 | Line 278 | type
278		property Items[index: integer]: _IItem read getItems; default;
279		end;
280
281	+	IParameterBlockWithTypeNames<_IItem> = interface(IParameterBlock<_IItem>)
282	+	function AddByTypeName(ParamTypeName: AnsiString): _IItem;
283	+	function GetDPBParamTypeName(ParamType: byte): Ansistring; deprecated 'Use Get ParamTypeName';
284	+	function GetParamTypeName(ParamType: byte): Ansistring;
285	+	end;
286	+
287		{IParameterBlockItem is not used on its own but instead provides a base type for
288		different parameter block items }
289
#	Line 251 | Line 301 | type
301		property AsInteger: integer read getAsInteger write SetAsInteger;
302		end;
303
304	+	IParameterBlockItemWithTypeName = interface(IParameterBlockItem)
305	+	function getParamTypeName: AnsiString;
306	+	end;
307
308		{The IStatus interface provides access to error information, if any, returned
309		by the last API call. It can also be used to customise the error message
#	Line 265 | Line 318 | type
318
319		TIBDataBaseErrorMessages   = set of TIBDataBaseErrorMessage;
320
321	+	TStatusCode = long;
322	+
323		IStatus = interface
324		['{34167722-af38-4831-b08a-93162d58ede3}']
325	<	function GetIBErrorCode: Long;
326	<	function Getsqlcode: Long;
325	>	function GetIBErrorCode: TStatusCode;
326	>	function Getsqlcode: TStatusCode;
327		function GetMessage: AnsiString;
328		function CheckStatusVector(ErrorCodes: array of TFBStatusCode): Boolean;
329		function GetIBDataBaseErrorMessages: TIBDataBaseErrorMessages;
#	Line 330 | Line 385 | type
385		function GetAsBoolean(index: array of integer): boolean;
386		function GetAsCurrency(index: array of integer): Currency;
387		function GetAsInt64(index: array of integer): Int64;
388	<	function GetAsDateTime(index: array of integer): TDateTime;
388	>	function GetAsDateTime(index: array of integer): TDateTime; overload;
389	>	procedure GetAsDateTime(index: array of integer; var aDateTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID); overload;
390	>	procedure GetAsDateTime(index: array of integer; var aDateTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString); overload;
391	>	procedure GetAsTime(index: array of integer; var aTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID; OnDate: TDateTime); overload;
392	>	procedure GetAsTime(index: array of integer; var aTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString; OnDate: TDateTime); overload;
393	>	function GetAsUTCDateTime(index: array of integer): TDateTime;
394		function GetAsDouble(index: array of integer): Double;
395		function GetAsFloat(index: array of integer): Float;
396		function GetAsLong(index: array of integer): Long;
397		function GetAsShort(index: array of integer): Short;
398		function GetAsString(index: array of integer): AnsiString;
399		function GetAsVariant(index: array of integer): Variant;
400	+	function GetAsBCD(index: array of integer): tBCD;
401		procedure SetAsInteger(index: array of integer; AValue: integer);
402		procedure SetAsBoolean(index: array of integer; AValue: boolean);
403		procedure SetAsCurrency(index: array of integer; Value: Currency);
404		procedure SetAsInt64(index: array of integer; Value: Int64);
405		procedure SetAsDate(index: array of integer; Value: TDateTime);
406	+	procedure SetAsDateTime(index: array of integer; Value: TDateTime); overload;
407	+	procedure SetAsDateTime(index: array of integer; aValue: TDateTime; aTimeZoneID: TFBTimeZoneID); overload;
408	+	procedure SetAsDateTime(index: array of integer; aValue: TDateTime; aTimeZone: AnsiString); overload;
409	+	procedure SetAsTime(index: array of integer; Value: TDateTime); overload;
410	+	procedure SetAsTime(index: array of integer; aValue: TDateTime; OnDate: TDateTime; aTimeZoneID: TFBTimeZoneID); overload;
411	+	procedure SetAsTime(index: array of integer; aValue: TDateTime; OnDate: TDateTime; aTimeZone: AnsiString); overload;
412	+	procedure SetAsUTCDateTime(index: array of integer; aUTCTime: TDateTime);
413		procedure SetAsLong(index: array of integer; Value: Long);
346	–	procedure SetAsTime(index: array of integer; Value: TDateTime);
347	–	procedure SetAsDateTime(index: array of integer; Value: TDateTime);
414		procedure SetAsDouble(index: array of integer; Value: Double);
415		procedure SetAsFloat(index: array of integer; Value: Float);
416		procedure SetAsShort(index: array of integer; Value: Short);
417		procedure SetAsString(index: array of integer; Value: AnsiString);
418		procedure SetAsVariant(index: array of integer; Value: Variant);
419	+	procedure SetAsBcd(index: array of integer; aValue: tBCD);
420		procedure SetBounds(dim, UpperBound, LowerBound: integer);
421		function GetAttachment: IAttachment;
422		function GetTransaction: ITransaction;
#	Line 422 | Line 489 | type
489
490		TIBDateTimeFormats = (dfTimestamp, {SQL TIMESTAMP}
491		dfDateTime,   {SQL DATETIME}
492	<	dfTime);      {SQL TIME}
492	>	dfTime,      {SQL TIME}
493	>	dfTimestampTZ, {SQL_TIMESTAMP_TZ}
494	>	dfTimeTZ);       {SQLTIME_TZ
495
496		{ IColumnMetaData }
497
#	Line 448 | Line 517 | type
517		function GetDateTimeStrLength(DateTimeFormat: TIBDateTimeFormats): integer;
518		function GetStatement: IStatement;
519		function GetTransaction: ITransaction;
520	+	function GetAttachment: IAttachment;
521		property Name: AnsiString read GetName;
522		property Size: cardinal read GetSize;
523		property SQLType: cardinal read GetSQLType;
#	Line 493 | Line 563 | type
563		function GetAsBoolean: boolean;
564		function GetAsCurrency: Currency;
565		function GetAsInt64: Int64;
566	<	function GetAsDateTime: TDateTime;
566	>	function GetAsDateTime: TDateTime; overload;
567	>	procedure GetAsDateTime(var aDateTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID); overload;
568	>	procedure GetAsDateTime(var aDateTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString); overload;
569	>	procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID; OnDate: TDateTime); overload;
570	>	procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString; OnDate: TDateTime); overload;
571	>	procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID); overload;
572	>	procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString); overload;
573	>	function GetAsUTCDateTime: TDateTime;
574		function GetAsDouble: Double;
575		function GetAsFloat: Float;
576		function GetAsLong: Long;
#	Line 506 | Line 583 | type
583		function GetAsBlob: IBlob; overload;
584		function GetAsBlob(BPB: IBPB): IBlob; overload;
585		function GetAsArray: IArray;
586	+	function GetAsBCD: tBCD;
587	+	function GetAsNumeric: IFBNumeric;
588		property AsDate: TDateTime read GetAsDateTime;
589		property AsBoolean:boolean read GetAsBoolean;
590		property AsTime: TDateTime read GetAsDateTime;
#	Line 523 | Line 602 | type
602		property AsVariant: Variant read GetAsVariant ;
603		property AsBlob: IBlob read GetAsBlob;
604		property AsArray: IArray read GetAsArray;
605	+	property AsBCD: tBCD read GetAsBCD;
606	+	property AsNumeric: IFBNumeric read GetAsNumeric;
607		property IsNull: Boolean read GetIsNull;
608		property Value: Variant read GetAsVariant;
609		end;
#	Line 538 | Line 619 | type
619		function getCount: integer;
620		function GetStatement: IStatement;
621		function GetTransaction: ITransaction;
622	+	function GetAttachment: IAttachment;
623		function ByName(Idx: AnsiString): ISQLData;
624		function getSQLData(index: integer): ISQLData;
625		procedure GetData(index: integer; var IsNull:boolean; var len: short; var data: PByte);
#	Line 553 | Line 635 | type
635		}
636		IResultSet = interface(IResults)
637		['{0ae4979b-7857-4e8c-8918-ec6f155b51a0}']
638	<	function FetchNext: boolean;
638	>	function FetchNext: boolean; {fetch next record}
639	>	function FetchPrior: boolean; {fetch previous record}
640	>	function FetchFirst:boolean; {fetch first record}
641	>	function FetchLast: boolean; {fetch last record}
642	>	function FetchAbsolute(position: Integer): boolean; {fetch record by its absolute position in result set}
643	>	function FetchRelative(offset: Integer): boolean; {fetch record by position relative to current}
644		function GetCursorName: AnsiString;
645	+	function IsBof: boolean;
646		function IsEof: boolean;
647		procedure Close;
648		end;
649
650		{The ISQLParam interface is used to provide access to each parameter in a
651	<	parametised SQL Statement. It subclasses IColumnMetaData and this part of
564	<	the interface may be used to access information on the expected SQL Type, etc.
565	<
566	<	It also subclasses ISQLData and this part of the interface may be used to access
567	<	current values for each parameter.
568	<
569	<	Otherwise, the interface comprises the Setter Methods and properties used to
651	>	parametised SQL Statement. The interface comprises the Setter Methods and properties used to
652		set the value of each parameter.
653
654		Automatic conversion is provided to and from strings. That is GetAsString and
655		SetAsString are safe to use for sql types other than boolean - provided automatic
656		conversion is possible.
657	+
658	+	ISQLParam is subclassed from the IParamMetaData interface. This interface provides
659	+	access to the parameter metadata. This metadata is mutable and can change after
660	+	a parameter is set to a given value. This is acceptable as long as the parameter
661	+	metadata is type compatible with the underlying column metadata and hence the
662	+	parameter value can be converted by Firebird into a value acceptable by the
663	+	underlying column. The column metadata, which is unmutable, can be obtained
664	+	by the ISQLParam.getColMetadata interface. When a statement is prepared, the
665	+	parameter metadata is always initialised to the column metadata.
666		}
667
668	<	ISQLParam = interface
669	<	['{b22b4578-6d41-4807-a9a9-d2ec8d1d5a14}']
579	<	function GetIndex: integer;
668	>	IParamMetaData = interface
669	>	['{4e148c4e-2d48-4991-a263-f66eca05c6aa}']
670		function GetSQLType: cardinal;
671		function GetSQLTypeName: AnsiString;
672		function getSubtype: integer;
583	–	function getName: AnsiString;
673		function getScale: integer;
674		function getCharSetID: cardinal;
675		function getCodePage: TSystemCodePage;
676		function getIsNullable: boolean;
677		function GetSize: cardinal;
678	+	property SQLType: cardinal read GetSQLType;
679	+	end;
680	+
681	+	ISQLParam = interface(IParamMetaData)
682	+	['{b22b4578-6d41-4807-a9a9-d2ec8d1d5a14}']
683	+	function getColMetadata: IParamMetaData;
684	+	function GetStatement: IStatement;
685	+	function GetTransaction: ITransaction;
686	+	function GetAttachment: IAttachment;
687	+	function GetIndex: integer;
688	+	function getName: AnsiString;
689		function GetAsBoolean: boolean;
690		function GetAsCurrency: Currency;
691		function GetAsInt64: Int64;
692	<	function GetAsDateTime: TDateTime;
692	>	function GetAsDateTime: TDateTime; overload;
693	>	procedure GetAsDateTime(var aDateTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID); overload;
694	>	procedure GetAsDateTime(var aDateTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString); overload;
695	>	procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID; OnDate: TDateTime); overload;
696	>	procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString; OnDate: TDateTime); overload;
697	>	procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID); overload;
698	>	procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString); overload;
699	>	function GetAsUTCDateTime: TDateTime;
700		function GetAsDouble: Double;
701		function GetAsFloat: Float;
702		function GetAsLong: Long;
#	Line 601 | Line 708 | type
708		function GetAsVariant: Variant;
709		function GetAsBlob: IBlob;
710		function GetAsArray: IArray;
711	+	function GetAsBCD: tBCD;
712	+	function GetAsNumeric: IFBNumeric;
713		procedure Clear;
714		function GetModified: boolean;
715		procedure SetAsBoolean(AValue: boolean);
#	Line 608 | Line 717 | type
717		procedure SetAsInt64(aValue: Int64);
718		procedure SetAsDate(aValue: TDateTime);
719		procedure SetAsLong(aValue: Long);
720	<	procedure SetAsTime(aValue: TDateTime);
721	<	procedure SetAsDateTime(aValue: TDateTime);
720	>	procedure SetAsTime(aValue: TDateTime); overload;
721	>	procedure SetAsTime(aValue: TDateTime; OnDate: TDateTime; aTimeZoneID: TFBTimeZoneID); overload;
722	>	procedure SetAsTime(aValue: TDateTime; OnDate: TDateTime; aTimeZone: AnsiString); overload;
723	>	procedure SetAsTime(aValue: TDateTime; aTimeZoneID: TFBTimeZoneID); overload;
724	>	procedure SetAsTime(aValue: TDateTime; aTimeZone: AnsiString); overload;
725	>	procedure SetAsDateTime(aValue: TDateTime); overload;
726	>	procedure SetAsDateTime(aValue: TDateTime; aTimeZoneID: TFBTimeZoneID); overload;
727	>	procedure SetAsDateTime(aValue: TDateTime; aTimeZone: AnsiString); overload;
728	>	procedure SetAsUTCDateTime(aUTCTime: TDateTime);
729		procedure SetAsDouble(aValue: Double);
730		procedure SetAsFloat(aValue: Float);
731		procedure SetAsPointer(aValue: Pointer);
#	Line 621 | Line 737 | type
737		procedure SetAsArray(anArray: IArray);
738		procedure SetAsQuad(aValue: TISC_QUAD);
739		procedure SetCharSetID(aValue: cardinal);
740	+	procedure SetAsBcd(aValue: tBCD);
741	+	procedure SetAsNumeric(Value: IFBNumeric);
742		property AsDate: TDateTime read GetAsDateTime write SetAsDate;
743		property AsBoolean:boolean read GetAsBoolean write SetAsBoolean;
744		property AsTime: TDateTime read GetAsDateTime write SetAsTime;
#	Line 637 | Line 755 | type
755		property AsVariant: Variant read GetAsVariant write SetAsVariant;
756		property AsBlob: IBlob read GetAsBlob write SetAsBlob;
757		property AsArray: IArray read GetAsArray write SetAsArray;
758	+	property AsBCD: tBCD read GetAsBCD write SetAsBCD;
759	+	property AsNumeric: IFBNumeric read GetAsNumeric write SetAsNumeric;
760		property AsQuad: TISC_QUAD read GetAsQuad write SetAsQuad;
761		property Value: Variant read GetAsVariant write SetAsVariant;
762		property IsNull: Boolean read GetIsNull write SetIsNull;
763		property IsNullable: Boolean read GetIsNullable;
764		property Modified: Boolean read getModified;
765		property Name: AnsiString read GetName;
646	–	property SQLType: cardinal read GetSQLType;
766		end;
767
768		{
#	Line 658 | Line 777 | type
777		function ByName(Idx: AnsiString): ISQLParam ;
778		function GetModified: Boolean;
779		function GetHasCaseSensitiveParams: Boolean;
780	+	function GetStatement: IStatement;
781	+	function GetTransaction: ITransaction;
782	+	function GetAttachment: IAttachment;
783	+	procedure Clear;
784		property Modified: Boolean read GetModified;
785		property Params[index: integer]: ISQLParam read getSQLParam; default;
786		property Count: integer read getCount;
#	Line 670 | Line 793 | type
793
794		TPerfCounters = array[TPerfStats] of Int64;
795
796	+	{Batch Query Execution Support}
797	+
798	+	TBatchCompletionState = (bcExecuteFailed, bcSuccessNoInfo, bcNoMoreErrors);
799	+
800	+	IBatchCompletion = interface
801	+	['{9bc3d49d-16d9-4606-94e5-ee987103ad92}']
802	+	function getTotalProcessed: cardinal;
803	+	function getState(updateNo: cardinal): TBatchCompletionState;
804	+	function getStatusMessage(updateNo: cardinal): AnsiString;
805	+	function getUpdated: integer;
806	+	function getErrorStatus(var RowNo: integer; var status: IStatus): boolean;
807	+	end;
808	+
809		{The IStatement interface provides access to an SQL Statement once it has been
810		initially prepared. The interface is returned from the IAttachment interface.
811		}
812
813	+	TStatementFlag = (stHasCursor,stRepeatExecute,stScrollable);
814	+	TStatementFlags = set of TStatementFlag;
815	+
816		IStatement = interface
817		['{a260576d-a07d-4a66-b02d-1b72543fd7cf}']
818		function GetMetaData: IMetaData;  {Output Metadata}
#	Line 681 | Line 820 | type
820		function GetPlan: AnsiString;
821		function GetRowsAffected(var SelectCount, InsertCount, UpdateCount, DeleteCount: integer): boolean;
822		function GetSQLStatementType: TIBSQLStatementTypes;
823	+	function GetSQLStatementTypeName: AnsiString;
824		function GetSQLText: AnsiString;
825		function GetProcessedSQLText: AnsiString;
826		function GetSQLDialect: integer;
827	+	function GetFlags: TStatementFlags;
828		function IsPrepared: boolean;
829	<	procedure Prepare(aTransaction: ITransaction=nil);
829	>	function HasBatchMode: boolean;
830	>	function IsInBatchMode: boolean;
831	>	procedure Prepare(aTransaction: ITransaction=nil); overload;
832	>	procedure Prepare(CursorName: AnsiString; aTransaction: ITransaction=nil); overload;
833		function Execute(aTransaction: ITransaction=nil): IResults;
834	<	function OpenCursor(aTransaction: ITransaction=nil): IResultSet;
834	>	function OpenCursor(aTransaction: ITransaction=nil): IResultSet; overload;
835	>	function OpenCursor(Scrollable: boolean; aTransaction: ITransaction=nil): IResultSet; overload;
836		function GetAttachment: IAttachment;
837		function GetTransaction: ITransaction;
838		procedure SetRetainInterfaces(aValue: boolean);
839		procedure EnableStatistics(aValue: boolean);
840		function GetPerfStatistics(var stats: TPerfCounters): boolean;
841	+	{IBatch interface support}
842	+	procedure AddToBatch;
843	+	function ExecuteBatch(aTransaction: ITransaction=nil): IBatchCompletion;
844	+	procedure CancelBatch;
845	+	function GetBatchCompletion: IBatchCompletion;
846	+	function GetBatchRowLimit: integer;
847	+	procedure SetBatchRowLimit(aLimit: integer);
848	+	{Stale Reference Check}
849	+	procedure SetStaleReferenceChecks(Enable:boolean); {default true}
850	+	function GetStaleReferenceChecks: boolean;
851	+
852		property MetaData: IMetaData read GetMetaData;
853		property SQLParams: ISQLParams read GetSQLParams;
854		property SQLStatementType: TIBSQLStatementTypes read GetSQLStatementType;
855		end;
856
857	+	ITrInfoItem = interface
858	+	['{41455e1a-f84e-4e26-aff0-1a78e8b69cfe}']
859	+	function getItemType: byte;
860	+	function getSize: integer;
861	+	function getAsString: AnsiString;
862	+	function getAsInteger: int64;
863	+	procedure DecodeTraIsolation(var IsolationType, RecVersion: byte);
864	+	end;
865	+
866	+	{ ITrInformation }
867	+
868	+	ITrInformation = interface
869	+	['{e6ea4a52-c1a1-44ba-9609-c8bcc7cba7b2}']
870	+	function GetCount: integer;
871	+	function GetItem(index: integer): ITrInfoItem;
872	+	function Find(ItemType: byte): ITrInfoItem;
873	+	procedure PrintBuf; {can be used to print buffer in hex for debugging}
874	+	property Count: integer read GetCount;
875	+	property Items[index: integer]: ITrInfoItem read getItem; default;
876	+	end;
877	+
878		{Transaction Parameter Block: (TPB)
879
880		The TPB provides the parameters used when starting a transaction. It is allocated
#	Line 709 | Line 886 | type
886		found in the Interbase 6.0 API Guide.
887		}
888
889	<	ITPBItem = interface(IParameterBlockItem)
889	>	ITPBItem = interface(IParameterBlockItemWithTypeName)
890		['{544c1f2b-7c12-4a87-a4a5-face7ea72671}']
891		end;
892
893	<	ITPB = interface(IParameterBlock<ITPBItem>)
893	>	ITPB = interface(IParameterBlockWithTypeNames<ITPBItem>)
894		['{7369b0ff-defe-437b-81fe-19b211d42d25}']
895	+	function AsText: AnsiString;
896		end;
897
898		{The ITransactionAction interface provides access to a Transaction once it
#	Line 733 | Line 911 | type
911		function getTPB: ITPB;
912		procedure Start(DefaultCompletion: TTransactionCompletion=taCommit);
913		function GetInTransaction: boolean;
914	+	function GetIsReadOnly: boolean;
915	+	function GetTransactionID: integer;
916	+	function GetJournalingActive(attachment: IAttachment): boolean;
917	+	function GetDefaultCompletion: TTransactionCompletion;
918		procedure PrepareForCommit; {Two phase commit - stage 1}
919		procedure Commit(Force: boolean=false);
920		procedure CommitRetaining;
#	Line 741 | Line 923 | type
923		procedure RollbackRetaining;
924		function GetAttachmentCount: integer;
925		function GetAttachment(index: integer): IAttachment;
926	+	function GetTrInformation(Requests: array of byte): ITrInformation; overload;
927	+	function GetTrInformation(Request: byte): ITrInformation; overload;
928	+	function GetTransactionName: AnsiString;
929	+	procedure SetTransactionName(aValue: AnsiString);
930		property InTransaction: boolean read GetInTransaction;
931	+	property TransactionName: AnsiString read GetTransactionName write SetTransactionName;
932		end;
933
934		{ The IEvents Interface is used to handle events from a single database. The
#	Line 771 | Line 958 | type
958		['{6a0be233-ed08-4524-889c-2e45d0c20e5f}']
959		procedure GetEvents(EventNames: TStrings);
960		procedure SetEvents(EventNames: TStrings); overload;
961	<	procedure SetEvents(EventName: AnsiString); overload;
961	>	procedure SetEvents(EventName: string); overload;
962		procedure Cancel;
963		function ExtractEventCounts: TEventCounts;
964		procedure WaitForEvent;
#	Line 779 | Line 966 | type
966		function GetAttachment: IAttachment;
967		end;
968
969	+	TTZTextOptions = (tzOffset,      {Time Zone Rendered as an offset to GMT}
970	+	tzGMT,         {No Time Zone. Time part is always rendered in GMT}
971	+	tzOriginalID); {Time Zone shown as originally entered}
972	+
973	+	{The ITimeZoneServices interface provides access to the time zone database
974	+	used for the attachment. It may be used in support of TIMESTAMP WITH TIME ZONE
975	+	and TIME WITH TIME ZONE data types.}
976	+
977	+	ITimeZoneServices = interface
978	+	['{163821f5-ebef-42b9-ac60-8ac4b5c09954}']
979	+	{utility functions}
980	+	function TimeZoneID2TimeZoneName(aTimeZoneID: TFBTimeZoneID): AnsiString;
981	+	function TimeZoneName2TimeZoneID(aTimeZone: AnsiString): TFBTimeZoneID;
982	+	function LocalTimeToGMT(aLocalTime: TDateTime; aTimeZone: AnsiString): TDateTime; overload;
983	+	function LocalTimeToGMT(aLocalTime: TDateTime; aTimeZoneID: TFBTimeZoneID): TDateTime; overload;
984	+	function GMTToLocalTime(aGMTTime: TDateTime; aTimeZone: AnsiString): TDateTime; overload;
985	+	function GMTToLocalTime(aGMTTime: TDateTime; aTimeZoneID: TFBTimeZoneID): TDateTime; overload;
986	+	function GetEffectiveOffsetMins(aLocalTime: TDateTime; aTimeZone: AnsiString): integer; overload;
987	+	function GetEffectiveOffsetMins(aLocalTime: TDateTime; aTimeZoneID: TFBTimeZoneID): integer; overload;
988	+
989	+	{Time Zone DB Information}
990	+	function UsingRemoteTZDB: boolean;
991	+	procedure SetUseLocalTZDB(useLocalTZDB: boolean);
992	+	function GetLocalTimeZoneName: AnsiString;
993	+	function GetLocalTimeZoneID: TFBTimeZoneID;
994	+	procedure GetTimeZoneInfo(aTimeZone: AnsiString; OnDate: TDateTime;
995	+	var ZoneOffset, DSTOffset, EffectiveOffset: integer);
996	+	{Configurable Options}
997	+	function GetTimeTZDate: TDateTime;
998	+	procedure SetTimeTZDate(aDate: TDateTime);
999	+	function GetTZTextOption: TTZTextOptions;
1000	+	procedure SetTZTextOption(aOptionValue: TTZTextOptions);
1001	+	end;
1002	+
1003		{The IDBInformation Interface.
1004
1005		An IDBInformation interface is returned by the  IAttachment GetDBInformation
#	Line 807 | Line 1028 | type
1028		function getSize: integer;
1029		procedure getRawBytes(var Buffer);
1030		function getAsString: AnsiString;
1031	<	function getAsInteger: integer;
1031	>	function getAsInteger: int64;
1032		procedure DecodeIDCluster(var ConnectionType: integer; var DBFileName, DBSiteName: AnsiString);
1033		function getAsBytes: TByteArray;
1034		function getAsDateTime: TDateTime;
#	Line 819 | Line 1040 | type
1040		function GetCount: integer;
1041		function GetItem(index: integer): IDBInfoItem;
1042		function Find(ItemType: byte): IDBInfoItem;
1043	<	property AsInteger: integer read getAsInteger;
1043	>	property AsInteger: int64 read getAsInteger;
1044		property AsString: AnsiString read GetAsString;
1045		property Count: integer read GetCount;
1046		property Items[index: integer]: IDBInfoItem read getItem; default;
#	Line 862 | Line 1083 | type
1083		found in the Interbase 6.0 API Guide.
1084		}
1085
1086	<	IDPBItem = interface(IParameterBlockItem)
1086	>	IDPBItem = interface(IParameterBlockItemWithTypeName)
1087		['{123d4ad0-087a-4cd1-a344-1b3d03b30673}']
1088		end;
1089
1090	<	IDPB = interface(IParameterBlock<IDPBItem>)
1091	<	['{e676067b-1cf4-4eba-9256-9724f57e0d16}']
1092	<	end;
1090	>	IDPB = interface(IParameterBlockWithTypeNames<IDPBItem>)
1091	>	['{e676067b-1cf4-4eba-9256-9724f57e0d16}']
1092	>	end;
1093	>
1094	>	{Journaling options. Default is [joReadWriteTransactions,joModifyQueries] }
1095	>
1096	>	TJournalOption = (joReadOnlyTransactions, joReadWriteTransactions,
1097	>	joModifyQueries, joReadOnlyQueries,joNoServerTable);
1098	>
1099	>	TJournalOptions = set of TJournalOption;
1100
1101		{The IAttachment interface provides access to a Database Connection. It may be
1102		used to:
#	Line 907 | Line 1135 | type
1135		procedure Disconnect(Force: boolean=false);
1136		function IsConnected: boolean;
1137		procedure DropDatabase;
1138	<	function StartTransaction(TPB: array of byte; DefaultCompletion: TTransactionCompletion=taCommit): ITransaction; overload;
1139	<	function StartTransaction(TPB: ITPB; DefaultCompletion: TTransactionCompletion=taCommit): ITransaction; overload;
1138	>	function StartTransaction(TPB: array of byte;
1139	>	DefaultCompletion: TTransactionCompletion=taCommit;
1140	>	aName: AnsiString=''): ITransaction; overload;
1141	>	function StartTransaction(TPB: ITPB;
1142	>	DefaultCompletion: TTransactionCompletion=taCommit;
1143	>	aName: AnsiString=''): ITransaction; overload;
1144		procedure ExecImmediate(transaction: ITransaction; sql: AnsiString; SQLDialect: integer); overload;
1145		procedure ExecImmediate(TPB: array of byte; sql: AnsiString; SQLDialect: integer); overload;
1146		procedure ExecImmediate(transaction: ITransaction; sql: AnsiString); overload;
#	Line 917 | Line 1149 | type
1149		function ExecuteSQL(transaction: ITransaction; sql: AnsiString; SQLDialect: integer; params: array of const): IResults; overload;
1150		function ExecuteSQL(TPB: array of byte; sql: AnsiString; params: array of const): IResults; overload;
1151		function ExecuteSQL(transaction: ITransaction; sql: AnsiString; params: array of const): IResults; overload;
920	–	function OpenCursor(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer): IResultSet; overload;
1152		function OpenCursor(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer;
1153	+	Scrollable: boolean=false): IResultSet; overload;
1154	+	function OpenCursor(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer;
1155	+	params: array of const): IResultSet; overload;
1156	+	function OpenCursor(transaction: ITransaction; sql: AnsiString; Scrollable: boolean=false): IResultSet; overload;
1157	+	function OpenCursor(transaction: ITransaction; sql: AnsiString; Scrollable: boolean;
1158		params: array of const): IResultSet; overload;
923	–	function OpenCursor(transaction: ITransaction; sql: AnsiString): IResultSet; overload;
1159		function OpenCursor(transaction: ITransaction; sql: AnsiString;
1160		params: array of const): IResultSet; overload;
1161	<	function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer): IResultSet; overload;
1161	>	function OpenCursor(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer; Scrollable: boolean;
1162	>	params: array of const): IResultSet; overload;
1163	>	function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer;
1164	>	Scrollable: boolean=false): IResultSet; overload;
1165		function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer;
1166		params: array of const): IResultSet; overload;
1167	<	function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString): IResultSet; overload;
1167	>	function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer; Scrollable: boolean;
1168	>	params: array of const): IResultSet; overload;
1169	>	function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString; Scrollable: boolean=false): IResultSet; overload;
1170		function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString;
1171		params: array of const): IResultSet; overload;
1172	<	function OpenCursorAtStart(sql: AnsiString): IResultSet; overload;
1172	>	function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString; Scrollable: boolean;
1173	>	params: array of const): IResultSet; overload;
1174	>	function OpenCursorAtStart(sql: AnsiString; Scrollable: boolean=false): IResultSet; overload;
1175	>	function OpenCursorAtStart(sql: AnsiString; Scrollable: boolean;
1176	>	params: array of const): IResultSet; overload;
1177		function OpenCursorAtStart(sql: AnsiString;
1178		params: array of const): IResultSet; overload;
1179	<	function Prepare(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer): IStatement; overload;
1180	<	function Prepare(transaction: ITransaction; sql: AnsiString): IStatement; overload;
1179	>	function Prepare(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer; CursorName: AnsiString=''): IStatement; overload;
1180	>	function Prepare(transaction: ITransaction; sql: AnsiString; CursorName: AnsiString=''): IStatement; overload;
1181		function PrepareWithNamedParameters(transaction: ITransaction; sql: AnsiString;
1182		aSQLDialect: integer; GenerateParamNames: boolean=false;
1183	<	CaseSensitiveParams: boolean = false): IStatement; overload;
1183	>	CaseSensitiveParams: boolean = false; CursorName: AnsiString=''): IStatement; overload;
1184		function PrepareWithNamedParameters(transaction: ITransaction; sql: AnsiString;
1185		GenerateParamNames: boolean=false;
1186	<	CaseSensitiveParams: boolean = false): IStatement; overload;
1186	>	CaseSensitiveParams: boolean = false; CursorName: AnsiString=''): IStatement; overload;
1187
1188		{Events}
1189		function GetEventHandler(Events: TStrings): IEvents; overload;
#	Line 952 | Line 1196 | type
1196		function CreateBlob(transaction: ITransaction; SubType: integer; CharSetID: cardinal=0; BPB: IBPB=nil): IBlob; overload;
1197		function OpenBlob(transaction: ITransaction; RelationName, ColumnName: AnsiString; BlobID: TISC_QUAD; BPB: IBPB=nil): IBlob; overload;
1198		function OpenBlob(transaction: ITransaction; BlobMetaData: IBlobMetaData; BlobID: TISC_QUAD; BPB: IBPB=nil): IBlob;  overload;
1199	+	function GetInlineBlobLimit: integer;
1200	+	procedure SetInlineBlobLimit(limit: integer);
1201
1202		{Array - may use to open existing arrays. However, ISQLData.AsArray is preferred}
1203
#	Line 965 | Line 1211 | type
1211
1212		{Database Information}
1213		function GetSQLDialect: integer;
1214	+	function GetAttachmentID: integer;
1215		function GetBlobMetaData(Transaction: ITransaction; tableName, columnName: AnsiString): IBlobMetaData;
1216		function GetArrayMetaData(Transaction: ITransaction; tableName, columnName: AnsiString): IArrayMetaData;
1217		function GetDBInformation(Requests: array of byte): IDBInformation; overload;
#	Line 978 | Line 1225 | type
1225		function GetODSMinorVersion: integer;
1226		procedure getFBVersion(version: TStrings);
1227		function HasActivity: boolean;
1228	+	function HasDecFloatSupport: boolean;
1229	+	function HasBatchMode: boolean;
1230	+	function HasScollableCursors: boolean;
1231	+	function HasTable(aTableName: AnsiString): boolean;  {case sensitive}
1232	+	function HasFunction(aFunctionName: AnsiString): boolean; {case sensitive}
1233	+	function HasProcedure(aProcName: AnsiString): boolean; {case sensitive}
1234
1235		{Character Sets}
1236	+	function GetCharSetID: integer; {connection character set}
1237		function HasDefaultCharSet: boolean;
1238		function GetDefaultCharSetID: integer;
1239		function GetCharsetName(CharSetID: integer): AnsiString;
#	Line 989 | Line 1243 | type
1243		function CharSetWidth(CharSetID: integer; var Width: integer): boolean;
1244		procedure RegisterCharSet(CharSetName: AnsiString; CodePage: TSystemCodePage;
1245		AllowReverseLookup:boolean; out CharSetID: integer);
1246	<	end;
1246	>
1247	>	{Time Zone Database}
1248	>	function GetTimeZoneServices: ITimeZoneServices;
1249	>	function HasTimeZoneSupport: boolean;
1250	>
1251	>	{Client side Journaling}
1252	>	function JournalingActive: boolean;
1253	>	function GetJournalOptions: TJournalOptions;
1254	>	function StartJournaling(aJournalLogFile: AnsiString): integer; overload;
1255	>	function StartJournaling(aJournalLogFile: AnsiString; Options: TJournalOptions): integer; overload;
1256	>	function StartJournaling(S: TStream; Options: TJournalOptions): integer; overload;
1257	>	procedure StopJournaling(RetainJournal: boolean);
1258	>	end;
1259
1260		TProtocolAll = (TCP, SPX, NamedPipe, Local, inet, inet4, inet6, wnet, xnet, unknownProtocol);
1261		TProtocol = TCP..xnet;
#	Line 1006 | Line 1272 | type
1272
1273		}
1274
1275	<	ISPBItem = interface(IParameterBlockItem)
1275	>	ISPBItem = interface(IParameterBlockItemWithTypeName)
1276		['{5d08ae2b-4519-41bd-8b40-97cd451c3f6a}']
1277		end;
1278
1279	<	ISPB = interface(IParameterBlock<ISPBItem>)
1279	>	ISPB = interface(IParameterBlockWithTypeNames<ISPBItem>)
1280		['{2c5836fd-41ed-4426-9b7d-5af580ec2659}']
1281		end;
1282
#	Line 1070 | Line 1336 | type
1336		function getSize: integer;
1337		procedure getRawBytes(var Buffer);
1338		function getAsString: AnsiString;
1339	<	function getAsInteger: integer;
1339	>	function getAsInteger: int64;
1340		function getAsByte: byte;
1341		function CopyTo(stream: TStream; count: integer): integer;
1342		property AsString: AnsiString read getAsString;
1343	<	property AsInteger: integer read getAsInteger;
1343	>	property AsInteger: int64 read getAsInteger;
1344		property AsByte: byte read getAsByte;
1345		end;
1346
#	Line 1144 | Line 1410 | type
1410		The interface is returned by the FirebirdAPI function.
1411		}
1412
1413	+	{ IFirebirdAPI }
1414	+
1415		IFirebirdAPI = interface
1416		['{edeee691-c8d3-4dcf-a780-cd7e432821d5}']
1417		{Database connections}
#	Line 1155 | Line 1423 | type
1423		{Start Transaction against multiple databases}
1424		function AllocateTPB: ITPB;
1425		function StartTransaction(Attachments: array of IAttachment;
1426	<	TPB: array of byte; DefaultCompletion: TTransactionCompletion=taCommit): ITransaction; overload;
1426	>	TPB: array of byte; DefaultCompletion: TTransactionCompletion=taCommit;
1427	>	aName: AnsiString=''): ITransaction; overload;
1428		function StartTransaction(Attachments: array of IAttachment;
1429	<	TPB: ITPB; DefaultCompletion: TTransactionCompletion=taCommit): ITransaction; overload;
1429	>	TPB: ITPB; DefaultCompletion: TTransactionCompletion=taCommit;
1430	>	aName: AnsiString=''): ITransaction; overload;
1431
1432		{Service Manager}
1433		function HasServiceAPI: boolean;
#	Line 1172 | Line 1442 | type
1442		function GetImplementationVersion: AnsiString;
1443		function GetClientMajor: integer;
1444		function GetClientMinor: integer;
1445	+	function HasDecFloatSupport: boolean;
1446	+	function HasLocalTZDB: boolean;
1447	+	function HasTimeZoneSupport: boolean;
1448	+	function HasExtendedTZSupport: boolean;
1449
1450		{Firebird 3 API}
1451		function HasMasterIntf: boolean;
1452	<	function GetIMaster: TObject;
1452	>	function GetIMaster: TObject;  deprecated 'Use FirebirdAPI.QueryInterface and FBClientLib.pas IFBIMasterProvider instead';
1453		function GetFBLibrary: IFirebirdLibrary;
1454		end;
1455
#	Line 1202 | Line 1476 | type
1476		EIBInterBaseError = class(EIBError)
1477		private
1478		FIBErrorCode: Long;
1479	+	FStatus: IStatus;
1480		public
1481	<	constructor Create(Status: IStatus); overload;
1481	>	constructor Create(aStatus: IStatus); overload;
1482		constructor Create(ASQLCode: Long; AIBErrorCode: Long; Msg: AnsiString); overload;
1483		property IBErrorCode: Long read FIBErrorCode;
1484	+	property Status: IStatus read FStatus;
1485		end;
1486
1487		{IB Client Exceptions}
1488		EIBClientError = class(EIBError);
1489
1490	+	{Used to explicitly report a Batch Buffer overflow}
1491	+	EIBBatchBufferOverflow = class(EIBError);
1492	+
1493		{The Firebird API function is used to access the IFirebirdAPI interface.
1494
1495		It will load the Firebird Client Library if this is not already loaded and
#	Line 1220 | Line 1499 | type
1499		function FirebirdAPI: IFirebirdAPI;
1500
1501		{IBX support functions. Probably best ignored i.e. always used the FirebirdAPI
1502	<	functino to load the library and check if it's loaded.}
1502	>	function to load the library and check if it's loaded.}
1503
1504		function TryIBLoad: Boolean;
1505		procedure CheckIBLoaded;
#	Line 1231 | Line 1510 | procedure CheckIBLoaded;
1510
1511		function LoadFBLibrary(aLibPathName: string): IFirebirdLibrary;
1512
1513	+	{$if not declared(Null)} {Needed for Delphi}
1514	+	function Null: Variant;       // Null standard constant
1515	+	{$define NEEDNULLFUNCTION}
1516	+	{$ifend}
1517	+
1518		implementation
1519
1520	<	uses FBClientAPI
1520	>	uses FBClientAPI {$if not declared(NULL)}, Variants {$ifend}
1521		{$IFDEF USELEGACYFIREBIRDAPI}, FB25ClientAPI {$ENDIF}
1522		{$IFDEF USEFIREBIRD3API}, FB30ClientAPI {$ENDIF};
1523
#	Line 1325 | Line 1609 | end;
1609
1610		{ EIBInterBaseError }
1611
1612	<	constructor EIBInterBaseError.Create(Status: IStatus);
1612	>	constructor EIBInterBaseError.Create(aStatus: IStatus);
1613		begin
1614	<	inherited Create(Status.Getsqlcode,Status.GetMessage);
1615	<	FIBErrorCode := Status.GetIBErrorCode;
1614	>	inherited Create(aStatus.Getsqlcode,aStatus.GetMessage);
1615	>	FIBErrorCode := aStatus.GetIBErrorCode;
1616	>	FStatus := aStatus;
1617		end;
1618
1619		constructor EIBInterBaseError.Create(ASQLCode: Long; AIBErrorCode: Long;
#	Line 1338 | Line 1623 | begin
1623		FIBErrorCode := AIBErrorCode;
1624		end;
1625
1626	+	{$ifdef NEEDNULLFUNCTION}
1627	+	function Null: Variant;       // Null standard constant
1628	+	begin
1629	+	VarClearProc(TVarData(Result));
1630	+	TVarData(Result).VType := varnull;
1631	+	end;
1632	+	{$endif}
1633
1634		initialization
1635		FDefaultFBLibrary := nil;

Comparing:
ibx/trunk/fbintf/IB.pas (property svn:eol-style), Revision 310 by tony, Tue Jul 21 08:20:03 2020 UTC vs.
ibx/branches/udr/client/IB.pas (property svn:eol-style), Revision 381 by tony, Sat Jan 15 00:06:22 2022 UTC

#	Line 0 | Line 1
1	+	native

Diff Legend

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