ViewVC Help

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

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

Comparing ibx/trunk/fbintf/IB.pas (file contents):
Revision 45 by tony, Tue Dec 6 10:33:46 2016 UTC vs.
Revision 231 by tony, Mon Apr 16 08:32:21 2018 UTC

#	Line 60 | Line 60
60		{                                                                        }
61		{************************************************************************}
62		unit IB;
63	+	{$IFDEF MSWINDOWS}
64	+	{$DEFINE WINDOWS}
65	+	{$ENDIF}
66
67		{$IFDEF FPC}
68	<	{$mode objfpc}{$H+}
68	>	{$mode delphi}
69		{$codepage UTF8}
70		{$interfaces COM}
71	<	{$IF FPC_FULLVERSION < 30000 }
71	>	{$IF defined(FPC) and (FPC_FULLVERSION < 30000) }
72		{$ERROR FPC Version 3.0.0 or later is required}
73	<	{$ENDIF}
73	>	{$IFEND}
74		{$ENDIF}
75
76		{$DEFINE USEFIREBIRD3API}
#	Line 103 | Line 106 | unit IB;
106
107		5. Straightforward progammatic access to the Firebird API from Pascal programs.
108
109	+	6. FPC and Delphi Support.
110	+
111		String Types
112		============
113
#	Line 119 | Line 124 | interface
124		uses
125		Classes, SysUtils, DB, FBMessages, IBExternals;
126
127	+	const
128	+	{Interface version information}
129	+	FBIntf_Major = 1;
130	+	FBIntf_Minor = 1;
131	+	FBIntf_Release = 2;
132	+	FBIntf_Version = '1.1.2';
133	+
134		{These include files are converted from the 'C' originals in the Firebird API
135		and define the various constants used by the API}
136
137	<	{$I consts_pub.inc}
138	<	{$I inf_pub.inc}
139	<	{$I configkeys.inc}
137	>	{$I 'include/consts_pub.inc'}
138	>	{$I 'include/inf_pub.inc'}
139	>	{$I 'include/configkeys.inc'}
140
141		{The following constants define the values return by calls to the GetSQLType
142		methods provided by several of the interfaces defined below.}
#	Line 160 | Line 172 | type
172		PGDS__QUAD           = ^TGDS__QUAD;
173		PISC_QUAD            = ^TISC_QUAD;
174
175	+	{$IFNDEF FPC}
176	+	{Delphi only seems to define CP_UTF8 and CP_UTF16}
177	+	const
178	+	CP_ACP     = 0;     // default to ANSI code page
179	+	CP_OEMCP   = 1;     // default to OEM (console) code page
180	+	CP_UTF16BE = 1201;  // unicodeFFFE
181	+	CP_UTF7    = 65000; // utf-7
182	+	CP_ASCII   = 20127; // us-ascii
183	+	CP_NONE    = $FFFF; // rawbytestring encoding
184	+
185	+	{$ENDIF}
186	+
187	+	type
188	+	{$IF not declared(TSystemCodePage)}
189	+	TSystemCodePage = word; {not defined in Delphi}
190	+	{$IFEND}
191	+
192		TIBSQLStatementTypes =
193		(SQLUnknown, SQLSelect, SQLInsert,
194		SQLUpdate, SQLDelete, SQLDDL,
#	Line 174 | Line 203 | type
203		IAttachment = interface;
204		ITransaction = interface;
205
206	<	{The IParameterBlock generic interface provides the template for all parameter
206	>	{The IParameterBlock interface provides the template for all parameter
207		block interfaces}
208
209	<	generic IParameterBlock<_IItem> = interface
209	>	IParameterBlock<_IItem> = interface
210		function getCount: integer;
211		function Add(ParamType: byte): _IItem;
212		function getItems(index: integer): _IItem;
#	Line 191 | Line 220 | type
220		different parameter block items }
221
222		IParameterBlockItem = interface
223	+	['{53b23f7b-abda-46a5-9aa5-07bd5e723266}']
224		function getParamType: byte;
225		function getAsInteger: integer;
226	<	function getAsString: string;
226	>	function getAsString: AnsiString;
227		function getAsByte: byte;
228	<	procedure setAsString(aValue: string);
228	>	procedure setAsString(aValue: AnsiString);
229		procedure setAsByte(aValue: byte);
230		procedure SetAsInteger(aValue: integer);
231	<	property AsString: string read getAsString write setAsString;
231	>	property AsString: AnsiString read getAsString write setAsString;
232		property AsByte: byte read getAsByte write setAsByte;
233		property AsInteger: integer read getAsInteger write SetAsInteger;
234		end;
#	Line 212 | Line 242 | type
242		}
243
244		IStatus = interface
245	+	['{34167722-af38-4831-b08a-93162d58ede3}']
246		function GetIBErrorCode: Long;
247		function Getsqlcode: Long;
248	<	function GetMessage: string;
248	>	function GetMessage: AnsiString;
249		function CheckStatusVector(ErrorCodes: array of TFBStatusCode): Boolean;
250		function GetIBDataBaseErrorMessages: TIBDataBaseErrorMessages;
251		procedure SetIBDataBaseErrorMessages(Value: TIBDataBaseErrorMessages);
#	Line 231 | Line 262 | type
262		TArrayBounds = array of TArrayBound;
263
264		IArrayMetaData = interface
265	+	['{7dd0aea4-59af-4c2a-b958-565d5025c489}']
266		function GetSQLType: cardinal;
267	<	function GetSQLTypeName: string;
267	>	function GetSQLTypeName: AnsiString;
268		function GetScale: integer;
269		function GetSize: cardinal;
270		function GetCharSetID: cardinal;
271	<	function GetTableName: string;
272	<	function GetColumnName: string;
271	>	function GetTableName: AnsiString;
272	>	function GetColumnName: AnsiString;
273		function GetDimensions: integer;
274		function GetBounds: TArrayBounds;
275		end;
#	Line 262 | Line 294 | type
294		TArrayEventHandler = procedure(Sender: IArray; Reason: TArrayEventReason) of object;
295
296		IArray = interface(IArrayMetaData)
297	+	['{631c6bb1-fb49-44fb-a64a-c49859632b88}']
298		function GetArrayID: TISC_QUAD;
299		procedure Clear;
300		function IsEmpty: boolean;
#	Line 277 | Line 310 | type
310		function GetAsFloat(index: array of integer): Float;
311		function GetAsLong(index: array of integer): Long;
312		function GetAsShort(index: array of integer): Short;
313	<	function GetAsString(index: array of integer): String;
313	>	function GetAsString(index: array of integer): AnsiString;
314		function GetAsVariant(index: array of integer): Variant;
315		procedure SetAsInteger(index: array of integer; AValue: integer);
316		procedure SetAsBoolean(index: array of integer; AValue: boolean);
#	Line 290 | Line 323 | type
323		procedure SetAsDouble(index: array of integer; Value: Double);
324		procedure SetAsFloat(index: array of integer; Value: Float);
325		procedure SetAsShort(index: array of integer; Value: Short);
326	<	procedure SetAsString(index: array of integer; Value: String);
326	>	procedure SetAsString(index: array of integer; Value: AnsiString);
327		procedure SetAsVariant(index: array of integer; Value: Variant);
328		procedure SetBounds(dim, UpperBound, LowerBound: integer);
329		function GetAttachment: IAttachment;
#	Line 304 | Line 337 | type
337		}
338
339		IBlobMetaData = interface
340	+	['{575f3c61-bb33-46a5-8975-bb7d1b6e37cc}']
341		function GetSubType: integer;
342		function GetCharSetID: cardinal;
343		function GetCodePage: TSystemCodePage;
344		function GetSegmentSize: cardinal;
345	<	function GetRelationName: string;
346	<	function GetColumnName: string;
345	>	function GetRelationName: AnsiString;
346	>	function GetColumnName: AnsiString;
347		end;
348
349		{The Blob Parameter block is used to select a Blob Filter}
350
351	<	IBPBItem = interface (IParameterBlockItem) end;
351	>	IBPBItem = interface (IParameterBlockItem)
352	>	['{660822a5-3114-4c16-b6cb-c1a7b2aba70d}']
353	>	end;
354
355	<	IBPB = specialize IParameterBlock<IBPBItem>;
355	>	IBPB = interface (IParameterBlock<IBPBItem>)
356	>	['{e0cb9eb5-17f7-4416-b7d1-3cddd1dfca76}']
357	>	end;
358
359		{ The Blob Interface provides access to a blob data item.
360
#	Line 330 | Line 368 | type
368		TBlobType = (btSegmented,btStream);
369
370		IBlob = interface(IBlobMetaData)
371	+	['{3090a145-7780-442b-b15b-efd4568b8611}']
372		function GetBPB: IBPB;
373		procedure Cancel;
374		procedure Close;
#	Line 340 | Line 379 | type
379		TotalSize: Int64; var BlobType: TBlobType);
380		function Read(var Buffer; Count: Longint): Longint;
381		function Write(const Buffer; Count: Longint): Longint;
382	<	function LoadFromFile(Filename: string): IBlob;
382	>	function LoadFromFile(Filename: AnsiString): IBlob;
383		function LoadFromStream(S: TStream) : IBlob;
384	<	function SaveToFile(Filename: string): IBlob;
384	>	function SaveToFile(Filename: AnsiString): IBlob;
385		function SaveToStream(S: TStream): IBlob;
386		function GetAsString: rawbytestring;
387		procedure SetAsString(aValue: rawbytestring);
#	Line 359 | Line 398 | type
398		{ IColumnMetaData }
399
400		IColumnMetaData = interface
401	+	['{c222e6c3-53c1-469f-9e05-0a5c3ef232d8}']
402		function GetIndex: integer;
403		function GetSQLType: cardinal;
404	<	function GetSQLTypeName: string;
404	>	function GetSQLTypeName: AnsiString;
405		function getSubtype: integer;
406	<	function getRelationName: string;
407	<	function getOwnerName: string;
408	<	function getSQLName: string;    {Name of the column}
409	<	function getAliasName: string;  {Alias Name of column or Column Name if no alias}
410	<	function getName: string;       {Disambiguated uppercase Field Name}
406	>	function getRelationName: AnsiString;
407	>	function getOwnerName: AnsiString;
408	>	function getSQLName: AnsiString;    {Name of the column}
409	>	function getAliasName: AnsiString;  {Alias Name of column or Column Name if no alias}
410	>	function getName: AnsiString;       {Disambiguated uppercase Field Name}
411		function getScale: integer;
412		function getCharSetID: cardinal;
413		function getCodePage: TSystemCodePage;
#	Line 375 | Line 415 | type
415		function GetSize: cardinal;
416		function GetArrayMetaData: IArrayMetaData; {Valid only for Array SQL Type}
417		function GetBlobMetaData: IBlobMetaData; {Valid only for Blob SQL Type}
418	<	property Name: string read GetName;
418	>	property Name: AnsiString read GetName;
419		property Size: cardinal read GetSize;
420		property SQLType: cardinal read GetSQLType;
421		property Scale: integer read getScale;
#	Line 391 | Line 431 | type
431		{ IMetaData }
432
433		IMetaData = interface
434	+	['{4dafdbb6-0d36-4f1f-9c95-8b132804b965}']
435		function getCount: integer;
436		function getColumnMetaData(index: integer): IColumnMetaData;
437	<	function GetUniqueRelationName: string; {Non empty if all columns come from the same table}
438	<	function ByName(Idx: String): IColumnMetaData;
437	>	function GetUniqueRelationName: AnsiString; {Non empty if all columns come from the same table}
438	>	function ByName(Idx: AnsiString): IColumnMetaData;
439		property ColMetaData[index: integer]: IColumnMetaData read getColumnMetaData; default;
440		property Count: integer read getCount;
441		end;
#	Line 414 | Line 455 | type
455
456
457		ISQLData = interface(IColumnMetaData)
458	+	['{3f493e31-7e3f-4606-a07c-b210b9e3619d}']
459		function GetAsBoolean: boolean;
460		function GetAsCurrency: Currency;
461		function GetAsInt64: Int64;
#	Line 424 | Line 466 | type
466		function GetAsPointer: Pointer;
467		function GetAsQuad: TISC_QUAD;
468		function GetAsShort: short;
469	<	function GetAsString: String;
469	>	function GetAsString: AnsiString;
470		function GetIsNull: Boolean;
471		function GetAsVariant: Variant;
472		function GetAsBlob: IBlob; overload;
#	Line 443 | Line 485 | type
485		property AsPointer: Pointer read GetAsPointer;
486		property AsQuad: TISC_QUAD read GetAsQuad;
487		property AsShort: short read GetAsShort;
488	<	property AsString: String read GetAsString;
488	>	property AsString: AnsiString read GetAsString;
489		property AsVariant: Variant read GetAsVariant ;
490		property AsBlob: IBlob read GetAsBlob;
491		property AsArray: IArray read GetAsArray;
#	Line 458 | Line 500 | type
500		}
501
502		IResults = interface
503	+	['{e836b2bb-93d1-4bbf-a8eb-7ce535de3bb5}']
504		function getCount: integer;
505		function GetTransaction: ITransaction;
506	<	function ByName(Idx: String): ISQLData;
506	>	function ByName(Idx: AnsiString): ISQLData;
507		function getSQLData(index: integer): ISQLData;
508	<	procedure GetData(index: integer; var IsNull:boolean; var len: short; var data: PChar);
508	>	procedure GetData(index: integer; var IsNull:boolean; var len: short; var data: PByte);
509		procedure SetRetainInterfaces(aValue: boolean);
510		property Data[index: integer]: ISQLData read getSQLData; default;
511		property Count: integer read getCount;
#	Line 474 | Line 517 | type
517		in turn, used to access the data returned by each field of the current row.
518		}
519		IResultSet = interface(IResults)
520	+	['{0ae4979b-7857-4e8c-8918-ec6f155b51a0}']
521		function FetchNext: boolean;
522	<	function GetCursorName: string;
522	>	function GetCursorName: AnsiString;
523		function IsEof: boolean;
524		procedure Close;
525		end;
#	Line 496 | Line 540 | type
540		}
541
542		ISQLParam = interface
543	+	['{b22b4578-6d41-4807-a9a9-d2ec8d1d5a14}']
544		function GetIndex: integer;
545		function GetSQLType: cardinal;
546	<	function GetSQLTypeName: string;
546	>	function GetSQLTypeName: AnsiString;
547		function getSubtype: integer;
548	<	function getName: string;
548	>	function getName: AnsiString;
549		function getScale: integer;
550		function getCharSetID: cardinal;
551		function getCodePage: TSystemCodePage;
#	Line 516 | Line 561 | type
561		function GetAsPointer: Pointer;
562		function GetAsQuad: TISC_QUAD;
563		function GetAsShort: short;
564	<	function GetAsString: String;
564	>	function GetAsString: AnsiString;
565		function GetIsNull: boolean;
566		function GetAsVariant: Variant;
567		function GetAsBlob: IBlob;
#	Line 534 | Line 579 | type
579		procedure SetAsFloat(aValue: Float);
580		procedure SetAsPointer(aValue: Pointer);
581		procedure SetAsShort(aValue: Short);
582	<	procedure SetAsString(aValue: String);
582	>	procedure SetAsString(aValue: AnsiString);
583		procedure SetAsVariant(aValue: Variant);
584		procedure SetIsNull(aValue: Boolean);
585		procedure SetAsBlob(aValue: IBlob);
#	Line 553 | Line 598 | type
598		property AsLong: Long read GetAsLong write SetAsLong;
599		property AsPointer: Pointer read GetAsPointer write SetAsPointer;
600		property AsShort: Short read GetAsShort write SetAsShort;
601	<	property AsString: String read GetAsString write SetAsString;
601	>	property AsString: AnsiString read GetAsString write SetAsString;
602		property AsVariant: Variant read GetAsVariant write SetAsVariant;
603		property AsBlob: IBlob read GetAsBlob write SetAsBlob;
604		property AsArray: IArray read GetAsArray write SetAsArray;
#	Line 562 | Line 607 | type
607		property IsNull: Boolean read GetIsNull write SetIsNull;
608		property IsNullable: Boolean read GetIsNullable;
609		property Modified: Boolean read getModified;
610	<	property Name: string read GetName;
610	>	property Name: AnsiString read GetName;
611		property SQLType: cardinal read GetSQLType;
612		end;
613
#	Line 572 | Line 617 | type
617		}
618
619		ISQLParams = interface
620	+	['{c6d95ac7-b2b7-461b-b890-afef0acbb077}']
621		function getCount: integer;
622		function getSQLParam(index: integer): ISQLParam;
623	<	function ByName(Idx: String): ISQLParam ;
623	>	function ByName(Idx: AnsiString): ISQLParam ;
624		function GetModified: Boolean;
625		property Modified: Boolean read GetModified;
626		property Params[index: integer]: ISQLParam read getSQLParam; default;
627		property Count: integer read getCount;
628		end;
629
630	+
631	+	TPerfStats = (psCurrentMemory, psMaxMemory,
632	+	psRealTime, psUserTime, psBuffers,
633	+	psReads, psWrites, psFetches,psDeltaMemory);
634	+
635	+	TPerfCounters = array[TPerfStats] of Int64;
636	+
637		{The IStatement interface provides access to an SQL Statement once it has been
638		initially prepared. The interface is returned from the IAttachment interface.
639		}
640
641		IStatement = interface
642	+	['{a260576d-a07d-4a66-b02d-1b72543fd7cf}']
643		function GetMetaData: IMetaData;  {Output Metadata}
644		function GetSQLParams: ISQLParams;{Statement Parameters}
645	<	function GetPlan: String;
645	>	function GetPlan: AnsiString;
646		function GetRowsAffected(var SelectCount, InsertCount, UpdateCount, DeleteCount: integer): boolean;
647		function GetSQLStatementType: TIBSQLStatementTypes;
648	<	function GetSQLText: string;
648	>	function GetSQLText: AnsiString;
649		function GetSQLDialect: integer;
650		function IsPrepared: boolean;
651		procedure Prepare(aTransaction: ITransaction=nil);
#	Line 600 | Line 654 | type
654		function GetAttachment: IAttachment;
655		function GetTransaction: ITransaction;
656		procedure SetRetainInterfaces(aValue: boolean);
657	+	procedure EnableStatistics(aValue: boolean);
658	+	function GetPerfStatistics(var stats: TPerfCounters): boolean;
659		property MetaData: IMetaData read GetMetaData;
660		property SQLParams: ISQLParams read GetSQLParams;
661		property SQLStatementType: TIBSQLStatementTypes read GetSQLStatementType;
#	Line 616 | Line 672 | type
672		found in the Interbase 6.0 API Guide.
673		}
674
675	<	ITPBItem = interface(IParameterBlockItem) end;
675	>	ITPBItem = interface(IParameterBlockItem)
676	>	['{544c1f2b-7c12-4a87-a4a5-face7ea72671}']
677	>	end;
678
679	<	ITPB = specialize IParameterBlock<ITPBItem>;
679	>	ITPB = interface(IParameterBlock<ITPBItem>)
680	>	['{7369b0ff-defe-437b-81fe-19b211d42d25}']
681	>	end;
682
683		{The ITransactionAction interface provides access to a Transaction once it
684		has been initially started. After a Commit or Rollback, a transaction
#	Line 632 | Line 692 | type
692		TTransactionCompletion = TARollback.. TACommit;
693
694		ITransaction = interface
695	+	['{30928d0e-a9d7-4c61-b7cf-14f4f38abe2a}']
696		function getTPB: ITPB;
697		procedure Start(DefaultCompletion: TTransactionCompletion=taCommit);
698		function GetInTransaction: boolean;
#	Line 659 | Line 720 | type
720		}
721
722		TEventInfo = record
723	<	EventName: string;
723	>	EventName: AnsiString;
724		Count: integer;
725		end;
726
#	Line 670 | Line 731 | type
731		{ IEvents }
732
733		IEvents = interface
734	+	['{6a0be233-ed08-4524-889c-2e45d0c20e5f}']
735		procedure GetEvents(EventNames: TStrings);
736		procedure SetEvents(EventNames: TStrings); overload;
737	<	procedure SetEvents(EventName: string); overload;
737	>	procedure SetEvents(EventName: AnsiString); overload;
738		procedure Cancel;
739		function ExtractEventCounts: TEventCounts;
740		procedure WaitForEvent;
#	Line 703 | Line 765 | type
765		TDBOperationCounts = array of TDBOperationCount;
766
767		IDBInfoItem = interface
768	+	['{eeb97b51-ec0f-473f-9f75-c1721f055fcb}']
769		function getItemType: byte;
770		function getSize: integer;
771		procedure getRawBytes(var Buffer);
772	<	function getAsString: string;
772	>	function getAsString: AnsiString;
773		function getAsInteger: integer;
774	<	procedure DecodeIDCluster(var ConnectionType: integer; var DBFileName, DBSiteName: string);
774	>	procedure DecodeIDCluster(var ConnectionType: integer; var DBFileName, DBSiteName: AnsiString);
775		function getAsBytes: TByteArray;
776	<	procedure DecodeVersionString(var Version: byte; var VersionString: string);
776	>	function getAsDateTime: TDateTime;
777	>	procedure DecodeVersionString(var Version: byte; var VersionString: AnsiString);
778		function getOperationCounts: TDBOperationCounts;
779		procedure DecodeUserNames(UserNames: TStrings);
780
#	Line 719 | Line 783 | type
783		function GetItem(index: integer): IDBInfoItem;
784		function Find(ItemType: byte): IDBInfoItem;
785		property AsInteger: integer read getAsInteger;
786	<	property AsString: string read GetAsString;
786	>	property AsString: AnsiString read GetAsString;
787		property Count: integer read GetCount;
788		property Items[index: integer]: IDBInfoItem read getItem; default;
789		end;
#	Line 727 | Line 791 | type
791		{ IDBInformation }
792
793		IDBInformation = interface
794	+	['{7ac6777f-f0a9-498a-9f5c-4a57a554df81}']
795		function GetCount: integer;
796		function GetItem(index: integer): IDBInfoItem;
797		function Find(ItemType: byte): IDBInfoItem;
#	Line 735 | Line 800 | type
800		property Items[index: integer]: IDBInfoItem read getItem; default;
801		end;
802
803	+	{The Database Information Request Block is used to pass requests for
804	+	database information where at least one item requested has a parameter.
805	+	At present, this is only fb_info_page_contents which has a single
806	+	integer parameter.}
807	+
808	+	IDIRBItem = interface(IParameterBlockItem)
809	+	['{d34a7511-8435-4a24-81a7-5103d218d234}']
810	+	end;
811	+
812	+	IDIRB = interface(IParameterBlock<IDIRBItem>)
813	+	['{1010e5ac-0a8f-403b-a302-91625e9d9579}']
814	+	end;
815	+
816	+
817		{The Database Parameter Block (DPB).
818
819		The DPB provides the parameters used when connecting to a database. It is allocated
#	Line 746 | Line 825 | type
825		found in the Interbase 6.0 API Guide.
826		}
827
828	<	IDPBItem = interface(IParameterBlockItem) end;
828	>	IDPBItem = interface(IParameterBlockItem)
829	>	['{123d4ad0-087a-4cd1-a344-1b3d03b30673}']
830	>	end;
831
832	<	IDPB = specialize IParameterBlock<IDPBItem>;
832	>	IDPB = interface(IParameterBlock<IDPBItem>)
833	>	['{e676067b-1cf4-4eba-9256-9724f57e0d16}']
834	>	end;
835
836		{The IAttachment interface provides access to a Database Connection. It may be
837		used to:
#	Line 778 | Line 861 | type
861		{ IAttachment }
862
863		IAttachment = interface
864	+	['{466e9b67-9def-4807-b3e7-e08a35e7185c}']
865		function getDPB: IDPB;
866		function AllocateBPB: IBPB;
867	+	function AllocateDIRB: IDIRB;
868		procedure Connect;
869		procedure Disconnect(Force: boolean=false);
870		function IsConnected: boolean;
871		procedure DropDatabase;
872		function StartTransaction(TPB: array of byte; DefaultCompletion: TTransactionCompletion=taCommit): ITransaction; overload;
873		function StartTransaction(TPB: ITPB; DefaultCompletion: TTransactionCompletion=taCommit): ITransaction; overload;
874	<	procedure ExecImmediate(transaction: ITransaction; sql: string; SQLDialect: integer); overload;
875	<	procedure ExecImmediate(TPB: array of byte; sql: string; SQLDialect: integer); overload;
876	<	procedure ExecImmediate(transaction: ITransaction; sql: string); overload;
877	<	procedure ExecImmediate(TPB: array of byte; sql: string); overload;
878	<	function ExecuteSQL(TPB: array of byte; sql: string; SQLDialect: integer; params: array of const): IResults; overload;
879	<	function ExecuteSQL(transaction: ITransaction; sql: string; SQLDialect: integer; params: array of const): IResults; overload;
880	<	function ExecuteSQL(TPB: array of byte; sql: string; params: array of const): IResults; overload;
881	<	function ExecuteSQL(transaction: ITransaction; sql: string; params: array of const): IResults; overload;
882	<	function OpenCursor(transaction: ITransaction; sql: string; aSQLDialect: integer): IResultSet; overload;
883	<	function OpenCursor(transaction: ITransaction; sql: string; aSQLDialect: integer;
874	>	procedure ExecImmediate(transaction: ITransaction; sql: AnsiString; SQLDialect: integer); overload;
875	>	procedure ExecImmediate(TPB: array of byte; sql: AnsiString; SQLDialect: integer); overload;
876	>	procedure ExecImmediate(transaction: ITransaction; sql: AnsiString); overload;
877	>	procedure ExecImmediate(TPB: array of byte; sql: AnsiString); overload;
878	>	function ExecuteSQL(TPB: array of byte; sql: AnsiString; SQLDialect: integer; params: array of const): IResults; overload;
879	>	function ExecuteSQL(transaction: ITransaction; sql: AnsiString; SQLDialect: integer; params: array of const): IResults; overload;
880	>	function ExecuteSQL(TPB: array of byte; sql: AnsiString; params: array of const): IResults; overload;
881	>	function ExecuteSQL(transaction: ITransaction; sql: AnsiString; params: array of const): IResults; overload;
882	>	function OpenCursor(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer): IResultSet; overload;
883	>	function OpenCursor(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer;
884		params: array of const): IResultSet; overload;
885	<	function OpenCursor(transaction: ITransaction; sql: string): IResultSet; overload;
886	<	function OpenCursor(transaction: ITransaction; sql: string;
885	>	function OpenCursor(transaction: ITransaction; sql: AnsiString): IResultSet; overload;
886	>	function OpenCursor(transaction: ITransaction; sql: AnsiString;
887		params: array of const): IResultSet; overload;
888	<	function OpenCursorAtStart(transaction: ITransaction; sql: string; aSQLDialect: integer): IResultSet; overload;
889	<	function OpenCursorAtStart(transaction: ITransaction; sql: string; aSQLDialect: integer;
888	>	function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer): IResultSet; overload;
889	>	function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer;
890		params: array of const): IResultSet; overload;
891	<	function OpenCursorAtStart(transaction: ITransaction; sql: string): IResultSet; overload;
892	<	function OpenCursorAtStart(transaction: ITransaction; sql: string;
891	>	function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString): IResultSet; overload;
892	>	function OpenCursorAtStart(transaction: ITransaction; sql: AnsiString;
893		params: array of const): IResultSet; overload;
894	<	function OpenCursorAtStart(sql: string): IResultSet; overload;
895	<	function OpenCursorAtStart(sql: string;
894	>	function OpenCursorAtStart(sql: AnsiString): IResultSet; overload;
895	>	function OpenCursorAtStart(sql: AnsiString;
896		params: array of const): IResultSet; overload;
897	<	function Prepare(transaction: ITransaction; sql: string; aSQLDialect: integer): IStatement; overload;
898	<	function Prepare(transaction: ITransaction; sql: string): IStatement; overload;
899	<	function PrepareWithNamedParameters(transaction: ITransaction; sql: string;
897	>	function Prepare(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer): IStatement; overload;
898	>	function Prepare(transaction: ITransaction; sql: AnsiString): IStatement; overload;
899	>	function PrepareWithNamedParameters(transaction: ITransaction; sql: AnsiString;
900		aSQLDialect: integer; GenerateParamNames: boolean=false): IStatement; overload;
901	<	function PrepareWithNamedParameters(transaction: ITransaction; sql: string;
901	>	function PrepareWithNamedParameters(transaction: ITransaction; sql: AnsiString;
902		GenerateParamNames: boolean=false): IStatement; overload;
903
904		{Events}
905		function GetEventHandler(Events: TStrings): IEvents; overload;
906	<	function GetEventHandler(Event: string): IEvents; overload;
906	>	function GetEventHandler(Event: AnsiString): IEvents; overload;
907
908		{Blob - may use to open existing Blobs. However, ISQLData.AsBlob is preferred}
909
910	<	function CreateBlob(transaction: ITransaction; RelationName, ColumnName: string; BPB: IBPB=nil): IBlob; overload;
910	>	function CreateBlob(transaction: ITransaction; RelationName, ColumnName: AnsiString; BPB: IBPB=nil): IBlob; overload;
911		function CreateBlob(transaction: ITransaction; BlobMetaData: IBlobMetaData; BPB: IBPB=nil): IBlob; overload;
912		function CreateBlob(transaction: ITransaction; SubType: integer; CharSetID: cardinal=0; BPB: IBPB=nil): IBlob; overload;
913	<	function OpenBlob(transaction: ITransaction; RelationName, ColumnName: string; BlobID: TISC_QUAD; BPB: IBPB=nil): IBlob;
913	>	function OpenBlob(transaction: ITransaction; RelationName, ColumnName: AnsiString; BlobID: TISC_QUAD; BPB: IBPB=nil): IBlob;
914
915		{Array - may use to open existing arrays. However, ISQLData.AsArray is preferred}
916
917	<	function OpenArray(transaction: ITransaction; RelationName, ColumnName: string; ArrayID: TISC_QUAD): IArray;
918	<	function CreateArray(transaction: ITransaction; RelationName, ColumnName: string): IArray; overload;
917	>	function OpenArray(transaction: ITransaction; RelationName, ColumnName: AnsiString; ArrayID: TISC_QUAD): IArray;
918	>	function CreateArray(transaction: ITransaction; RelationName, ColumnName: AnsiString): IArray; overload;
919		function CreateArray(transaction: ITransaction; ArrayMetaData: IArrayMetaData): IArray; overload;
920	+	function CreateArrayMetaData(SQLType: cardinal; tableName: AnsiString; columnName: AnsiString;
921	+	Scale: integer; size: cardinal; charSetID: cardinal; dimensions: cardinal;
922	+	bounds: TArrayBounds): IArrayMetaData;
923
924		{Database Information}
925		function GetSQLDialect: integer;
926	<	function GetBlobMetaData(Transaction: ITransaction; tableName, columnName: string): IBlobMetaData;
927	<	function GetArrayMetaData(Transaction: ITransaction; tableName, columnName: string): IArrayMetaData;
926	>	function GetBlobMetaData(Transaction: ITransaction; tableName, columnName: AnsiString): IBlobMetaData;
927	>	function GetArrayMetaData(Transaction: ITransaction; tableName, columnName: AnsiString): IArrayMetaData;
928		function GetDBInformation(Requests: array of byte): IDBInformation; overload;
929		function GetDBInformation(Request: byte): IDBInformation; overload;
930	+	function GetDBInformation(Requests: IDIRB): IDBInformation; overload;
931	+	function GetConnectString: AnsiString;
932	+	function GetRemoteProtocol: AnsiString;
933	+	function GetAuthenticationMethod: AnsiString;
934	+	function GetSecurityDatabase: AnsiString;
935	+	function GetODSMajorVersion: integer;
936	+	function GetODSMinorVersion: integer;
937		function HasActivity: boolean;
938	+
939	+	{Character Sets}
940	+	function HasDefaultCharSet: boolean;
941	+	function GetDefaultCharSetID: integer;
942	+	function GetCharsetName(CharSetID: integer): AnsiString;
943	+	function CharSetID2CodePage(CharSetID: integer; var CodePage: TSystemCodePage): boolean;
944	+	function CodePage2CharSetID(CodePage: TSystemCodePage; var CharSetID: integer): boolean;
945	+	function CharSetName2CharSetID(CharSetName: AnsiString; var CharSetID: integer): boolean;
946	+	function CharSetWidth(CharSetID: integer; var Width: integer): boolean;
947	+	procedure RegisterCharSet(CharSetName: AnsiString; CodePage: TSystemCodePage;
948	+	AllowReverseLookup:boolean; out CharSetID: integer);
949		end;
950
951	<	TProtocol = (TCP, SPX, NamedPipe, Local);
951	>	TProtocolAll = (TCP, SPX, NamedPipe, Local, inet, inet4, inet6, wnet, xnet, unknownProtocol);
952	>	TProtocol = TCP..xnet;
953
954		{Service Parameter Block (SPB).
955
#	Line 856 | Line 963 | type
963
964		}
965
966	<	ISPBItem = interface(IParameterBlockItem) end;
966	>	ISPBItem = interface(IParameterBlockItem)
967	>	['{5d08ae2b-4519-41bd-8b40-97cd451c3f6a}']
968	>	end;
969
970	<	ISPB = specialize IParameterBlock<ISPBItem>;
970	>	ISPB = interface(IParameterBlock<ISPBItem>)
971	>	['{2c5836fd-41ed-4426-9b7d-5af580ec2659}']
972	>	end;
973
974		{Service Query Parameter Block (SQPB).
975
#	Line 867 | Line 978 | type
978		}
979
980		ISQPBItem = interface(IParameterBlockItem)
981	+	['{b07841a6-33b3-47f0-b5a2-028cbc86dc97}']
982		function CopyFrom(source: TStream; count: integer): integer;
983		end;
984
985	<	ISQPB = specialize IParameterBlock<ISQPBItem>;
985	>	ISQPB = interface(IParameterBlock<ISQPBItem>)
986	>	['{8553e66b-ee62-498b-8431-dff030211447}']
987	>	end;
988
989		{Service Request Block (SRB).
990
#	Line 884 | Line 998 | type
998
999		}
1000
1001	<	ISRBItem = interface(IParameterBlockItem) end;
1001	>	ISRBItem = interface(IParameterBlockItem)
1002	>	['{47ec790e-f265-4b30-9dcd-261e51677245}']
1003	>	end;
1004
1005	<	ISRB = specialize IParameterBlock<ISRBItem>;
1005	>	ISRB = interface(IParameterBlock<ISRBItem>)
1006	>	['{9f2e204f-3c33-4e44-90f9-9135e95dafb9}']
1007	>	end;
1008
1009		{The Service Query Results Interface.
1010
#	Line 904 | Line 1022 | type
1022		}
1023
1024		IServiceQueryResultSubItem = interface
1025	+	['{8a4c381e-9923-4cc9-a96b-553729248640}']
1026		function getItemType: byte;
1027		function getSize: integer;
1028		procedure getRawBytes(var Buffer);
1029	<	function getAsString: string;
1029	>	function getAsString: AnsiString;
1030		function getAsInteger: integer;
1031		function getAsByte: byte;
1032		function CopyTo(stream: TStream; count: integer): integer;
1033	<	property AsString: string read getAsString;
1033	>	property AsString: AnsiString read getAsString;
1034		property AsInteger: integer read getAsInteger;
1035		property AsByte: byte read getAsByte;
1036		end;
1037
1038		IServiceQueryResultItem = interface(IServiceQueryResultSubItem)
1039	+	['{b2806886-206c-4024-8df9-5fe0a7630a5e}']
1040		function getCount: integer;
1041		function getItem(index: integer): IServiceQueryResultSubItem;
1042		function find(ItemType: byte): IServiceQueryResultSubItem;
#	Line 925 | Line 1045 | type
1045		end;
1046
1047		IServiceQueryResults = interface
1048	+	['{8fbbef7d-fe03-4409-828a-a787d34ef531}']
1049		function getCount: integer;
1050		function getItem(index: integer): IServiceQueryResultItem;
1051		function find(ItemType: byte): IServiceQueryResultItem;
#	Line 943 | Line 1064 | type
1064		{ IServiceManager }
1065
1066		IServiceManager = interface
1067	+	['{905b587d-1e1f-4e40-a3f8-a3519f852e48}']
1068		function getSPB: ISPB;
1069	<	function getServerName: string;
1069	>	function getServerName: AnsiString;
1070	>	function getProtocol: TProtocol;
1071	>	function getPortNo: AnsiString;
1072		procedure Attach;
1073		procedure Detach(Force: boolean=false);
1074		function IsAttached: boolean;
1075		function AllocateSRB: ISRB;
1076		function AllocateSQPB: ISQPB;
1077	<	procedure Start(Request: ISRB);
1078	<	function Query(SQPB: ISQPB; Request: ISRB) :IServiceQueryResults; overload;
1079	<	function Query(Request: ISRB) :IServiceQueryResults; overload;
1077	>	function Start(Request: ISRB; RaiseExceptionOnError: boolean=true): boolean;
1078	>	function Query(SQPB: ISQPB; Request: ISRB; RaiseExceptionOnError: boolean=true) :IServiceQueryResults; overload;
1079	>	function Query(Request: ISRB; RaiseExceptionOnError: boolean=true) :IServiceQueryResults; overload;
1080		end;
1081
1082		{The Firebird API.
#	Line 964 | Line 1088 | type
1088		}
1089
1090		IFirebirdAPI = interface
1091	+	['{edeee691-c8d3-4dcf-a780-cd7e432821d5}']
1092		{Database connections}
1093		function AllocateDPB: IDPB;
1094	<	function OpenDatabase(DatabaseName: string; DPB: IDPB; RaiseExceptionOnConnectError: boolean=true): IAttachment;
1095	<	function CreateDatabase(DatabaseName: string; DPB: IDPB; RaiseExceptionOnError: boolean=true): IAttachment;
1094	>	function OpenDatabase(DatabaseName: AnsiString; DPB: IDPB; RaiseExceptionOnConnectError: boolean=true): IAttachment;
1095	>	function CreateDatabase(DatabaseName: AnsiString; DPB: IDPB; RaiseExceptionOnError: boolean=true): IAttachment; overload;
1096	>	function CreateDatabase(sql: AnsiString; aSQLDialect: integer; RaiseExceptionOnError: boolean=true): IAttachment; overload;
1097
1098		{Start Transaction against multiple databases}
1099		function AllocateTPB: ITPB;
#	Line 979 | Line 1105 | type
1105		{Service Manager}
1106		function HasServiceAPI: boolean;
1107		function AllocateSPB: ISPB;
1108	<	function GetServiceManager(ServerName: string; Protocol: TProtocol; SPB: ISPB): IServiceManager;
1108	>	function GetServiceManager(ServerName: AnsiString; Protocol: TProtocol; SPB: ISPB): IServiceManager; overload;
1109	>	function GetServiceManager(ServerName: AnsiString; Port: AnsiString; Protocol: TProtocol; SPB: ISPB): IServiceManager; overload;
1110
1111		{Information}
1112		function GetStatus: IStatus;
1113		function GetLibraryName: string;
1114		function HasRollbackRetaining: boolean;
1115		function IsEmbeddedServer: boolean;
1116	<	function GetImplementationVersion: string;
1116	>	function GetImplementationVersion: AnsiString;
1117
1118		{Firebird 3 API}
1119		function HasMasterIntf: boolean;
1120		function GetIMaster: TObject;
994	–
995	–	{utility}
996	–	function GetCharsetName(CharSetID: integer): string;
997	–	function CharSetID2CodePage(CharSetID: integer; var CodePage: TSystemCodePage): boolean;
998	–	function CodePage2CharSetID(CodePage: TSystemCodePage; var CharSetID: integer): boolean;
999	–	function CharSetName2CharSetID(CharSetName: string; var CharSetID: integer): boolean;
1000	–	function CharSetWidth(CharSetID: integer; var Width: integer): boolean;
1121		end;
1122
1123		type
#	Line 1014 | Line 1134 | type
1134		private
1135		FSQLCode: Long;
1136		public
1137	<	constructor Create(ASQLCode: Long; Msg: string);
1137	>	constructor Create(ASQLCode: Long; Msg: AnsiString);
1138		property SQLCode: Long read FSQLCode;
1139		end;
1140
#	Line 1025 | Line 1145 | type
1145		FIBErrorCode: Long;
1146		public
1147		constructor Create(Status: IStatus); overload;
1148	<	constructor Create(ASQLCode: Long; AIBErrorCode: Long; Msg: string); overload;
1148	>	constructor Create(ASQLCode: Long; AIBErrorCode: Long; Msg: AnsiString); overload;
1149		property IBErrorCode: Long read FIBErrorCode;
1150		end;
1151
#	Line 1103 | Line 1223 | end;
1223
1224		{ EIBError }
1225
1226	<	constructor EIBError.Create(ASQLCode: Long; Msg: string);
1226	>	constructor EIBError.Create(ASQLCode: Long; Msg: AnsiString);
1227		begin
1228		inherited Create(Msg);
1229		FSQLCode := ASQLCode;
#	Line 1118 | Line 1238 | begin
1238		end;
1239
1240		constructor EIBInterBaseError.Create(ASQLCode: Long; AIBErrorCode: Long;
1241	<	Msg: string);
1241	>	Msg: AnsiString);
1242		begin
1243		inherited Create(ASQLCode,Msg);
1244		FIBErrorCode := AIBErrorCode;
#	Line 1133 | Line 1253 | end;
1253		initialization
1254		FFirebirdAPI := nil;
1255
1256	+	finalization
1257	+	FFirebirdAPI := nil;
1258
1259		end.
1260

Diff Legend

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