client/3.0/FB30Attachment.pas

(*
 *  Firebird Interface (fbintf). The fbintf components provide a set of
 *  Pascal language bindings for the Firebird API.
 *
 *  The contents of this file are subject to the Initial Developer's
 *  Public License Version 1.0 (the "License"); you may not use this
 *  file except in compliance with the License. You may obtain a copy
 *  of the License here:
 *
 *    http://www.firebirdsql.org/index.php?op=doc&id=idpl
 *
 *  Software distributed under the License is distributed on an "AS
 *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 *  implied. See the License for the specific language governing rights
 *  and limitations under the License.
 *
 *  The Initial Developer of the Original Code is Tony Whyman.
 *
 *  The Original Code is (C) 2016 Tony Whyman, MWA Software
 *  (http://www.mwasoftware.co.uk).
 *
 *  All Rights Reserved.
 *
 *  Contributor(s): ______________________________________.
 *
*)
unit FB30Attachment;
{$IFDEF MSWINDOWS} 
{$DEFINE WINDOWS} 
{$ENDIF}

{$IFDEF FPC}
{$mode delphi}
{$interfaces COM}
{$ENDIF}

interface

uses
  Classes, SysUtils, FBAttachment, FB30ClientAPI, Firebird, IB, FBActivityMonitor, FBParamBlock;

type

  { TFB30Attachment }

  TFB30Attachment = class(TFBAttachment,IAttachment, IActivityMonitor)
  private
    FAttachmentIntf: Firebird.IAttachment;
    FFirebird30ClientAPI: TFB30ClientAPI;
  protected
    procedure CheckHandle; override;
  public
    constructor Create(api: TFB30ClientAPI; DatabaseName: AnsiString; aDPB: IDPB;
          RaiseExceptionOnConnectError: boolean);
    constructor CreateDatabase(api: TFB30ClientAPI; DatabaseName: AnsiString; aDPB: IDPB; RaiseExceptionOnError: boolean);  overload;
    constructor CreateDatabase(api: TFB30ClientAPI; sql: AnsiString; aSQLDialect: integer;
      RaiseExceptionOnError: boolean); overload;
    destructor Destroy; override;
    function GetDBInfo(ReqBuffer: PByte; ReqBufLen: integer): IDBInformation;
      override;
    property AttachmentIntf: Firebird.IAttachment read FAttachmentIntf;
    property Firebird30ClientAPI: TFB30ClientAPI read FFirebird30ClientAPI;

  public
    {IAttachment}
    procedure Connect;
    procedure Disconnect(Force: boolean=false); override;
    function IsConnected: boolean; override;
    procedure DropDatabase;
    function StartTransaction(TPB: array of byte; DefaultCompletion: TTransactionCompletion): ITransaction; override;
    function StartTransaction(TPB: ITPB; DefaultCompletion: TTransactionCompletion): ITransaction; override;
    procedure ExecImmediate(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer); override;
    function Prepare(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer): IStatement; override;
    function PrepareWithNamedParameters(transaction: ITransaction; sql: AnsiString;
                       aSQLDialect: integer; GenerateParamNames: boolean=false): IStatement; override;

    {Events}
    function GetEventHandler(Events: TStrings): IEvents; override;

    {Blob - may use to open existing Blobs. However, ISQLData.AsBlob is preferred}

    function CreateBlob(transaction: ITransaction; RelationName, ColumnName: AnsiString; BPB: IBPB=nil): IBlob; overload;
    function CreateBlob(transaction: ITransaction; BlobMetaData: IBlobMetaData; BPB: IBPB=nil): IBlob; overload;
    function CreateBlob(transaction: ITransaction; SubType: integer; aCharSetID: cardinal=0; BPB: IBPB=nil): IBlob; overload;
    function OpenBlob(transaction: ITransaction; RelationName, ColumnName: AnsiString; BlobID: TISC_QUAD; BPB: IBPB=nil): IBlob; overload;
    function OpenBlob(transaction: ITransaction; BlobMetaData: IBlobMetaData; BlobID: TISC_QUAD; BPB: IBPB=nil): IBlob;  overload; override;

    {Array}
    function OpenArray(transaction: ITransaction; RelationName, ColumnName: AnsiString; ArrayID: TISC_QUAD): IArray;
    function CreateArray(transaction: ITransaction; RelationName, ColumnName: AnsiString): IArray; overload;
    function CreateArray(transaction: ITransaction; ArrayMetaData: IArrayMetaData): IArray; overload;
    function CreateArrayMetaData(SQLType: cardinal; tableName: AnsiString;
      columnName: AnsiString; Scale: integer; size: cardinal; aCharSetID: cardinal;
      dimensions: cardinal; bounds: TArrayBounds): IArrayMetaData;


    {Database Information}
    function GetBlobMetaData(Transaction: ITransaction; tableName, columnName: AnsiString): IBlobMetaData;
    function GetArrayMetaData(Transaction: ITransaction; tableName, columnName: AnsiString): IArrayMetaData;
  end;

implementation

uses FB30Transaction, FB30Statement, FB30Array, FB30Blob, FBMessages,
  FBOutputBlock, FB30Events, IBUtils;

{ TFB30Attachment }

procedure TFB30Attachment.CheckHandle;
begin
  if FAttachmentIntf = nil then
    IBError(ibxeDatabaseClosed,[nil]);
end;

constructor TFB30Attachment.Create(api: TFB30ClientAPI; DatabaseName: AnsiString; aDPB: IDPB;
  RaiseExceptionOnConnectError: boolean);
begin
  FFirebird30ClientAPI := api;
  if aDPB = nil then
  begin
    if RaiseExceptionOnConnectError then
       IBError(ibxeNoDPB,[nil]);
    Exit;
  end;
  inherited Create(api,DatabaseName,aDPB,RaiseExceptionOnConnectError);
  Connect;
end;

constructor TFB30Attachment.CreateDatabase(api: TFB30ClientAPI; DatabaseName: AnsiString; aDPB: IDPB;
  RaiseExceptionOnError: boolean);
var Param: IDPBItem;
    sql: AnsiString;
    IsCreateDB: boolean;
begin
  inherited Create(api,DatabaseName,aDPB,RaiseExceptionOnError);
  FFirebird30ClientAPI := api;
  IsCreateDB := true;
  if aDPB <> nil then
  begin
    Param := aDPB.Find(isc_dpb_set_db_SQL_dialect);
    if Param <> nil then
      FSQLDialect := Param.AsByte;
  end;
  sql := GenerateCreateDatabaseSQL(DatabaseName,aDPB);
  with FFirebird30ClientAPI do
  begin
    FAttachmentIntf := UtilIntf.executeCreateDatabase(StatusIntf,Length(sql),
                                       PAnsiChar(sql),FSQLDialect,@IsCreateDB);
    if FRaiseExceptionOnConnectError then Check4DataBaseError;
    if InErrorState then
      FAttachmentIntf := nil
    else
    if aDPB <> nil then
    {Connect using known parameters}
    begin
      Disconnect;
      Connect;
    end
    else
      GetODSAndConnectionInfo;
  end;
end;

constructor TFB30Attachment.CreateDatabase(api: TFB30ClientAPI; sql: AnsiString; aSQLDialect: integer;
  RaiseExceptionOnError: boolean);
var IsCreateDB: boolean;
begin
  inherited Create(api,'',nil,RaiseExceptionOnError);
  FFirebird30ClientAPI := api;
  FSQLDialect := aSQLDialect;
  with FFirebird30ClientAPI do
  begin
    FAttachmentIntf := UtilIntf.executeCreateDatabase(StatusIntf,Length(sql),
                                       PAnsiChar(sql),aSQLDialect,@IsCreateDB);
    if FRaiseExceptionOnConnectError then Check4DataBaseError;
    if InErrorState then
      FAttachmentIntf := nil;
  end;
  GetODSAndConnectionInfo;
  ExtractConnectString(sql,FDatabaseName);
  DPBFromCreateSQL(sql);
end;

destructor TFB30Attachment.Destroy;
begin
  inherited Destroy;
  if assigned(FAttachmentIntf) then
    FAttachmentIntf.release;
end;

function TFB30Attachment.GetDBInfo(ReqBuffer: PByte; ReqBufLen: integer): IDBInformation;
begin
  Result := TDBInformation.Create(Firebird30ClientAPI);
  with FFirebird30ClientAPI, Result as TDBInformation do
  begin
    FAttachmentIntf.getInfo(StatusIntf, ReqBufLen, BytePtr(ReqBuffer),
                               getBufSize, BytePtr(Buffer));
      Check4DataBaseError;
  end
end;

procedure TFB30Attachment.Connect;
begin
  with FFirebird30ClientAPI do
  begin
    FAttachmentIntf := ProviderIntf.attachDatabase(StatusIntf,PAnsiChar(FDatabaseName),
                         (DPB as TDPB).getDataLength,
                         BytePtr((DPB as TDPB).getBuffer));
    if FRaiseExceptionOnConnectError then Check4DataBaseError;
    if InErrorState then
      FAttachmentIntf := nil
    else
      GetODSAndConnectionInfo;
  end;
end;

procedure TFB30Attachment.Disconnect(Force: boolean);
begin
  if IsConnected then
    with FFirebird30ClientAPI do
    begin
      EndAllTransactions;
      FAttachmentIntf.Detach(StatusIntf);
      if not Force and InErrorState then
        IBDataBaseError;
      FAttachmentIntf := nil;
      FHasDefaultCharSet := false;
      FCodePage := CP_NONE;
      FCharSetID := 0;
    end;
end;

function TFB30Attachment.IsConnected: boolean;
begin
  Result := FAttachmentIntf <> nil;
end;

procedure TFB30Attachment.DropDatabase;
begin
  if IsConnected then
    with FFirebird30ClientAPI do
    begin
      EndAllTransactions;
      FAttachmentIntf.dropDatabase(StatusIntf);
      Check4DataBaseError;
      FAttachmentIntf := nil;
    end;
end;

function TFB30Attachment.StartTransaction(TPB: array of byte;
  DefaultCompletion: TTransactionCompletion): ITransaction;
begin
  CheckHandle;
  Result := TFB30Transaction.Create(FFirebird30ClientAPI,self,TPB,DefaultCompletion);
end;

function TFB30Attachment.StartTransaction(TPB: ITPB;
  DefaultCompletion: TTransactionCompletion): ITransaction;
begin
  CheckHandle;
  Result := TFB30Transaction.Create(FFirebird30ClientAPI,self,TPB,DefaultCompletion);
end;

procedure TFB30Attachment.ExecImmediate(transaction: ITransaction; sql: AnsiString;
  aSQLDialect: integer);
begin
  CheckHandle;
  with FFirebird30ClientAPI do
  begin
    FAttachmentIntf.execute(StatusIntf,(transaction as TFB30Transaction).TransactionIntf,
                    Length(sql),PAnsiChar(sql),aSQLDialect,nil,nil,nil,nil);
    Check4DataBaseError;
  end;
end;

function TFB30Attachment.Prepare(transaction: ITransaction; sql: AnsiString;
  aSQLDialect: integer): IStatement;
begin
  CheckHandle;
  Result := TFB30Statement.Create(self,transaction,sql,aSQLDialect);
end;

function TFB30Attachment.PrepareWithNamedParameters(transaction: ITransaction;
  sql: AnsiString; aSQLDialect: integer; GenerateParamNames: boolean): IStatement;
begin
  CheckHandle;
  Result := TFB30Statement.CreateWithParameterNames(self,transaction,sql,aSQLDialect,
         GenerateParamNames);
end;

function TFB30Attachment.GetEventHandler(Events: TStrings): IEvents;
begin
  CheckHandle;
  Result := TFB30Events.Create(self,Events);
end;

function TFB30Attachment.CreateBlob(transaction: ITransaction; RelationName,
  ColumnName: AnsiString; BPB: IBPB): IBlob;
begin
  CheckHandle;
  Result := TFB30Blob.Create(self,transaction as TFB30Transaction,
              TFB30BlobMetaData.Create(self,Transaction as TFB30Transaction,RelationName,ColumnName),BPB);
end;

function TFB30Attachment.CreateBlob(transaction: ITransaction;
  BlobMetaData: IBlobMetaData; BPB: IBPB): IBlob;
begin
  CheckHandle;
  Result := TFB30Blob.Create(self,transaction as TFB30Transaction, BlobMetaData,BPB);
end;

function TFB30Attachment.CreateBlob(transaction: ITransaction;
  SubType: integer; aCharSetID: cardinal; BPB: IBPB): IBlob;
begin
  CheckHandle;
  Result := TFB30Blob.Create(self,transaction as TFB30Transaction, SubType,aCharSetID,BPB);
end;

function TFB30Attachment.OpenBlob(transaction: ITransaction; RelationName,
  ColumnName: AnsiString; BlobID: TISC_QUAD; BPB: IBPB): IBlob;
begin
  CheckHandle;
  Result := TFB30Blob.Create(self,transaction as TFB30transaction,
                TFB30BlobMetaData.Create(self,Transaction as TFB30Transaction,RelationName,ColumnName),
                BlobID,BPB);
end;

function TFB30Attachment.OpenBlob(transaction: ITransaction;
  BlobMetaData: IBlobMetaData; BlobID: TISC_QUAD; BPB: IBPB): IBlob;
begin
  CheckHandle;
  Result :=  TFB30Blob.Create(self,transaction as TFB30transaction,BlobMetaData,BlobID,BPB);
end;

function TFB30Attachment.OpenArray(transaction: ITransaction; RelationName,
  ColumnName: AnsiString; ArrayID: TISC_QUAD): IArray;
begin
  CheckHandle;
  Result := TFB30Array.Create(self,transaction as TFB30Transaction,
                    GetArrayMetaData(transaction,RelationName,ColumnName),ArrayID);
end;

function TFB30Attachment.CreateArray(transaction: ITransaction; RelationName,
  ColumnName: AnsiString): IArray;
begin
  CheckHandle;
  Result := TFB30Array.Create(self,transaction as TFB30Transaction,
                    GetArrayMetaData(transaction,RelationName,ColumnName));
end;

function TFB30Attachment.CreateArray(transaction: ITransaction;
  ArrayMetaData: IArrayMetaData): IArray;
begin
  CheckHandle;
  Result := TFB30Array.Create(self,transaction as TFB30Transaction,ArrayMetaData);
end;

function TFB30Attachment.CreateArrayMetaData(SQLType: cardinal; tableName: AnsiString; columnName: AnsiString;
  Scale: integer; size: cardinal; aCharSetID: cardinal; dimensions: cardinal;
  bounds: TArrayBounds): IArrayMetaData;
begin
  Result := TFB30ArrayMetaData.Create(self,SQLType,tableName,ColumnName,Scale,size,aCharSetID, dimensions,bounds);
end;

function TFB30Attachment.GetBlobMetaData(Transaction: ITransaction; tableName,
  columnName: AnsiString): IBlobMetaData;
begin
  CheckHandle;
  Result := TFB30BlobMetaData.Create(self,Transaction as TFB30Transaction,tableName,columnName);
end;

function TFB30Attachment.GetArrayMetaData(Transaction: ITransaction; tableName,
  columnName: AnsiString): IArrayMetaData;
begin
  CheckHandle;
  Result := TFB30ArrayMetaData.Create(self,Transaction as TFB30Transaction,tableName,columnName);
end;

end.

Revision:	263
Committed:	Thu Dec 6 15:55:01 2018 UTC (5 years, 4 months ago) by tony
Content type:	text/x-pascal
File size:	13201 byte(s)
Log Message:	Release 2.3.2 committed
#	Content
1	(*
2	* Firebird Interface (fbintf). The fbintf components provide a set of
3	* Pascal language bindings for the Firebird API.
4	*
5	* The contents of this file are subject to the Initial Developer's
6	* Public License Version 1.0 (the "License"); you may not use this
7	* file except in compliance with the License. You may obtain a copy
8	* of the License here:
9	*
10	* http://www.firebirdsql.org/index.php?op=doc&id=idpl
11	*
12	* Software distributed under the License is distributed on an "AS
13	* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
14	* implied. See the License for the specific language governing rights
15	* and limitations under the License.
16	*
17	* The Initial Developer of the Original Code is Tony Whyman.
18	*
19	* The Original Code is (C) 2016 Tony Whyman, MWA Software
20	* (http://www.mwasoftware.co.uk).
21	*
22	* All Rights Reserved.
23	*
24	* Contributor(s): ______________________________________.
25	*
26	*)
27	unit FB30Attachment;
28	{$IFDEF MSWINDOWS}
29	{$DEFINE WINDOWS}
30	{$ENDIF}
31
32	{$IFDEF FPC}
33	{$mode delphi}
34	{$interfaces COM}
35	{$ENDIF}
36
37	interface
38
39	uses
40	Classes, SysUtils, FBAttachment, FB30ClientAPI, Firebird, IB, FBActivityMonitor, FBParamBlock;
41
42	type
43
44	{ TFB30Attachment }
45
46	TFB30Attachment = class(TFBAttachment,IAttachment, IActivityMonitor)
47	private
48	FAttachmentIntf: Firebird.IAttachment;
49	FFirebird30ClientAPI: TFB30ClientAPI;
50	protected
51	procedure CheckHandle; override;
52	public
53	constructor Create(api: TFB30ClientAPI; DatabaseName: AnsiString; aDPB: IDPB;
54	RaiseExceptionOnConnectError: boolean);
55	constructor CreateDatabase(api: TFB30ClientAPI; DatabaseName: AnsiString; aDPB: IDPB; RaiseExceptionOnError: boolean); overload;
56	constructor CreateDatabase(api: TFB30ClientAPI; sql: AnsiString; aSQLDialect: integer;
57	RaiseExceptionOnError: boolean); overload;
58	destructor Destroy; override;
59	function GetDBInfo(ReqBuffer: PByte; ReqBufLen: integer): IDBInformation;
60	override;
61	property AttachmentIntf: Firebird.IAttachment read FAttachmentIntf;
62	property Firebird30ClientAPI: TFB30ClientAPI read FFirebird30ClientAPI;
63
64	public
65	{IAttachment}
66	procedure Connect;
67	procedure Disconnect(Force: boolean=false); override;
68	function IsConnected: boolean; override;
69	procedure DropDatabase;
70	function StartTransaction(TPB: array of byte; DefaultCompletion: TTransactionCompletion): ITransaction; override;
71	function StartTransaction(TPB: ITPB; DefaultCompletion: TTransactionCompletion): ITransaction; override;
72	procedure ExecImmediate(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer); override;
73	function Prepare(transaction: ITransaction; sql: AnsiString; aSQLDialect: integer): IStatement; override;
74	function PrepareWithNamedParameters(transaction: ITransaction; sql: AnsiString;
75	aSQLDialect: integer; GenerateParamNames: boolean=false): IStatement; override;
76
77	{Events}
78	function GetEventHandler(Events: TStrings): IEvents; override;
79
80	{Blob - may use to open existing Blobs. However, ISQLData.AsBlob is preferred}
81
82	function CreateBlob(transaction: ITransaction; RelationName, ColumnName: AnsiString; BPB: IBPB=nil): IBlob; overload;
83	function CreateBlob(transaction: ITransaction; BlobMetaData: IBlobMetaData; BPB: IBPB=nil): IBlob; overload;
84	function CreateBlob(transaction: ITransaction; SubType: integer; aCharSetID: cardinal=0; BPB: IBPB=nil): IBlob; overload;
85	function OpenBlob(transaction: ITransaction; RelationName, ColumnName: AnsiString; BlobID: TISC_QUAD; BPB: IBPB=nil): IBlob; overload;
86	function OpenBlob(transaction: ITransaction; BlobMetaData: IBlobMetaData; BlobID: TISC_QUAD; BPB: IBPB=nil): IBlob; overload; override;
87
88	{Array}
89	function OpenArray(transaction: ITransaction; RelationName, ColumnName: AnsiString; ArrayID: TISC_QUAD): IArray;
90	function CreateArray(transaction: ITransaction; RelationName, ColumnName: AnsiString): IArray; overload;
91	function CreateArray(transaction: ITransaction; ArrayMetaData: IArrayMetaData): IArray; overload;
92	function CreateArrayMetaData(SQLType: cardinal; tableName: AnsiString;
93	columnName: AnsiString; Scale: integer; size: cardinal; aCharSetID: cardinal;
94	dimensions: cardinal; bounds: TArrayBounds): IArrayMetaData;
95
96
97	{Database Information}
98	function GetBlobMetaData(Transaction: ITransaction; tableName, columnName: AnsiString): IBlobMetaData;
99	function GetArrayMetaData(Transaction: ITransaction; tableName, columnName: AnsiString): IArrayMetaData;
100	end;
101
102	implementation
103
104	uses FB30Transaction, FB30Statement, FB30Array, FB30Blob, FBMessages,
105	FBOutputBlock, FB30Events, IBUtils;
106
107	{ TFB30Attachment }
108
109	procedure TFB30Attachment.CheckHandle;
110	begin
111	if FAttachmentIntf = nil then
112	IBError(ibxeDatabaseClosed,[nil]);
113	end;
114
115	constructor TFB30Attachment.Create(api: TFB30ClientAPI; DatabaseName: AnsiString; aDPB: IDPB;
116	RaiseExceptionOnConnectError: boolean);
117	begin
118	FFirebird30ClientAPI := api;
119	if aDPB = nil then
120	begin
121	if RaiseExceptionOnConnectError then
122	IBError(ibxeNoDPB,[nil]);
123	Exit;
124	end;
125	inherited Create(api,DatabaseName,aDPB,RaiseExceptionOnConnectError);
126	Connect;
127	end;
128
129	constructor TFB30Attachment.CreateDatabase(api: TFB30ClientAPI; DatabaseName: AnsiString; aDPB: IDPB;
130	RaiseExceptionOnError: boolean);
131	var Param: IDPBItem;
132	sql: AnsiString;
133	IsCreateDB: boolean;
134	begin
135	inherited Create(api,DatabaseName,aDPB,RaiseExceptionOnError);
136	FFirebird30ClientAPI := api;
137	IsCreateDB := true;
138	if aDPB <> nil then
139	begin
140	Param := aDPB.Find(isc_dpb_set_db_SQL_dialect);
141	if Param <> nil then
142	FSQLDialect := Param.AsByte;
143	end;
144	sql := GenerateCreateDatabaseSQL(DatabaseName,aDPB);
145	with FFirebird30ClientAPI do
146	begin
147	FAttachmentIntf := UtilIntf.executeCreateDatabase(StatusIntf,Length(sql),
148	PAnsiChar(sql),FSQLDialect,@IsCreateDB);
149	if FRaiseExceptionOnConnectError then Check4DataBaseError;
150	if InErrorState then
151	FAttachmentIntf := nil
152	else
153	if aDPB <> nil then
154	{Connect using known parameters}
155	begin
156	Disconnect;
157	Connect;
158	end
159	else
160	GetODSAndConnectionInfo;
161	end;
162	end;
163
164	constructor TFB30Attachment.CreateDatabase(api: TFB30ClientAPI; sql: AnsiString; aSQLDialect: integer;
165	RaiseExceptionOnError: boolean);
166	var IsCreateDB: boolean;
167	begin
168	inherited Create(api,'',nil,RaiseExceptionOnError);
169	FFirebird30ClientAPI := api;
170	FSQLDialect := aSQLDialect;
171	with FFirebird30ClientAPI do
172	begin
173	FAttachmentIntf := UtilIntf.executeCreateDatabase(StatusIntf,Length(sql),
174	PAnsiChar(sql),aSQLDialect,@IsCreateDB);
175	if FRaiseExceptionOnConnectError then Check4DataBaseError;
176	if InErrorState then
177	FAttachmentIntf := nil;
178	end;
179	GetODSAndConnectionInfo;
180	ExtractConnectString(sql,FDatabaseName);
181	DPBFromCreateSQL(sql);
182	end;
183
184	destructor TFB30Attachment.Destroy;
185	begin
186	inherited Destroy;
187	if assigned(FAttachmentIntf) then
188	FAttachmentIntf.release;
189	end;
190
191	function TFB30Attachment.GetDBInfo(ReqBuffer: PByte; ReqBufLen: integer): IDBInformation;
192	begin
193	Result := TDBInformation.Create(Firebird30ClientAPI);
194	with FFirebird30ClientAPI, Result as TDBInformation do
195	begin
196	FAttachmentIntf.getInfo(StatusIntf, ReqBufLen, BytePtr(ReqBuffer),
197	getBufSize, BytePtr(Buffer));
198	Check4DataBaseError;
199	end
200	end;
201
202	procedure TFB30Attachment.Connect;
203	begin
204	with FFirebird30ClientAPI do
205	begin
206	FAttachmentIntf := ProviderIntf.attachDatabase(StatusIntf,PAnsiChar(FDatabaseName),
207	(DPB as TDPB).getDataLength,
208	BytePtr((DPB as TDPB).getBuffer));
209	if FRaiseExceptionOnConnectError then Check4DataBaseError;
210	if InErrorState then
211	FAttachmentIntf := nil
212	else
213	GetODSAndConnectionInfo;
214	end;
215	end;
216
217	procedure TFB30Attachment.Disconnect(Force: boolean);
218	begin
219	if IsConnected then
220	with FFirebird30ClientAPI do
221	begin
222	EndAllTransactions;
223	FAttachmentIntf.Detach(StatusIntf);
224	if not Force and InErrorState then
225	IBDataBaseError;
226	FAttachmentIntf := nil;
227	FHasDefaultCharSet := false;
228	FCodePage := CP_NONE;
229	FCharSetID := 0;
230	end;
231	end;
232
233	function TFB30Attachment.IsConnected: boolean;
234	begin
235	Result := FAttachmentIntf <> nil;
236	end;
237
238	procedure TFB30Attachment.DropDatabase;
239	begin
240	if IsConnected then
241	with FFirebird30ClientAPI do
242	begin
243	EndAllTransactions;
244	FAttachmentIntf.dropDatabase(StatusIntf);
245	Check4DataBaseError;
246	FAttachmentIntf := nil;
247	end;
248	end;
249
250	function TFB30Attachment.StartTransaction(TPB: array of byte;
251	DefaultCompletion: TTransactionCompletion): ITransaction;
252	begin
253	CheckHandle;
254	Result := TFB30Transaction.Create(FFirebird30ClientAPI,self,TPB,DefaultCompletion);
255	end;
256
257	function TFB30Attachment.StartTransaction(TPB: ITPB;
258	DefaultCompletion: TTransactionCompletion): ITransaction;
259	begin
260	CheckHandle;
261	Result := TFB30Transaction.Create(FFirebird30ClientAPI,self,TPB,DefaultCompletion);
262	end;
263
264	procedure TFB30Attachment.ExecImmediate(transaction: ITransaction; sql: AnsiString;
265	aSQLDialect: integer);
266	begin
267	CheckHandle;
268	with FFirebird30ClientAPI do
269	begin
270	FAttachmentIntf.execute(StatusIntf,(transaction as TFB30Transaction).TransactionIntf,
271	Length(sql),PAnsiChar(sql),aSQLDialect,nil,nil,nil,nil);
272	Check4DataBaseError;
273	end;
274	end;
275
276	function TFB30Attachment.Prepare(transaction: ITransaction; sql: AnsiString;
277	aSQLDialect: integer): IStatement;
278	begin
279	CheckHandle;
280	Result := TFB30Statement.Create(self,transaction,sql,aSQLDialect);
281	end;
282
283	function TFB30Attachment.PrepareWithNamedParameters(transaction: ITransaction;
284	sql: AnsiString; aSQLDialect: integer; GenerateParamNames: boolean): IStatement;
285	begin
286	CheckHandle;
287	Result := TFB30Statement.CreateWithParameterNames(self,transaction,sql,aSQLDialect,
288	GenerateParamNames);
289	end;
290
291	function TFB30Attachment.GetEventHandler(Events: TStrings): IEvents;
292	begin
293	CheckHandle;
294	Result := TFB30Events.Create(self,Events);
295	end;
296
297	function TFB30Attachment.CreateBlob(transaction: ITransaction; RelationName,
298	ColumnName: AnsiString; BPB: IBPB): IBlob;
299	begin
300	CheckHandle;
301	Result := TFB30Blob.Create(self,transaction as TFB30Transaction,
302	TFB30BlobMetaData.Create(self,Transaction as TFB30Transaction,RelationName,ColumnName),BPB);
303	end;
304
305	function TFB30Attachment.CreateBlob(transaction: ITransaction;
306	BlobMetaData: IBlobMetaData; BPB: IBPB): IBlob;
307	begin
308	CheckHandle;
309	Result := TFB30Blob.Create(self,transaction as TFB30Transaction, BlobMetaData,BPB);
310	end;
311
312	function TFB30Attachment.CreateBlob(transaction: ITransaction;
313	SubType: integer; aCharSetID: cardinal; BPB: IBPB): IBlob;
314	begin
315	CheckHandle;
316	Result := TFB30Blob.Create(self,transaction as TFB30Transaction, SubType,aCharSetID,BPB);
317	end;
318
319	function TFB30Attachment.OpenBlob(transaction: ITransaction; RelationName,
320	ColumnName: AnsiString; BlobID: TISC_QUAD; BPB: IBPB): IBlob;
321	begin
322	CheckHandle;
323	Result := TFB30Blob.Create(self,transaction as TFB30transaction,
324	TFB30BlobMetaData.Create(self,Transaction as TFB30Transaction,RelationName,ColumnName),
325	BlobID,BPB);
326	end;
327
328	function TFB30Attachment.OpenBlob(transaction: ITransaction;
329	BlobMetaData: IBlobMetaData; BlobID: TISC_QUAD; BPB: IBPB): IBlob;
330	begin
331	CheckHandle;
332	Result := TFB30Blob.Create(self,transaction as TFB30transaction,BlobMetaData,BlobID,BPB);
333	end;
334
335	function TFB30Attachment.OpenArray(transaction: ITransaction; RelationName,
336	ColumnName: AnsiString; ArrayID: TISC_QUAD): IArray;
337	begin
338	CheckHandle;
339	Result := TFB30Array.Create(self,transaction as TFB30Transaction,
340	GetArrayMetaData(transaction,RelationName,ColumnName),ArrayID);
341	end;
342
343	function TFB30Attachment.CreateArray(transaction: ITransaction; RelationName,
344	ColumnName: AnsiString): IArray;
345	begin
346	CheckHandle;
347	Result := TFB30Array.Create(self,transaction as TFB30Transaction,
348	GetArrayMetaData(transaction,RelationName,ColumnName));
349	end;
350
351	function TFB30Attachment.CreateArray(transaction: ITransaction;
352	ArrayMetaData: IArrayMetaData): IArray;
353	begin
354	CheckHandle;
355	Result := TFB30Array.Create(self,transaction as TFB30Transaction,ArrayMetaData);
356	end;
357
358	function TFB30Attachment.CreateArrayMetaData(SQLType: cardinal; tableName: AnsiString; columnName: AnsiString;
359	Scale: integer; size: cardinal; aCharSetID: cardinal; dimensions: cardinal;
360	bounds: TArrayBounds): IArrayMetaData;
361	begin
362	Result := TFB30ArrayMetaData.Create(self,SQLType,tableName,ColumnName,Scale,size,aCharSetID, dimensions,bounds);
363	end;
364
365	function TFB30Attachment.GetBlobMetaData(Transaction: ITransaction; tableName,
366	columnName: AnsiString): IBlobMetaData;
367	begin
368	CheckHandle;
369	Result := TFB30BlobMetaData.Create(self,Transaction as TFB30Transaction,tableName,columnName);
370	end;
371
372	function TFB30Attachment.GetArrayMetaData(Transaction: ITransaction; tableName,
373	columnName: AnsiString): IArrayMetaData;
374	begin
375	CheckHandle;
376	Result := TFB30ArrayMetaData.Create(self,Transaction as TFB30Transaction,tableName,columnName);
377	end;
378
379	end.
380