ViewVC Help
View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing
root/public/ibx/branches/udr/client/IB.pas
(Generate patch)

Comparing:
ibx/trunk/fbintf/IB.pas (file contents), Revision 117 by tony, Mon Jan 22 13:58:11 2018 UTC vs.
ibx/branches/udr/client/IB.pas (file contents), Revision 371 by tony, Wed Jan 5 15:21:22 2022 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;
138 <  FBIntf_Release = 2;
139 <  FBIntf_Version = '1.0.2';
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 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 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 clone(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}
# Line 216 | 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 233 | 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 241 | Line 312 | type
312     This interface can be accessed from IFirebirdAPI.
313     }
314  
315 +   TIBDataBaseErrorMessage    = (ShowSQLCode,
316 +                                   ShowIBMessage,
317 +                                   ShowSQLMessage);
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 267 | Line 346 | type
346      function GetSQLTypeName: AnsiString;
347      function GetScale: integer;
348      function GetSize: cardinal;
349 +    function GetCharSetWidth: integer;
350      function GetCharSetID: cardinal;
351      function GetTableName: AnsiString;
352      function GetColumnName: AnsiString;
# Line 305 | 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);
321    procedure SetAsTime(index: array of integer; Value: TDateTime);
322    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 395 | Line 487 | type
487      the output of an SQL Statement.
488    }
489  
490 +  TIBDateTimeFormats = (dfTimestamp, {SQL TIMESTAMP}
491 +                        dfDateTime,   {SQL DATETIME}
492 +                        dfTime,      {SQL TIME}
493 +                        dfTimestampTZ, {SQL_TIMESTAMP_TZ}
494 +                        dfTimeTZ);       {SQLTIME_TZ
495 +
496    { IColumnMetaData }
497  
498    IColumnMetaData = interface
# Line 411 | Line 509 | type
509      function getScale: integer;
510      function getCharSetID: cardinal;
511      function getCodePage: TSystemCodePage;
512 +    function GetCharSetWidth: integer;
513      function getIsNullable: boolean;
514      function GetSize: cardinal;
515      function GetArrayMetaData: IArrayMetaData; {Valid only for Array SQL Type}
516      function GetBlobMetaData: IBlobMetaData; {Valid only for Blob SQL 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 456 | Line 559 | type
559  
560    ISQLData = interface(IColumnMetaData)
561      ['{3f493e31-7e3f-4606-a07c-b210b9e3619d}']
562 +    function GetStrDataLength: short;
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 472 | 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 489 | 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 502 | Line 617 | type
617    IResults = interface
618      ['{e836b2bb-93d1-4bbf-a8eb-7ce535de3bb5}']
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 518 | 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
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
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}']
544 <    function GetIndex: integer;
668 >  IParamMetaData = interface
669 >  ['{4e148c4e-2d48-4991-a263-f66eca05c6aa}']
670      function GetSQLType: cardinal;
671      function GetSQLTypeName: AnsiString;
672      function getSubtype: integer;
548    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 566 | 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 573 | 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 586 | 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 602 | 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;
611    property SQLType: cardinal read GetSQLType;
766    end;
767  
768     {
# Line 622 | Line 776 | type
776      function getSQLParam(index: integer): ISQLParam;
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 632 | Line 791 | type
791                  psRealTime, psUserTime, psBuffers,
792                  psReads, psWrites, psFetches,psDeltaMemory);
793  
794 <  TPerfCounters = array[TPerfStats] of comp;
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 645 | 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 672 | 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 696 | 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 704 | 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 742 | 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 770 | 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;
1035      procedure DecodeVersionString(var Version: byte; var VersionString: AnsiString);
1036      function getOperationCounts: TDBOperationCounts;
1037      procedure DecodeUserNames(UserNames: TStrings);
# Line 781 | 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 799 | Line 1058 | type
1058      property Items[index: integer]: IDBInfoItem read getItem; default;
1059    end;
1060  
1061 +  {The Database Information Request Block is used to pass requests for
1062 +   database information where at least one item requested has a parameter.
1063 +   At present, this is only fb_info_page_contents which has a single
1064 +   integer parameter.}
1065 +
1066 +  IDIRBItem = interface(IParameterBlockItem)
1067 +    ['{d34a7511-8435-4a24-81a7-5103d218d234}']
1068 +  end;
1069 +
1070 +  IDIRB = interface(IParameterBlock<IDIRBItem>)
1071 +    ['{1010e5ac-0a8f-403b-a302-91625e9d9579}']
1072 +  end;
1073 +
1074 +
1075    {The Database Parameter Block (DPB).
1076  
1077     The DPB provides the parameters used when connecting to a database. It is allocated
# Line 810 | 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 847 | Line 1127 | type
1127  
1128    IAttachment = interface
1129      ['{466e9b67-9def-4807-b3e7-e08a35e7185c}']
1130 +    function getFirebirdAPI: IFirebirdAPI;
1131      function getDPB: IDPB;
1132      function AllocateBPB: IBPB;
1133 +    function AllocateDIRB: IDIRB;
1134      procedure Connect;
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 863 | 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;
866    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;
869    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): IStatement; overload;
1182 >                       aSQLDialect: integer; GenerateParamNames: boolean=false;
1183 >                       CaseSensitiveParams: boolean = false; CursorName: AnsiString=''): IStatement; overload;
1184      function PrepareWithNamedParameters(transaction: ITransaction; sql: AnsiString;
1185 <                       GenerateParamNames: boolean=false): IStatement; overload;
1185 >                       GenerateParamNames: boolean=false;
1186 >                       CaseSensitiveParams: boolean = false; CursorName: AnsiString=''): IStatement; overload;
1187  
1188      {Events}
1189      function GetEventHandler(Events: TStrings): IEvents; overload;
# Line 894 | Line 1194 | type
1194      function CreateBlob(transaction: ITransaction; RelationName, ColumnName: AnsiString; BPB: IBPB=nil): IBlob; overload;
1195      function CreateBlob(transaction: ITransaction; BlobMetaData: IBlobMetaData; BPB: IBPB=nil): IBlob; overload;
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;
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  
1204 <    function OpenArray(transaction: ITransaction; RelationName, ColumnName: AnsiString; ArrayID: TISC_QUAD): IArray;
1204 >    function OpenArray(transaction: ITransaction; RelationName, ColumnName: AnsiString; ArrayID: TISC_QUAD): IArray; overload;
1205 >    function OpenArray(transaction: ITransaction; ArrayMetaData: IArrayMetaData; ArrayID: TISC_QUAD): IArray; overload;
1206      function CreateArray(transaction: ITransaction; RelationName, ColumnName: AnsiString): IArray; overload;
1207      function CreateArray(transaction: ITransaction; ArrayMetaData: IArrayMetaData): IArray; overload;
1208      function CreateArrayMetaData(SQLType: cardinal; tableName: AnsiString; columnName: AnsiString;
# Line 907 | 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;
1218      function GetDBInformation(Request: byte): IDBInformation; overload;
1219 +    function GetDBInformation(Requests: IDIRB): IDBInformation; overload;
1220      function GetConnectString: AnsiString;
1221      function GetRemoteProtocol: AnsiString;
1222 +    function GetAuthenticationMethod: AnsiString;
1223 +    function GetSecurityDatabase: AnsiString;
1224      function GetODSMajorVersion: integer;
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 927 | 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);
930  end;
1246  
1247 <  TProtocol = (TCP, SPX, NamedPipe, Local);
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;
1262  
1263    {Service Parameter Block (SPB).
1264  
# Line 943 | 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 1007 | 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 1034 | Line 1363 | type
1363      property Count: integer read getCount;
1364    end;
1365  
1366 +  IFirebirdLibrary = interface;
1367 +
1368    {The IServiceManager interface provides access to a service manager. It can
1369     used to Detach and re-attach to Service Manager, to start services and to
1370     query the service manager.
# Line 1045 | Line 1376 | type
1376  
1377    IServiceManager = interface
1378      ['{905b587d-1e1f-4e40-a3f8-a3519f852e48}']
1379 +    function getFirebirdAPI: IFirebirdAPI;
1380      function getSPB: ISPB;
1381      function getServerName: AnsiString;
1382 +    function getProtocol: TProtocol;
1383 +    function getPortNo: AnsiString;
1384      procedure Attach;
1385      procedure Detach(Force: boolean=false);
1386      function IsAttached: boolean;
1387      function AllocateSRB: ISRB;
1388      function AllocateSQPB: ISQPB;
1389 <    procedure Start(Request: ISRB);
1390 <    function Query(SQPB: ISQPB; Request: ISRB) :IServiceQueryResults; overload;
1391 <    function Query(Request: ISRB) :IServiceQueryResults; overload;
1389 >    function Start(Request: ISRB; RaiseExceptionOnError: boolean=true): boolean;
1390 >    function Query(SQPB: ISQPB; Request: ISRB; RaiseExceptionOnError: boolean=true) :IServiceQueryResults; overload;
1391 >    function Query(Request: ISRB; RaiseExceptionOnError: boolean=true) :IServiceQueryResults; overload;
1392 >  end;
1393 >
1394 >  {Tbe Firebird Library API used to get information about the Firebird library}
1395 >
1396 >
1397 >  IFirebirdLibrary = interface
1398 >    ['{3c04e0a1-12e0-428a-b2e1-bc6fcd97b79b}']
1399 >    function GetHandle: TLibHandle;
1400 >    function GetLibraryName: string;
1401 >    function GetLibraryFilePath: string;
1402 >    function GetFirebirdAPI: IFirebirdAPI;
1403    end;
1404  
1405    {The Firebird API.
# Line 1065 | 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 1076 | 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;
1434      function AllocateSPB: ISPB;
1435 <    function GetServiceManager(ServerName: AnsiString; Protocol: TProtocol; SPB: ISPB): IServiceManager;
1435 >    function GetServiceManager(ServerName: AnsiString; Protocol: TProtocol; SPB: ISPB): IServiceManager; overload;
1436 >    function GetServiceManager(ServerName: AnsiString; Port: AnsiString; Protocol: TProtocol; SPB: ISPB): IServiceManager; overload;
1437  
1438      {Information}
1439      function GetStatus: IStatus;
1090    function GetLibraryName: string;
1440      function HasRollbackRetaining: boolean;
1441      function IsEmbeddedServer: boolean;
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  
1456   type
# Line 1120 | 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 < {IBError is used internally and by IBX to throw an EIBClientError}
1491 <
1134 < procedure IBError(ErrMess: TIBClientError; const Args: array of const);
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  
# Line 1142 | Line 1499 | procedure IBError(ErrMess: TIBClientErro
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;
1506  
1507 + {If you want to explicitly load the Firebird library from a
1508 + non-default location then use this function and its GetFirebirdAPI function
1509 + to get the API.}
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  
1524 < var FFirebirdAPI: IFirebirdAPI;
1524 > var FDefaultFBLibrary: IFirebirdLibrary;
1525 >
1526 > type
1527 >
1528 >  { TFBLibrary }
1529 >
1530 >  TFBLibraryImpl = class(TFBLibrary)
1531 >  protected
1532 >    function GetFirebird3API: IFirebirdAPI; override;
1533 >    function GetLegacyFirebirdAPI: IFirebirdAPI; override;
1534 >  end;
1535 >
1536 > function TFBLibraryImpl.GetFirebird3API: IFirebirdAPI;
1537 > begin
1538 > {$IFDEF USEFIREBIRD3API}
1539 > Result := TFB30ClientAPI.Create(self);
1540 > {$ELSE}
1541 > Result := nil;
1542 > {$ENDIF}
1543 > end;
1544 >
1545 > function TFBLibraryImpl.GetLegacyFirebirdAPI: IFirebirdAPI;
1546 > begin
1547 >  {$IFDEF USELEGACYFIREBIRDAPI}
1548 >  Result := TFB25ClientAPI.Create(self);
1549 >  {$ELSE}
1550 >  Result := nil;
1551 >  {$ENDIF}
1552 > end;
1553  
1554   function FirebirdAPI: IFirebirdAPI;
1555   begin
1556 <  if FFirebirdAPI = nil then
1556 >  if FDefaultFBLibrary = nil then
1557      CheckIBLoaded;
1558 <  Result := FFirebirdAPI;
1558 >  Result := FDefaultFBLibrary.GetFirebirdAPI;
1559   end;
1560  
1561   function TryIBLoad: Boolean;
1562 + var fblib: IFirebirdLibrary;
1563   begin
1564 < Result := FFirebirdAPI <> nil;
1564 > Result := FDefaultFBLibrary <> nil;
1565   try
1169  {$IFDEF USEFIREBIRD3API}
1566    if not Result then
1567    begin
1568 <    FFirebirdAPI := TFB30ClientAPI.Create;
1569 <    Result := FFirebirdAPI.HasMasterIntf;
1570 <  end;
1571 <  {$ENDIF}
1176 <  {$IFDEF USELEGACYFIREBIRDAPI}
1177 <  if not Result then
1178 <  begin
1179 <    FFirebirdAPI := nil;
1180 <    FFirebirdAPI := TFB25ClientAPI.Create;
1181 <    Result := true;
1182 <  end;
1183 <  {$ENDIF}
1184 <  if Result and not (FFirebirdAPI as TFBClientAPI).IsLibraryLoaded then
1185 <  begin
1186 <    Result := false;
1187 <    FFirebirdAPI := nil;
1568 >    fblib := TFBLibraryImpl.Create;
1569 >    if (fblib <> nil) and (fblib.GetFirebirdAPI <> nil) then
1570 >      FDefaultFBLibrary := fblib;
1571 >    Result := FDefaultFBLibrary <> nil;
1572    end;
1573   except
1574     SysUtils.showexception(ExceptObject,ExceptAddr);
# Line 1198 | Line 1582 | begin
1582      IBError(ibxeInterBaseMissing, [nil]);
1583   end;
1584  
1585 + function LoadFBLibrary(aLibPathName: string): IFirebirdLibrary;
1586 + var fblib: IFirebirdLibrary;
1587 + begin
1588 +  if trim(aLibPathName) = '' then
1589 +  begin
1590 +    CheckIBLoaded;
1591 +    Result := FDefaultFBLibrary;
1592 +  end
1593 +  else
1594 +  begin
1595 +    fblib := TFBLibraryImpl.GetFBLibrary(aLibPathName);
1596 +    if (fblib = nil) or (fblib.GetFirebirdAPI = nil) then
1597 +      IBError(ibxeInterBaseMissing, [nil]);
1598 +    Result := fblib;
1599 +  end;
1600 + end;
1601 +
1602   { EIBError }
1603  
1604   constructor EIBError.Create(ASQLCode: Long; Msg: AnsiString);
# Line 1208 | 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 1221 | Line 1623 | begin
1623    FIBErrorCode := AIBErrorCode;
1624   end;
1625  
1626 < procedure IBError(ErrMess: TIBClientError; const Args: array of const);
1627 < begin
1628 <  raise EIBClientError.Create(Ord(ErrMess),
1629 <                              Format(GetErrorMessage(ErrMess), Args));
1630 < end;
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 <  FFirebirdAPI := nil;
1635 >  FDefaultFBLibrary := nil;
1636  
1637 + finalization
1638 +  FDefaultFBLibrary := nil;
1639  
1640   end.
1641  

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines