ViewVC Help
View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing
root/public/ibx/branches/udr/client/IB.pas
Revision: 381
Committed: Sat Jan 15 00:06:22 2022 UTC (4 months, 1 week ago) by tony
File size: 68993 byte(s)
Log Message:
Release Candidate 1
Line User Rev File contents
1 tony 45 (*
2     * Firebird Interface (fbintf). The fbintf components provide a set of
3     * Pascal language bindings for the Firebird API. Although predominantly
4     * a new development they include source code taken from IBX and may be
5     * considered a derived product. This software thus also includes the copyright
6     * notice and license conditions from IBX.
7     *
8     * Except for those parts dervied from IBX, contents of this file are subject
9     * to the Initial Developer's Public License Version 1.0 (the "License"); you
10     * may not use this file except in compliance with the License. You may obtain a
11     * copy of the License here:
12     *
13     * http://www.firebirdsql.org/index.php?op=doc&id=idpl
14     *
15     * Software distributed under the License is distributed on an "AS
16     * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
17     * implied. See the License for the specific language governing rights
18     * and limitations under the License.
19     *
20     * The Initial Developer of the Original Code is Tony Whyman.
21     *
22     * The Original Code is (C) 2016 Tony Whyman, MWA Software
23     * (http://www.mwasoftware.co.uk).
24     *
25     * All Rights Reserved.
26     *
27     * Contributor(s): ______________________________________.
28     *
29     *)
30     {************************************************************************}
31     { }
32     { Borland Delphi Visual Component Library }
33     { InterBase Express core components }
34     { }
35     { Copyright (c) 1998-2000 Inprise Corporation }
36     { }
37     { InterBase Express is based in part on the product }
38     { Free IB Components, written by Gregory H. Deatz for }
39     { Hoagland, Longo, Moran, Dunst & Doukas Company. }
40     { Free IB Components is used under license. }
41     { }
42     { The contents of this file are subject to the InterBase }
43     { Public License Version 1.0 (the "License"); you may not }
44     { use this file except in compliance with the License. You }
45     { may obtain a copy of the License at http://www.Inprise.com/IPL.html }
46     { Software distributed under the License is distributed on }
47     { an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either }
48     { express or implied. See the License for the specific language }
49     { governing rights and limitations under the License. }
50     { The Original Code was created by InterBase Software Corporation }
51     { and its successors. }
52     { Portions created by Inprise Corporation are Copyright (C) Inprise }
53     { Corporation. All Rights Reserved. }
54     { Contributor(s): Jeff Overcash }
55     { }
56     { IBX For Lazarus (Firebird Express) }
57     { Contributor: Tony Whyman, MWA Software http://www.mwasoftware.co.uk }
58     { Portions created by MWA Software are copyright McCallum Whyman }
59     { Associates Ltd 2011 - 2015 }
60     { }
61     {************************************************************************}
62     unit IB;
63 tony 56 {$IFDEF MSWINDOWS}
64     {$DEFINE WINDOWS}
65     {$ENDIF}
66 tony 45
67     {$IFDEF FPC}
68 tony 56 {$mode delphi}
69 tony 45 {$codepage UTF8}
70     {$interfaces COM}
71 tony 56 {$IF defined(FPC) and (FPC_FULLVERSION < 30000) }
72 tony 45 {$ERROR FPC Version 3.0.0 or later is required}
73 tony 56 {$IFEND}
74 tony 45 {$ENDIF}
75    
76 tony 270 {$IFNDEF LEGACYFIREBIRDAPIONLY}
77 tony 45 {$DEFINE USEFIREBIRD3API}
78 tony 270 {$ENDIF}
79     {$IFNDEF FIREBIRD3APIONLY}
80 tony 45 {$DEFINE USELEGACYFIREBIRDAPI}
81 tony 270 {$ENDIF}
82 tony 45
83     {
84     This unit defines the interfaces used to provide the Pascal Language
85     bindings for the Firebird API. These are COM style references counted interfaces
86     and are automatically freed when they go out of scope.
87    
88     The interface definition is independent of the Firebird API version and two
89     implementations are provided. One is for the legacy API (2.5 and earlier) and the
90     other is for the new object orientated API (3.0 and later). By default, both are
91     available with the 3.0 API used if it is available. Otherwise the 2.5 API is used.
92     The above two defines can be used to force only one implementation by undefining
93     the symbol for the unwanted API.
94    
95     Note that the FirebirdAPI function defined below is used for initial access to
96     the language bindings.
97    
98     The goals of these Pascal Langauge bindings are to provide:
99    
100     1. A set of reference counted interfaces providing complete access to the Firebird API.
101    
102     2. Application Independence from the Firebird API version.
103    
104     3. All data access through strongly typed variables and functions with no need for
105     the end user to manipulate untyped data in buffers such as the legacy API SQLDA
106     or the Firebird 3.0 message buffer.
107    
108     4. A stable platform for LCL Packages (e.g. IBX) that implement the TDataSet model
109     with independence from the Firebird API version.
110    
111     5. Straightforward progammatic access to the Firebird API from Pascal programs.
112    
113 tony 56 6. FPC and Delphi Support.
114    
115 tony 45 String Types
116     ============
117    
118     From FPC 3.0 onwards, ANSISTRINGs include the codepage in their definition. All
119     strings used by the interface are sensitive to the codepage in that the codepage
120     for all strings returned by an interface is consistent with the SQL Character set
121     used for the database connection. Input strings will be transliterated, where possible
122     and if necessary, to the codepage consistent with the character set used for
123     the database connection.
124     }
125    
126     interface
127    
128     uses
129 tony 263 Classes,
130     {$IFDEF WINDOWS}Windows, {$ENDIF}
131     {$IFDEF FPC} Dynlibs, {$ENDIF}
132 tony 315 SysUtils, DB, FBMessages, IBExternals, FmtBcd;
133 tony 45
134 tony 47 const
135     {Interface version information}
136     FBIntf_Major = 1;
137 tony 364 FBIntf_Minor = 4;
138     FBIntf_Release = 0;
139     FBIntf_Version = '1.4.0';
140 tony 47
141 tony 315 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 tony 45 {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 tony 56 {$I 'include/consts_pub.inc'}
160 tony 315 {$I 'include/dyn_consts.inc'}
161 tony 56 {$I 'include/inf_pub.inc'}
162     {$I 'include/configkeys.inc'}
163 tony 315 {$I 'include/blr.inc'}
164 tony 45
165     {The following constants define the values return by calls to the GetSQLType
166     methods provided by several of the interfaces defined below.}
167    
168     (*********************)
169     (** SQL definitions **)
170     (*********************)
171     SQL_VARYING = 448;
172     SQL_TEXT = 452;
173     SQL_DOUBLE = 480;
174     SQL_FLOAT = 482;
175     SQL_LONG = 496;
176     SQL_SHORT = 500;
177     SQL_TIMESTAMP = 510;
178     SQL_BLOB = 520;
179     SQL_D_FLOAT = 530;
180     SQL_ARRAY = 540;
181     SQL_QUAD = 550;
182     SQL_TYPE_TIME = 560;
183     SQL_TYPE_DATE = 570;
184     SQL_INT64 = 580;
185 tony 315 SQL_TIMESTAMP_TZ_EX = 32748;
186     SQL_TIME_TZ_EX = 32750;
187     SQL_INT128 = 32752;
188 tony 45 SQL_BOOLEAN = 32764;
189 tony 315 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 tony 45 SQL_DATE = SQL_TIMESTAMP;
196    
197     type
198     TGDS_QUAD = record
199     gds_quad_high : ISC_LONG;
200     gds_quad_low : UISC_LONG;
201     end;
202     TGDS__QUAD = TGDS_QUAD;
203     TISC_QUAD = TGDS_QUAD;
204     PGDS_QUAD = ^TGDS_QUAD;
205     PGDS__QUAD = ^TGDS__QUAD;
206     PISC_QUAD = ^TISC_QUAD;
207    
208 tony 56 {$IFNDEF FPC}
209 tony 263 {Delphi missing definitions}
210     type
211     TLibHandle = THandle;
212    
213     const
214     NilHandle = 0;
215     DirectorySeparator = '\';
216    
217 tony 56 {Delphi only seems to define CP_UTF8 and CP_UTF16}
218     const
219     CP_ACP = 0; // default to ANSI code page
220     CP_OEMCP = 1; // default to OEM (console) code page
221     CP_UTF16BE = 1201; // unicodeFFFE
222     CP_UTF7 = 65000; // utf-7
223     CP_ASCII = 20127; // us-ascii
224     CP_NONE = $FFFF; // rawbytestring encoding
225    
226     {$ENDIF}
227    
228     type
229     {$IF not declared(TSystemCodePage)}
230     TSystemCodePage = word; {not defined in Delphi}
231     {$IFEND}
232    
233 tony 45 TIBSQLStatementTypes =
234     (SQLUnknown, SQLSelect, SQLInsert,
235     SQLUpdate, SQLDelete, SQLDDL,
236     SQLGetSegment, SQLPutSegment,
237     SQLExecProcedure, SQLStartTransaction,
238     SQLCommit, SQLRollback,
239 tony 291 SQLSelectForUpdate, SQLSetGenerator,
240     SQLSavePoint);
241 tony 45
242     TFBStatusCode = cardinal;
243     TByteArray = array of byte;
244 tony 315 TFBTimeZoneID = ISC_USHORT;
245 tony 45
246 tony 263 IFirebirdAPI = interface;
247 tony 45 IAttachment = interface;
248     ITransaction = interface;
249 tony 291 IStatement = interface;
250 tony 45
251 tony 371 {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 tony 381 function AdjustScaleTo(aNewScale: integer): IFBNumeric;
259 tony 371 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 tony 56 {The IParameterBlock interface provides the template for all parameter
269 tony 45 block interfaces}
270    
271 tony 56 IParameterBlock<_IItem> = interface
272 tony 45 function getCount: integer;
273     function Add(ParamType: byte): _IItem;
274     function getItems(index: integer): _IItem;
275     function Find(ParamType: byte): _IItem;
276     procedure PrintBuf; {can be used to print buffer in hex for debugging}
277     property Count: integer read getCount;
278     property Items[index: integer]: _IItem read getItems; default;
279     end;
280    
281 tony 315 IParameterBlockWithTypeNames<_IItem> = interface(IParameterBlock<_IItem>)
282     function AddByTypeName(ParamTypeName: AnsiString): _IItem;
283 tony 345 function GetDPBParamTypeName(ParamType: byte): Ansistring; deprecated 'Use Get ParamTypeName';
284     function GetParamTypeName(ParamType: byte): Ansistring;
285 tony 315 end;
286    
287 tony 45 {IParameterBlockItem is not used on its own but instead provides a base type for
288     different parameter block items }
289    
290     IParameterBlockItem = interface
291 tony 56 ['{53b23f7b-abda-46a5-9aa5-07bd5e723266}']
292 tony 45 function getParamType: byte;
293     function getAsInteger: integer;
294 tony 56 function getAsString: AnsiString;
295 tony 45 function getAsByte: byte;
296 tony 56 procedure setAsString(aValue: AnsiString);
297 tony 45 procedure setAsByte(aValue: byte);
298     procedure SetAsInteger(aValue: integer);
299 tony 56 property AsString: AnsiString read getAsString write setAsString;
300 tony 45 property AsByte: byte read getAsByte write setAsByte;
301     property AsInteger: integer read getAsInteger write SetAsInteger;
302     end;
303    
304 tony 315 IParameterBlockItemWithTypeName = interface(IParameterBlockItem)
305     function getParamTypeName: AnsiString;
306     end;
307 tony 45
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
310     returned by a database engine exception - see EIBInterbaseError.
311    
312     This interface can be accessed from IFirebirdAPI.
313     }
314    
315 tony 291 TIBDataBaseErrorMessage = (ShowSQLCode,
316     ShowIBMessage,
317     ShowSQLMessage);
318    
319     TIBDataBaseErrorMessages = set of TIBDataBaseErrorMessage;
320    
321 tony 345 TStatusCode = long;
322    
323 tony 45 IStatus = interface
324 tony 56 ['{34167722-af38-4831-b08a-93162d58ede3}']
325 tony 345 function GetIBErrorCode: TStatusCode;
326     function Getsqlcode: TStatusCode;
327 tony 56 function GetMessage: AnsiString;
328 tony 45 function CheckStatusVector(ErrorCodes: array of TFBStatusCode): Boolean;
329     function GetIBDataBaseErrorMessages: TIBDataBaseErrorMessages;
330     procedure SetIBDataBaseErrorMessages(Value: TIBDataBaseErrorMessages);
331     end;
332    
333     { The array metadata interface provides access to the metadata used to describe
334     an array column in a Firebird table.
335     }
336    
337     TArrayBound = record
338     UpperBound: short;
339     LowerBound: short;
340     end;
341     TArrayBounds = array of TArrayBound;
342    
343     IArrayMetaData = interface
344 tony 56 ['{7dd0aea4-59af-4c2a-b958-565d5025c489}']
345 tony 45 function GetSQLType: cardinal;
346 tony 56 function GetSQLTypeName: AnsiString;
347 tony 45 function GetScale: integer;
348     function GetSize: cardinal;
349 tony 309 function GetCharSetWidth: integer;
350 tony 45 function GetCharSetID: cardinal;
351 tony 56 function GetTableName: AnsiString;
352     function GetColumnName: AnsiString;
353 tony 45 function GetDimensions: integer;
354     function GetBounds: TArrayBounds;
355     end;
356    
357     {The array interface provides access to and modification of the array data
358     contained in an array field of a Firebird Table. The array element is
359     selected by specifying its co-ordinates using an integer array. The
360     getter and setter methods used should be appropriate for the type of data
361     contained in the array. Automatic conversion is provided to and from strings.
362     That is GetAsString and SetAsString are safe to use for sql types other than
363     boolean.
364    
365     The interface is returned by a GetAsArray getter method (see ISQLData). A new array
366     can be obtained from the IAttachment interface. The SetAsArray setter method
367     (See ISQLParam) is used to apply an updated or new array to the database using
368     an UPDATE or INSERT statement.
369    
370     }
371    
372     TArrayEventReason = (arChanging,arChanged);
373     IArray = interface;
374     TArrayEventHandler = procedure(Sender: IArray; Reason: TArrayEventReason) of object;
375    
376     IArray = interface(IArrayMetaData)
377 tony 56 ['{631c6bb1-fb49-44fb-a64a-c49859632b88}']
378 tony 45 function GetArrayID: TISC_QUAD;
379     procedure Clear;
380     function IsEmpty: boolean;
381     procedure PreLoad;
382     procedure CancelChanges;
383     procedure SaveChanges;
384     function GetAsInteger(index: array of integer): integer;
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 tony 315 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 tony 45 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 tony 56 function GetAsString(index: array of integer): AnsiString;
399 tony 45 function GetAsVariant(index: array of integer): Variant;
400 tony 315 function GetAsBCD(index: array of integer): tBCD;
401 tony 45 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 tony 315 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 tony 45 procedure SetAsLong(index: array of integer; Value: Long);
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 tony 56 procedure SetAsString(index: array of integer; Value: AnsiString);
418 tony 45 procedure SetAsVariant(index: array of integer; Value: Variant);
419 tony 315 procedure SetAsBcd(index: array of integer; aValue: tBCD);
420 tony 45 procedure SetBounds(dim, UpperBound, LowerBound: integer);
421     function GetAttachment: IAttachment;
422     function GetTransaction: ITransaction;
423     procedure AddEventHandler(Handler: TArrayEventHandler);
424     procedure RemoveEventHandler(Handler: TArrayEventHandler);
425     end;
426    
427     { The Blob metadata interface provides access to the metadata used to describe
428     a blob column in a Firebird table.
429     }
430    
431     IBlobMetaData = interface
432 tony 56 ['{575f3c61-bb33-46a5-8975-bb7d1b6e37cc}']
433 tony 45 function GetSubType: integer;
434     function GetCharSetID: cardinal;
435     function GetCodePage: TSystemCodePage;
436     function GetSegmentSize: cardinal;
437 tony 56 function GetRelationName: AnsiString;
438     function GetColumnName: AnsiString;
439 tony 45 end;
440    
441     {The Blob Parameter block is used to select a Blob Filter}
442    
443 tony 56 IBPBItem = interface (IParameterBlockItem)
444     ['{660822a5-3114-4c16-b6cb-c1a7b2aba70d}']
445     end;
446 tony 45
447 tony 87 IBPB = interface (IParameterBlock<IBPBItem>)
448 tony 56 ['{e0cb9eb5-17f7-4416-b7d1-3cddd1dfca76}']
449     end;
450 tony 45
451     { The Blob Interface provides access to a blob data item.
452    
453     The interface is returned by a GetAsBlob getter method (see ISQLData). A new Blob
454     can be obtained from the IAttachment interface. The SetAsBlob setter method
455     (See ISQLParam) is used to apply an updated or new array to the database using
456     an UPDATE or INSERT statement.
457     }
458    
459     TFBBlobMode = (fbmRead,fbmWrite);
460     TBlobType = (btSegmented,btStream);
461    
462     IBlob = interface(IBlobMetaData)
463 tony 56 ['{3090a145-7780-442b-b15b-efd4568b8611}']
464 tony 45 function GetBPB: IBPB;
465     procedure Cancel;
466     procedure Close;
467     function GetBlobID: TISC_QUAD;
468     function GetBlobMode: TFBBlobMode;
469     function GetBlobSize: Int64;
470     procedure GetInfo(var NumSegments: Int64; var MaxSegmentSize,
471     TotalSize: Int64; var BlobType: TBlobType);
472     function Read(var Buffer; Count: Longint): Longint;
473     function Write(const Buffer; Count: Longint): Longint;
474 tony 56 function LoadFromFile(Filename: AnsiString): IBlob;
475 tony 45 function LoadFromStream(S: TStream) : IBlob;
476 tony 56 function SaveToFile(Filename: AnsiString): IBlob;
477 tony 45 function SaveToStream(S: TStream): IBlob;
478     function GetAsString: rawbytestring;
479     procedure SetAsString(aValue: rawbytestring);
480     function SetString(aValue: rawbytestring): IBlob;
481     function GetAttachment: IAttachment;
482     function GetTransaction: ITransaction;
483     property AsString: rawbytestring read GetAsString write SetAsString;
484     end;
485    
486     { The IColumnMetaData interface provides access to the per column metadata for
487     the output of an SQL Statement.
488     }
489    
490 tony 270 TIBDateTimeFormats = (dfTimestamp, {SQL TIMESTAMP}
491     dfDateTime, {SQL DATETIME}
492 tony 315 dfTime, {SQL TIME}
493     dfTimestampTZ, {SQL_TIMESTAMP_TZ}
494     dfTimeTZ); {SQLTIME_TZ
495 tony 270
496 tony 45 { IColumnMetaData }
497    
498     IColumnMetaData = interface
499 tony 56 ['{c222e6c3-53c1-469f-9e05-0a5c3ef232d8}']
500 tony 45 function GetIndex: integer;
501     function GetSQLType: cardinal;
502 tony 56 function GetSQLTypeName: AnsiString;
503 tony 45 function getSubtype: integer;
504 tony 56 function getRelationName: AnsiString;
505     function getOwnerName: AnsiString;
506     function getSQLName: AnsiString; {Name of the column}
507     function getAliasName: AnsiString; {Alias Name of column or Column Name if no alias}
508     function getName: AnsiString; {Disambiguated uppercase Field Name}
509 tony 45 function getScale: integer;
510     function getCharSetID: cardinal;
511     function getCodePage: TSystemCodePage;
512 tony 310 function GetCharSetWidth: integer;
513 tony 45 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 tony 270 function GetDateTimeStrLength(DateTimeFormat: TIBDateTimeFormats): integer;
518 tony 291 function GetStatement: IStatement;
519     function GetTransaction: ITransaction;
520 tony 371 function GetAttachment: IAttachment;
521 tony 56 property Name: AnsiString read GetName;
522 tony 45 property Size: cardinal read GetSize;
523     property SQLType: cardinal read GetSQLType;
524     property Scale: integer read getScale;
525     property SQLSubtype: integer read getSubtype;
526     property IsNullable: Boolean read GetIsNullable;
527     end;
528    
529     {
530     The IMetaData interface provides access to the set of column metadata
531     for the output of an SQL Statement
532     }
533    
534     { IMetaData }
535    
536     IMetaData = interface
537 tony 56 ['{4dafdbb6-0d36-4f1f-9c95-8b132804b965}']
538 tony 45 function getCount: integer;
539     function getColumnMetaData(index: integer): IColumnMetaData;
540 tony 56 function GetUniqueRelationName: AnsiString; {Non empty if all columns come from the same table}
541     function ByName(Idx: AnsiString): IColumnMetaData;
542 tony 45 property ColMetaData[index: integer]: IColumnMetaData read getColumnMetaData; default;
543     property Count: integer read getCount;
544     end;
545    
546     {
547     The ISQLData interface provides access to the data returned in a field in the
548     current row returned from a query or the result of an SQL Execute statement.
549    
550     It subclasses IColumnMetaData and so also provides access to the metadata
551     associated with the column.
552    
553     The getter and setter methods, and the corresponding properties, provide typed
554     access to the field data. The method/property used should be consistent
555     with the SQL Type. Automatic conversion is provided from strings.
556     That is GetAsString is safe to use for sql types other than boolean.
557     }
558    
559    
560     ISQLData = interface(IColumnMetaData)
561 tony 56 ['{3f493e31-7e3f-4606-a07c-b210b9e3619d}']
562 tony 291 function GetStrDataLength: short;
563 tony 45 function GetAsBoolean: boolean;
564     function GetAsCurrency: Currency;
565     function GetAsInt64: Int64;
566 tony 315 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 tony 45 function GetAsDouble: Double;
575     function GetAsFloat: Float;
576     function GetAsLong: Long;
577     function GetAsPointer: Pointer;
578     function GetAsQuad: TISC_QUAD;
579     function GetAsShort: short;
580 tony 56 function GetAsString: AnsiString;
581 tony 45 function GetIsNull: Boolean;
582     function GetAsVariant: Variant;
583     function GetAsBlob: IBlob; overload;
584     function GetAsBlob(BPB: IBPB): IBlob; overload;
585     function GetAsArray: IArray;
586 tony 315 function GetAsBCD: tBCD;
587 tony 371 function GetAsNumeric: IFBNumeric;
588 tony 45 property AsDate: TDateTime read GetAsDateTime;
589     property AsBoolean:boolean read GetAsBoolean;
590     property AsTime: TDateTime read GetAsDateTime;
591     property AsDateTime: TDateTime read GetAsDateTime ;
592     property AsDouble: Double read GetAsDouble;
593     property AsFloat: Float read GetAsFloat;
594     property AsCurrency: Currency read GetAsCurrency;
595     property AsInt64: Int64 read GetAsInt64 ;
596     property AsInteger: Integer read GetAsLong;
597     property AsLong: Long read GetAsLong;
598     property AsPointer: Pointer read GetAsPointer;
599     property AsQuad: TISC_QUAD read GetAsQuad;
600     property AsShort: short read GetAsShort;
601 tony 56 property AsString: AnsiString read GetAsString;
602 tony 45 property AsVariant: Variant read GetAsVariant ;
603     property AsBlob: IBlob read GetAsBlob;
604     property AsArray: IArray read GetAsArray;
605 tony 315 property AsBCD: tBCD read GetAsBCD;
606 tony 371 property AsNumeric: IFBNumeric read GetAsNumeric;
607 tony 45 property IsNull: Boolean read GetIsNull;
608     property Value: Variant read GetAsVariant;
609     end;
610    
611     { An IResults interface is returned as the result of an SQL Execute statement
612     and provides access to the fields returned, if any. It is a collection of
613     ISQLData interfaces which are, in turn, used to access the data returned by
614     each field of the result set.
615     }
616    
617     IResults = interface
618 tony 56 ['{e836b2bb-93d1-4bbf-a8eb-7ce535de3bb5}']
619 tony 45 function getCount: integer;
620 tony 291 function GetStatement: IStatement;
621 tony 45 function GetTransaction: ITransaction;
622 tony 371 function GetAttachment: IAttachment;
623 tony 56 function ByName(Idx: AnsiString): ISQLData;
624 tony 45 function getSQLData(index: integer): ISQLData;
625 tony 56 procedure GetData(index: integer; var IsNull:boolean; var len: short; var data: PByte);
626 tony 45 procedure SetRetainInterfaces(aValue: boolean);
627     property Data[index: integer]: ISQLData read getSQLData; default;
628     property Count: integer read getCount;
629     end;
630    
631     { An IResultSet interface is returned as the result of an SQL Open Cursor statement
632     (e.g. Select Statement) and provides access to the fields returned, if any
633     for the current row. It is a collection of ISQLData interfaces which are,
634     in turn, used to access the data returned by each field of the current row.
635     }
636     IResultSet = interface(IResults)
637 tony 56 ['{0ae4979b-7857-4e8c-8918-ec6f155b51a0}']
638 tony 350 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 tony 56 function GetCursorName: AnsiString;
645 tony 350 function IsBof: boolean;
646 tony 45 function IsEof: boolean;
647     procedure Close;
648     end;
649    
650     {The ISQLParam interface is used to provide access to each parameter in a
651 tony 349 parametised SQL Statement. The interface comprises the Setter Methods and properties used to
652 tony 45 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 tony 349
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 tony 45 }
667    
668 tony 349 IParamMetaData = interface
669     ['{4e148c4e-2d48-4991-a263-f66eca05c6aa}']
670 tony 45 function GetSQLType: cardinal;
671 tony 56 function GetSQLTypeName: AnsiString;
672 tony 45 function getSubtype: integer;
673     function getScale: integer;
674     function getCharSetID: cardinal;
675     function getCodePage: TSystemCodePage;
676     function getIsNullable: boolean;
677     function GetSize: cardinal;
678 tony 349 property SQLType: cardinal read GetSQLType;
679     end;
680    
681     ISQLParam = interface(IParamMetaData)
682     ['{b22b4578-6d41-4807-a9a9-d2ec8d1d5a14}']
683     function getColMetadata: IParamMetaData;
684 tony 371 function GetStatement: IStatement;
685     function GetTransaction: ITransaction;
686     function GetAttachment: IAttachment;
687 tony 349 function GetIndex: integer;
688     function getName: AnsiString;
689 tony 45 function GetAsBoolean: boolean;
690     function GetAsCurrency: Currency;
691     function GetAsInt64: Int64;
692 tony 315 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 tony 45 function GetAsDouble: Double;
701     function GetAsFloat: Float;
702     function GetAsLong: Long;
703     function GetAsPointer: Pointer;
704     function GetAsQuad: TISC_QUAD;
705     function GetAsShort: short;
706 tony 56 function GetAsString: AnsiString;
707 tony 45 function GetIsNull: boolean;
708     function GetAsVariant: Variant;
709     function GetAsBlob: IBlob;
710     function GetAsArray: IArray;
711 tony 315 function GetAsBCD: tBCD;
712 tony 371 function GetAsNumeric: IFBNumeric;
713 tony 45 procedure Clear;
714     function GetModified: boolean;
715     procedure SetAsBoolean(AValue: boolean);
716     procedure SetAsCurrency(aValue: Currency);
717     procedure SetAsInt64(aValue: Int64);
718     procedure SetAsDate(aValue: TDateTime);
719     procedure SetAsLong(aValue: Long);
720 tony 315 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 tony 45 procedure SetAsDouble(aValue: Double);
730     procedure SetAsFloat(aValue: Float);
731     procedure SetAsPointer(aValue: Pointer);
732     procedure SetAsShort(aValue: Short);
733 tony 56 procedure SetAsString(aValue: AnsiString);
734 tony 45 procedure SetAsVariant(aValue: Variant);
735     procedure SetIsNull(aValue: Boolean);
736     procedure SetAsBlob(aValue: IBlob);
737     procedure SetAsArray(anArray: IArray);
738     procedure SetAsQuad(aValue: TISC_QUAD);
739     procedure SetCharSetID(aValue: cardinal);
740 tony 315 procedure SetAsBcd(aValue: tBCD);
741 tony 371 procedure SetAsNumeric(Value: IFBNumeric);
742 tony 45 property AsDate: TDateTime read GetAsDateTime write SetAsDate;
743     property AsBoolean:boolean read GetAsBoolean write SetAsBoolean;
744     property AsTime: TDateTime read GetAsDateTime write SetAsTime;
745     property AsDateTime: TDateTime read GetAsDateTime write SetAsDateTime;
746     property AsDouble: Double read GetAsDouble write SetAsDouble;
747     property AsFloat: Float read GetAsFloat write SetAsFloat;
748     property AsCurrency: Currency read GetAsCurrency write SetAsCurrency;
749     property AsInt64: Int64 read GetAsInt64 write SetAsInt64;
750     property AsInteger: Integer read GetAsLong write SetAsLong;
751     property AsLong: Long read GetAsLong write SetAsLong;
752     property AsPointer: Pointer read GetAsPointer write SetAsPointer;
753     property AsShort: Short read GetAsShort write SetAsShort;
754 tony 56 property AsString: AnsiString read GetAsString write SetAsString;
755 tony 45 property AsVariant: Variant read GetAsVariant write SetAsVariant;
756     property AsBlob: IBlob read GetAsBlob write SetAsBlob;
757     property AsArray: IArray read GetAsArray write SetAsArray;
758 tony 315 property AsBCD: tBCD read GetAsBCD write SetAsBCD;
759 tony 371 property AsNumeric: IFBNumeric read GetAsNumeric write SetAsNumeric;
760 tony 45 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 tony 56 property Name: AnsiString read GetName;
766 tony 45 end;
767    
768     {
769     The ISQLParams interface provides access to the collection of parameters used
770     for the input to an SQL Statement
771     }
772    
773     ISQLParams = interface
774 tony 56 ['{c6d95ac7-b2b7-461b-b890-afef0acbb077}']
775 tony 45 function getCount: integer;
776     function getSQLParam(index: integer): ISQLParam;
777 tony 56 function ByName(Idx: AnsiString): ISQLParam ;
778 tony 45 function GetModified: Boolean;
779 tony 287 function GetHasCaseSensitiveParams: Boolean;
780 tony 371 function GetStatement: IStatement;
781     function GetTransaction: ITransaction;
782     function GetAttachment: IAttachment;
783     procedure Clear;
784 tony 45 property Modified: Boolean read GetModified;
785     property Params[index: integer]: ISQLParam read getSQLParam; default;
786     property Count: integer read getCount;
787     end;
788    
789 tony 47
790     TPerfStats = (psCurrentMemory, psMaxMemory,
791     psRealTime, psUserTime, psBuffers,
792     psReads, psWrites, psFetches,psDeltaMemory);
793    
794 tony 209 TPerfCounters = array[TPerfStats] of Int64;
795 tony 47
796 tony 345 {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 tony 45 {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 tony 359 TStatementFlag = (stHasCursor,stRepeatExecute,stScrollable);
814     TStatementFlags = set of TStatementFlag;
815    
816 tony 45 IStatement = interface
817 tony 56 ['{a260576d-a07d-4a66-b02d-1b72543fd7cf}']
818 tony 45 function GetMetaData: IMetaData; {Output Metadata}
819     function GetSQLParams: ISQLParams;{Statement Parameters}
820 tony 56 function GetPlan: AnsiString;
821 tony 45 function GetRowsAffected(var SelectCount, InsertCount, UpdateCount, DeleteCount: integer): boolean;
822     function GetSQLStatementType: TIBSQLStatementTypes;
823 tony 345 function GetSQLStatementTypeName: AnsiString;
824 tony 56 function GetSQLText: AnsiString;
825 tony 263 function GetProcessedSQLText: AnsiString;
826 tony 45 function GetSQLDialect: integer;
827 tony 359 function GetFlags: TStatementFlags;
828 tony 45 function IsPrepared: boolean;
829 tony 345 function HasBatchMode: boolean;
830     function IsInBatchMode: boolean;
831 tony 350 procedure Prepare(aTransaction: ITransaction=nil); overload;
832     procedure Prepare(CursorName: AnsiString; aTransaction: ITransaction=nil); overload;
833 tony 45 function Execute(aTransaction: ITransaction=nil): IResults;
834 tony 350 function OpenCursor(aTransaction: ITransaction=nil): IResultSet; overload;
835     function OpenCursor(Scrollable: boolean; aTransaction: ITransaction=nil): IResultSet; overload;
836 tony 45 function GetAttachment: IAttachment;
837     function GetTransaction: ITransaction;
838     procedure SetRetainInterfaces(aValue: boolean);
839 tony 47 procedure EnableStatistics(aValue: boolean);
840     function GetPerfStatistics(var stats: TPerfCounters): boolean;
841 tony 345 {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 tony 347 {Stale Reference Check}
849     procedure SetStaleReferenceChecks(Enable:boolean); {default true}
850     function GetStaleReferenceChecks: boolean;
851 tony 345
852 tony 45 property MetaData: IMetaData read GetMetaData;
853     property SQLParams: ISQLParams read GetSQLParams;
854     property SQLStatementType: TIBSQLStatementTypes read GetSQLStatementType;
855     end;
856    
857 tony 359 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 tony 45 {Transaction Parameter Block: (TPB)
879    
880     The TPB provides the parameters used when starting a transaction. It is allocated
881     empty by the FirebirdAPI and the parameters are then added to it. Each individual
882     parameter may be accessed by the ITPBItem interface which can be used to set the
883     value, if any, of the parameter.
884    
885     The TPB parameters, and the associated symbolic codes and parameter values may be
886     found in the Interbase 6.0 API Guide.
887     }
888    
889 tony 315 ITPBItem = interface(IParameterBlockItemWithTypeName)
890 tony 56 ['{544c1f2b-7c12-4a87-a4a5-face7ea72671}']
891     end;
892 tony 45
893 tony 315 ITPB = interface(IParameterBlockWithTypeNames<ITPBItem>)
894 tony 56 ['{7369b0ff-defe-437b-81fe-19b211d42d25}']
895 tony 363 function AsText: AnsiString;
896 tony 56 end;
897 tony 45
898     {The ITransactionAction interface provides access to a Transaction once it
899     has been initially started. After a Commit or Rollback, a transaction
900     may be restarted, optinally with a new TPB.
901    
902     A multi-database transaction is started from the FirebirdAPI. A single database
903     transaction is started from the IAttachment interface.
904     }
905    
906     TTransactionAction = (TARollback, TACommit, TACommitRetaining, TARollbackRetaining);
907     TTransactionCompletion = TARollback.. TACommit;
908    
909     ITransaction = interface
910 tony 56 ['{30928d0e-a9d7-4c61-b7cf-14f4f38abe2a}']
911 tony 45 function getTPB: ITPB;
912     procedure Start(DefaultCompletion: TTransactionCompletion=taCommit);
913     function GetInTransaction: boolean;
914 tony 359 function GetIsReadOnly: boolean;
915     function GetTransactionID: integer;
916 tony 363 function GetJournalingActive(attachment: IAttachment): boolean;
917     function GetDefaultCompletion: TTransactionCompletion;
918 tony 45 procedure PrepareForCommit; {Two phase commit - stage 1}
919     procedure Commit(Force: boolean=false);
920     procedure CommitRetaining;
921     function HasActivity: boolean;
922     procedure Rollback(Force: boolean=false);
923     procedure RollbackRetaining;
924     function GetAttachmentCount: integer;
925     function GetAttachment(index: integer): IAttachment;
926 tony 359 function GetTrInformation(Requests: array of byte): ITrInformation; overload;
927     function GetTrInformation(Request: byte): ITrInformation; overload;
928 tony 363 function GetTransactionName: AnsiString;
929     procedure SetTransactionName(aValue: AnsiString);
930 tony 45 property InTransaction: boolean read GetInTransaction;
931 tony 363 property TransactionName: AnsiString read GetTransactionName write SetTransactionName;
932 tony 45 end;
933    
934     { The IEvents Interface is used to handle events from a single database. The
935     interface is allocated from the IAttachment Interface.
936    
937     Note that the EventHandler called when an event occurs following AsynWaitForEvent
938     is called in a different thread to the calling program and TThread.Synchronize
939     may be needed to pass the event back to the main thread.
940    
941     Neither AsyncWaitForEvent nor WaitForEvent is intended to be thread safe
942     in a multi-threaded environment and should always be called from the main
943     thread.
944     }
945    
946     TEventInfo = record
947 tony 56 EventName: AnsiString;
948 tony 45 Count: integer;
949     end;
950    
951     TEventCounts = array of TEventInfo;
952     IEvents = interface;
953     TEventHandler = procedure(Sender: IEvents) of object;
954    
955     { IEvents }
956    
957     IEvents = interface
958 tony 56 ['{6a0be233-ed08-4524-889c-2e45d0c20e5f}']
959 tony 45 procedure GetEvents(EventNames: TStrings);
960     procedure SetEvents(EventNames: TStrings); overload;
961 tony 381 procedure SetEvents(EventName: string); overload;
962 tony 45 procedure Cancel;
963     function ExtractEventCounts: TEventCounts;
964     procedure WaitForEvent;
965     procedure AsyncWaitForEvent(EventHandler: TEventHandler);
966     function GetAttachment: IAttachment;
967     end;
968    
969 tony 315 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 tony 45 {The IDBInformation Interface.
1004    
1005     An IDBInformation interface is returned by the IAttachment GetDBInformation
1006     method. The interface provides access to the information requested and
1007     returned by the method.
1008    
1009     IDBInformation itself gives access to a collection of IDBInfoItems. Each one
1010     provides information requested, as indicated by the ItemType and the actual
1011     value of the information. In some cases, the returned item is itself a
1012     colletion of IDBInfoItems.
1013    
1014     The IDBInformation items, and the associated symbolic codes and parameter values may be
1015     found in the Interbase 6.0 API Guide.
1016     }
1017    
1018     TDBOperationCount = record
1019     TableID: UShort;
1020     Count: cardinal;
1021     end;
1022    
1023     TDBOperationCounts = array of TDBOperationCount;
1024    
1025     IDBInfoItem = interface
1026 tony 56 ['{eeb97b51-ec0f-473f-9f75-c1721f055fcb}']
1027 tony 45 function getItemType: byte;
1028     function getSize: integer;
1029     procedure getRawBytes(var Buffer);
1030 tony 56 function getAsString: AnsiString;
1031 tony 345 function getAsInteger: int64;
1032 tony 56 procedure DecodeIDCluster(var ConnectionType: integer; var DBFileName, DBSiteName: AnsiString);
1033 tony 45 function getAsBytes: TByteArray;
1034 tony 143 function getAsDateTime: TDateTime;
1035 tony 56 procedure DecodeVersionString(var Version: byte; var VersionString: AnsiString);
1036 tony 45 function getOperationCounts: TDBOperationCounts;
1037     procedure DecodeUserNames(UserNames: TStrings);
1038    
1039     {user names only}
1040     function GetCount: integer;
1041     function GetItem(index: integer): IDBInfoItem;
1042     function Find(ItemType: byte): IDBInfoItem;
1043 tony 345 property AsInteger: int64 read getAsInteger;
1044 tony 56 property AsString: AnsiString read GetAsString;
1045 tony 45 property Count: integer read GetCount;
1046     property Items[index: integer]: IDBInfoItem read getItem; default;
1047     end;
1048    
1049     { IDBInformation }
1050    
1051     IDBInformation = interface
1052 tony 56 ['{7ac6777f-f0a9-498a-9f5c-4a57a554df81}']
1053 tony 45 function GetCount: integer;
1054     function GetItem(index: integer): IDBInfoItem;
1055     function Find(ItemType: byte): IDBInfoItem;
1056     procedure PrintBuf; {can be used to print buffer in hex for debugging}
1057     property Count: integer read GetCount;
1058     property Items[index: integer]: IDBInfoItem read getItem; default;
1059     end;
1060    
1061 tony 143 {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 tony 45 {The Database Parameter Block (DPB).
1076    
1077     The DPB provides the parameters used when connecting to a database. It is allocated
1078     empty by the FirebirdAPI and the parameters are then added to it. Each individual
1079     parameter may be accessed by the IDPBItem interface which can be used to set the
1080     value, if any, of the parameter.
1081    
1082     The DPB parameters, and the associated symbolic codes and parameter values may be
1083     found in the Interbase 6.0 API Guide.
1084     }
1085    
1086 tony 315 IDPBItem = interface(IParameterBlockItemWithTypeName)
1087 tony 56 ['{123d4ad0-087a-4cd1-a344-1b3d03b30673}']
1088     end;
1089 tony 45
1090 tony 315 IDPB = interface(IParameterBlockWithTypeNames<IDPBItem>)
1091     ['{e676067b-1cf4-4eba-9256-9724f57e0d16}']
1092     end;
1093 tony 45
1094 tony 363 {Journaling options. Default is [joReadWriteTransactions,joModifyQueries] }
1095    
1096     TJournalOption = (joReadOnlyTransactions, joReadWriteTransactions,
1097 tony 371 joModifyQueries, joReadOnlyQueries,joNoServerTable);
1098 tony 363
1099     TJournalOptions = set of TJournalOption;
1100    
1101 tony 45 {The IAttachment interface provides access to a Database Connection. It may be
1102     used to:
1103    
1104     a. Disconnect and reconnect to the database.
1105    
1106     b. Start a Transaction on the database
1107    
1108     c. Execute directly SQL DDL Statements and others that return no information.
1109    
1110     d. OpenCursors (i.e. execute SQL Select statements and return the results)
1111    
1112     e. Prepare SQL Statements, returning an IStatement interface for further processing.
1113    
1114     f. Provide access to an SQL Event Handler.
1115    
1116     g. Access Database Information.
1117    
1118     h. Support the handling of Array and Blob data.
1119    
1120     Note that SQL statements can be prepared with named parameters (PSQL style).
1121     This then allows the parameters to be accessed by name. The same name can
1122     be used for more than one parameter, allowing a single operation to be used
1123     to set all parameters with the same name.
1124     }
1125    
1126     { IAttachment }
1127    
1128     IAttachment = interface
1129 tony 56 ['{466e9b67-9def-4807-b3e7-e08a35e7185c}']
1130 tony 263 function getFirebirdAPI: IFirebirdAPI;
1131 tony 45 function getDPB: IDPB;
1132     function AllocateBPB: IBPB;
1133 tony 143 function AllocateDIRB: IDIRB;
1134 tony 45 procedure Connect;
1135     procedure Disconnect(Force: boolean=false);
1136     function IsConnected: boolean;
1137     procedure DropDatabase;
1138 tony 363 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 tony 56 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;
1147     procedure ExecImmediate(TPB: array of byte; sql: AnsiString); overload;
1148     function ExecuteSQL(TPB: array of byte; sql: AnsiString; SQLDialect: integer; params: array of const): IResults; overload;
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;
1152     function OpenCursor(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer;
1153 tony 350 Scrollable: boolean=false): IResultSet; overload;
1154     function OpenCursor(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer;
1155 tony 45 params: array of const): IResultSet; overload;
1156 tony 350 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;
1159 tony 56 function OpenCursor(transaction: ITransaction; sql: AnsiString;
1160 tony 45 params: array of const): IResultSet; overload;
1161 tony 350 function OpenCursor(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer; Scrollable: boolean;
1162     params: array of const): IResultSet; overload;
1163 tony 56 function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer;
1164 tony 350 Scrollable: boolean=false): IResultSet; overload;
1165     function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer;
1166 tony 45 params: array of const): IResultSet; overload;
1167 tony 350 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 tony 56 function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString;
1171 tony 45 params: array of const): IResultSet; overload;
1172 tony 350 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 tony 56 function OpenCursorAtStart(sql: AnsiString;
1178 tony 45 params: array of const): IResultSet; overload;
1179 tony 350 function Prepare(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer; CursorName: AnsiString=''): IStatement; overload;
1180     function Prepare(transaction: ITransaction; sql: AnsiString; CursorName: AnsiString=''): IStatement; overload;
1181 tony 56 function PrepareWithNamedParameters(transaction: ITransaction; sql: AnsiString;
1182 tony 270 aSQLDialect: integer; GenerateParamNames: boolean=false;
1183 tony 350 CaseSensitiveParams: boolean = false; CursorName: AnsiString=''): IStatement; overload;
1184 tony 56 function PrepareWithNamedParameters(transaction: ITransaction; sql: AnsiString;
1185 tony 270 GenerateParamNames: boolean=false;
1186 tony 350 CaseSensitiveParams: boolean = false; CursorName: AnsiString=''): IStatement; overload;
1187 tony 45
1188     {Events}
1189     function GetEventHandler(Events: TStrings): IEvents; overload;
1190 tony 56 function GetEventHandler(Event: AnsiString): IEvents; overload;
1191 tony 45
1192     {Blob - may use to open existing Blobs. However, ISQLData.AsBlob is preferred}
1193    
1194 tony 56 function CreateBlob(transaction: ITransaction; RelationName, ColumnName: AnsiString; BPB: IBPB=nil): IBlob; overload;
1195 tony 45 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 tony 291 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 tony 345 function GetInlineBlobLimit: integer;
1200     procedure SetInlineBlobLimit(limit: integer);
1201 tony 45
1202     {Array - may use to open existing arrays. However, ISQLData.AsArray is preferred}
1203    
1204 tony 291 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 tony 56 function CreateArray(transaction: ITransaction; RelationName, ColumnName: AnsiString): IArray; overload;
1207 tony 45 function CreateArray(transaction: ITransaction; ArrayMetaData: IArrayMetaData): IArray; overload;
1208 tony 56 function CreateArrayMetaData(SQLType: cardinal; tableName: AnsiString; columnName: AnsiString;
1209 tony 47 Scale: integer; size: cardinal; charSetID: cardinal; dimensions: cardinal;
1210     bounds: TArrayBounds): IArrayMetaData;
1211 tony 45
1212     {Database Information}
1213     function GetSQLDialect: integer;
1214 tony 363 function GetAttachmentID: integer;
1215 tony 56 function GetBlobMetaData(Transaction: ITransaction; tableName, columnName: AnsiString): IBlobMetaData;
1216     function GetArrayMetaData(Transaction: ITransaction; tableName, columnName: AnsiString): IArrayMetaData;
1217 tony 45 function GetDBInformation(Requests: array of byte): IDBInformation; overload;
1218     function GetDBInformation(Request: byte): IDBInformation; overload;
1219 tony 143 function GetDBInformation(Requests: IDIRB): IDBInformation; overload;
1220 tony 117 function GetConnectString: AnsiString;
1221     function GetRemoteProtocol: AnsiString;
1222 tony 143 function GetAuthenticationMethod: AnsiString;
1223 tony 209 function GetSecurityDatabase: AnsiString;
1224 tony 117 function GetODSMajorVersion: integer;
1225     function GetODSMinorVersion: integer;
1226 tony 266 procedure getFBVersion(version: TStrings);
1227 tony 45 function HasActivity: boolean;
1228 tony 315 function HasDecFloatSupport: boolean;
1229 tony 345 function HasBatchMode: boolean;
1230 tony 352 function HasScollableCursors: boolean;
1231 tony 371 function HasTable(aTableName: AnsiString): boolean; {case sensitive}
1232     function HasFunction(aFunctionName: AnsiString): boolean; {case sensitive}
1233     function HasProcedure(aProcName: AnsiString): boolean; {case sensitive}
1234 tony 60
1235     {Character Sets}
1236 tony 371 function GetCharSetID: integer; {connection character set}
1237 tony 109 function HasDefaultCharSet: boolean;
1238     function GetDefaultCharSetID: integer;
1239 tony 60 function GetCharsetName(CharSetID: integer): AnsiString;
1240     function CharSetID2CodePage(CharSetID: integer; var CodePage: TSystemCodePage): boolean;
1241     function CodePage2CharSetID(CodePage: TSystemCodePage; var CharSetID: integer): boolean;
1242     function CharSetName2CharSetID(CharSetName: AnsiString; var CharSetID: integer): boolean;
1243     function CharSetWidth(CharSetID: integer; var Width: integer): boolean;
1244     procedure RegisterCharSet(CharSetName: AnsiString; CodePage: TSystemCodePage;
1245     AllowReverseLookup:boolean; out CharSetID: integer);
1246 tony 45
1247 tony 315 {Time Zone Database}
1248     function GetTimeZoneServices: ITimeZoneServices;
1249     function HasTimeZoneSupport: boolean;
1250 tony 363
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 tony 371 function StartJournaling(S: TStream; Options: TJournalOptions): integer; overload;
1257 tony 363 procedure StopJournaling(RetainJournal: boolean);
1258 tony 315 end;
1259    
1260 tony 231 TProtocolAll = (TCP, SPX, NamedPipe, Local, inet, inet4, inet6, wnet, xnet, unknownProtocol);
1261 tony 143 TProtocol = TCP..xnet;
1262 tony 45
1263     {Service Parameter Block (SPB).
1264    
1265     The SPB provides the parameters used when connecting to a Service Manager. It is
1266     allocated empty by the FirebirdAPI and the parameters are then added to it. Each
1267     individual parameter may be accessed by the ISPBItem interface which can be used
1268     to set the value, if any, of the parameter.
1269    
1270     The SPB parameters, and the associated symbolic codes and parameter values may be
1271     found in the Interbase 6.0 API Guide.
1272    
1273     }
1274    
1275 tony 315 ISPBItem = interface(IParameterBlockItemWithTypeName)
1276 tony 56 ['{5d08ae2b-4519-41bd-8b40-97cd451c3f6a}']
1277     end;
1278 tony 45
1279 tony 315 ISPB = interface(IParameterBlockWithTypeNames<ISPBItem>)
1280 tony 56 ['{2c5836fd-41ed-4426-9b7d-5af580ec2659}']
1281     end;
1282 tony 45
1283     {Service Query Parameter Block (SQPB).
1284    
1285     This is a specialised parameter block used to send data to a service manager
1286     in a Query Request.
1287     }
1288    
1289     ISQPBItem = interface(IParameterBlockItem)
1290 tony 56 ['{b07841a6-33b3-47f0-b5a2-028cbc86dc97}']
1291 tony 45 function CopyFrom(source: TStream; count: integer): integer;
1292     end;
1293    
1294 tony 56 ISQPB = interface(IParameterBlock<ISQPBItem>)
1295     ['{8553e66b-ee62-498b-8431-dff030211447}']
1296     end;
1297 tony 45
1298     {Service Request Block (SRB).
1299    
1300     The SRB specifies what is requested from the Service Manager when starting a
1301     service or querying a service. It is allocated empty by the ServiceManager API and
1302     the parameters are then added to it. Each individual parameter may be accessed
1303     by the ISRBItem interface which can be used to set the value, if any, of the parameter.
1304    
1305     The SRB parameters, and the associated symbolic codes and parameter values may be
1306     found in the Interbase 6.0 API Guide.
1307    
1308     }
1309    
1310 tony 56 ISRBItem = interface(IParameterBlockItem)
1311     ['{47ec790e-f265-4b30-9dcd-261e51677245}']
1312     end;
1313 tony 45
1314 tony 56 ISRB = interface(IParameterBlock<ISRBItem>)
1315     ['{9f2e204f-3c33-4e44-90f9-9135e95dafb9}']
1316     end;
1317 tony 45
1318     {The Service Query Results Interface.
1319    
1320     An IServiceQueryResults interface is returned by the IServiceManager Query
1321     method. The interface provides access to the information requested and
1322     returned by the method.
1323    
1324     IServiceQueryResults itself gives access to a collection of IServiceQueryResultItem.
1325     Each one provides information requested, as indicated by the ItemType and the actual
1326     value of the information. In some cases, the returned item is itself a
1327     collection of IServiceQueryResultSubItem.
1328    
1329     The IServiceQueryResultItem items, and the associated symbolic codes and parameter values may be
1330     found in the Interbase 6.0 API Guide.
1331     }
1332    
1333     IServiceQueryResultSubItem = interface
1334 tony 56 ['{8a4c381e-9923-4cc9-a96b-553729248640}']
1335 tony 45 function getItemType: byte;
1336     function getSize: integer;
1337     procedure getRawBytes(var Buffer);
1338 tony 56 function getAsString: AnsiString;
1339 tony 345 function getAsInteger: int64;
1340 tony 45 function getAsByte: byte;
1341     function CopyTo(stream: TStream; count: integer): integer;
1342 tony 56 property AsString: AnsiString read getAsString;
1343 tony 345 property AsInteger: int64 read getAsInteger;
1344 tony 45 property AsByte: byte read getAsByte;
1345     end;
1346    
1347     IServiceQueryResultItem = interface(IServiceQueryResultSubItem)
1348 tony 56 ['{b2806886-206c-4024-8df9-5fe0a7630a5e}']
1349 tony 45 function getCount: integer;
1350     function getItem(index: integer): IServiceQueryResultSubItem;
1351     function find(ItemType: byte): IServiceQueryResultSubItem;
1352     property Items[index: integer]: IServiceQueryResultSubItem read getItem; default;
1353     property Count: integer read getCount;
1354     end;
1355    
1356     IServiceQueryResults = interface
1357 tony 56 ['{8fbbef7d-fe03-4409-828a-a787d34ef531}']
1358 tony 45 function getCount: integer;
1359     function getItem(index: integer): IServiceQueryResultItem;
1360     function find(ItemType: byte): IServiceQueryResultItem;
1361     procedure PrintBuf; {can be used to print buffer in hex for debugging}
1362     property Items[index: integer]: IServiceQueryResultItem read getItem; default;
1363     property Count: integer read getCount;
1364     end;
1365    
1366 tony 263 IFirebirdLibrary = interface;
1367    
1368 tony 45 {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.
1371    
1372     The interface is returned by the FirebirdAPI GetService Manager method.
1373     }
1374    
1375     { IServiceManager }
1376    
1377     IServiceManager = interface
1378 tony 56 ['{905b587d-1e1f-4e40-a3f8-a3519f852e48}']
1379 tony 263 function getFirebirdAPI: IFirebirdAPI;
1380 tony 45 function getSPB: ISPB;
1381 tony 56 function getServerName: AnsiString;
1382 tony 209 function getProtocol: TProtocol;
1383     function getPortNo: AnsiString;
1384 tony 45 procedure Attach;
1385     procedure Detach(Force: boolean=false);
1386     function IsAttached: boolean;
1387     function AllocateSRB: ISRB;
1388     function AllocateSQPB: ISQPB;
1389 tony 209 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 tony 45 end;
1393    
1394 tony 263 {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 tony 45 {The Firebird API.
1406    
1407     This is the base interface and is used to create/open a database connection, to
1408     start a transaction on multiple databases and the access the service manager.
1409    
1410     The interface is returned by the FirebirdAPI function.
1411     }
1412    
1413 tony 315 { IFirebirdAPI }
1414    
1415 tony 45 IFirebirdAPI = interface
1416 tony 56 ['{edeee691-c8d3-4dcf-a780-cd7e432821d5}']
1417 tony 45 {Database connections}
1418     function AllocateDPB: IDPB;
1419 tony 56 function OpenDatabase(DatabaseName: AnsiString; DPB: IDPB; RaiseExceptionOnConnectError: boolean=true): IAttachment;
1420     function CreateDatabase(DatabaseName: AnsiString; DPB: IDPB; RaiseExceptionOnError: boolean=true): IAttachment; overload;
1421     function CreateDatabase(sql: AnsiString; aSQLDialect: integer; RaiseExceptionOnError: boolean=true): IAttachment; overload;
1422 tony 45
1423     {Start Transaction against multiple databases}
1424     function AllocateTPB: ITPB;
1425     function StartTransaction(Attachments: array of IAttachment;
1426 tony 363 TPB: array of byte; DefaultCompletion: TTransactionCompletion=taCommit;
1427     aName: AnsiString=''): ITransaction; overload;
1428 tony 45 function StartTransaction(Attachments: array of IAttachment;
1429 tony 363 TPB: ITPB; DefaultCompletion: TTransactionCompletion=taCommit;
1430     aName: AnsiString=''): ITransaction; overload;
1431 tony 45
1432     {Service Manager}
1433     function HasServiceAPI: boolean;
1434     function AllocateSPB: ISPB;
1435 tony 143 function GetServiceManager(ServerName: AnsiString; Protocol: TProtocol; SPB: ISPB): IServiceManager; overload;
1436     function GetServiceManager(ServerName: AnsiString; Port: AnsiString; Protocol: TProtocol; SPB: ISPB): IServiceManager; overload;
1437 tony 45
1438     {Information}
1439     function GetStatus: IStatus;
1440     function HasRollbackRetaining: boolean;
1441     function IsEmbeddedServer: boolean;
1442 tony 56 function GetImplementationVersion: AnsiString;
1443 tony 308 function GetClientMajor: integer;
1444     function GetClientMinor: integer;
1445 tony 315 function HasDecFloatSupport: boolean;
1446     function HasLocalTZDB: boolean;
1447     function HasTimeZoneSupport: boolean;
1448     function HasExtendedTZSupport: boolean;
1449 tony 45
1450     {Firebird 3 API}
1451     function HasMasterIntf: boolean;
1452 tony 315 function GetIMaster: TObject; deprecated 'Use FirebirdAPI.QueryInterface and FBClientLib.pas IFBIMasterProvider instead';
1453 tony 263 function GetFBLibrary: IFirebirdLibrary;
1454 tony 45 end;
1455    
1456     type
1457     TOnGetLibraryName = procedure(var libname: string);
1458    
1459     const
1460     OnGetLibraryName: TOnGetLibraryName = nil;
1461     AllowUseOfFBLIB: boolean = false;
1462    
1463     type
1464     { EIBError }
1465    
1466     EIBError = class(EDatabaseError)
1467     private
1468     FSQLCode: Long;
1469     public
1470 tony 56 constructor Create(ASQLCode: Long; Msg: AnsiString);
1471 tony 45 property SQLCode: Long read FSQLCode;
1472     end;
1473    
1474     { EIBInterBaseError - Firebird Engine errors}
1475    
1476     EIBInterBaseError = class(EIBError)
1477     private
1478     FIBErrorCode: Long;
1479 tony 371 FStatus: IStatus;
1480 tony 45 public
1481 tony 371 constructor Create(aStatus: IStatus); overload;
1482 tony 56 constructor Create(ASQLCode: Long; AIBErrorCode: Long; Msg: AnsiString); overload;
1483 tony 45 property IBErrorCode: Long read FIBErrorCode;
1484 tony 371 property Status: IStatus read FStatus;
1485 tony 45 end;
1486    
1487     {IB Client Exceptions}
1488     EIBClientError = class(EIBError);
1489    
1490 tony 345 {Used to explicitly report a Batch Buffer overflow}
1491     EIBBatchBufferOverflow = class(EIBError);
1492    
1493 tony 45 {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
1496     select an implementation of the Firebird API (legacy 2.5 or 3.0.
1497     }
1498    
1499     function FirebirdAPI: IFirebirdAPI;
1500    
1501     {IBX support functions. Probably best ignored i.e. always used the FirebirdAPI
1502 tony 315 function to load the library and check if it's loaded.}
1503 tony 45
1504     function TryIBLoad: Boolean;
1505     procedure CheckIBLoaded;
1506    
1507 tony 263 {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 tony 371 {$if not declared(Null)} {Needed for Delphi}
1514 tony 363 function Null: Variant; // Null standard constant
1515     {$define NEEDNULLFUNCTION}
1516     {$ifend}
1517 tony 315
1518 tony 45 implementation
1519    
1520 tony 363 uses FBClientAPI {$if not declared(NULL)}, Variants {$ifend}
1521 tony 45 {$IFDEF USELEGACYFIREBIRDAPI}, FB25ClientAPI {$ENDIF}
1522     {$IFDEF USEFIREBIRD3API}, FB30ClientAPI {$ENDIF};
1523    
1524 tony 263 var FDefaultFBLibrary: IFirebirdLibrary;
1525 tony 45
1526 tony 263 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 tony 45 function FirebirdAPI: IFirebirdAPI;
1555     begin
1556 tony 263 if FDefaultFBLibrary = nil then
1557 tony 45 CheckIBLoaded;
1558 tony 263 Result := FDefaultFBLibrary.GetFirebirdAPI;
1559 tony 45 end;
1560    
1561     function TryIBLoad: Boolean;
1562 tony 263 var fblib: IFirebirdLibrary;
1563 tony 45 begin
1564 tony 263 Result := FDefaultFBLibrary <> nil;
1565 tony 45 try
1566     if not Result then
1567     begin
1568 tony 263 fblib := TFBLibraryImpl.Create;
1569     if (fblib <> nil) and (fblib.GetFirebirdAPI <> nil) then
1570     FDefaultFBLibrary := fblib;
1571     Result := FDefaultFBLibrary <> nil;
1572 tony 45 end;
1573     except
1574     SysUtils.showexception(ExceptObject,ExceptAddr);
1575     Result := false;
1576     end;
1577     end;
1578    
1579     procedure CheckIBLoaded;
1580     begin
1581     if not TryIBLoad then
1582     IBError(ibxeInterBaseMissing, [nil]);
1583     end;
1584    
1585 tony 263 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 tony 45 { EIBError }
1603    
1604 tony 56 constructor EIBError.Create(ASQLCode: Long; Msg: AnsiString);
1605 tony 45 begin
1606     inherited Create(Msg);
1607     FSQLCode := ASQLCode;
1608     end;
1609    
1610     { EIBInterBaseError }
1611    
1612 tony 371 constructor EIBInterBaseError.Create(aStatus: IStatus);
1613 tony 45 begin
1614 tony 371 inherited Create(aStatus.Getsqlcode,aStatus.GetMessage);
1615     FIBErrorCode := aStatus.GetIBErrorCode;
1616     FStatus := aStatus;
1617 tony 45 end;
1618    
1619     constructor EIBInterBaseError.Create(ASQLCode: Long; AIBErrorCode: Long;
1620 tony 56 Msg: AnsiString);
1621 tony 45 begin
1622     inherited Create(ASQLCode,Msg);
1623     FIBErrorCode := AIBErrorCode;
1624     end;
1625    
1626 tony 363 {$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 tony 45
1634     initialization
1635 tony 263 FDefaultFBLibrary := nil;
1636 tony 45
1637 tony 209 finalization
1638 tony 263 FDefaultFBLibrary := nil;
1639 tony 45
1640     end.
1641    

Properties

Name Value
svn:eol-style native