fbintf/client/FBAttachment.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 FBAttachment;

{$IFDEF FPC}
{$mode objfpc}{$H+}
{$interfaces COM}
{$ENDIF}

interface

uses
  Classes, SysUtils, IB,  FBParamBlock, FBActivityMonitor;

type

  { TFBAttachment }

  TFBAttachment = class(TActivityHandler)
  private
    FDPB: IDPB;
    FFirebirdAPI: IFirebirdAPI;
  protected
    FDatabaseName: string;
    FRaiseExceptionOnConnectError: boolean;
    FSQLDialect: integer;
    FHasDefaultCharSet: boolean;
    FCharSetID: integer;
    FCodePage: TSystemCodePage;
    constructor Create(DatabaseName: string; DPB: IDPB;
      RaiseExceptionOnConnectError: boolean);
    procedure CheckHandle; virtual; abstract;
    function GenerateCreateDatabaseSQL(DatabaseName: string; aDPB: IDPB): string;
    procedure EndAllTransactions;
    procedure SetParameters(SQLParams: ISQLParams; params: array of const);
  public
    destructor Destroy; override;
    function getDPB: IDPB;
    function AllocateBPB: IBPB;
    function StartTransaction(TPB: array of byte; DefaultCompletion: TTransactionCompletion): ITransaction; overload; virtual; abstract;
    function StartTransaction(TPB: ITPB; DefaultCompletion: TTransactionCompletion): ITransaction; overload; virtual; abstract;
    procedure Disconnect(Force: boolean=false); virtual; abstract;
    procedure ExecImmediate(transaction: ITransaction; sql: string; aSQLDialect: integer); overload; virtual; abstract;
    procedure ExecImmediate(TPB: array of byte; sql: string; aSQLDialect: integer); overload;
    procedure ExecImmediate(transaction: ITransaction; sql: string); overload;
    procedure ExecImmediate(TPB: array of byte; sql: string); overload;
    function ExecuteSQL(TPB: array of byte; sql: string; SQLDialect: integer; params: array of const): IResults; overload;
    function ExecuteSQL(transaction: ITransaction; sql: string; SQLDialect: integer; params: array of const): IResults; overload;
    function ExecuteSQL(TPB: array of byte; sql: string; params: array of const): IResults; overload;
    function ExecuteSQL(transaction: ITransaction; sql: string; params: array of const): IResults; overload;
    function OpenCursor(transaction: ITransaction; sql: string; aSQLDialect: integer): IResultSet; overload;
    function OpenCursor(transaction: ITransaction; sql: string; aSQLDialect: integer;
                             params: array of const): IResultSet; overload;
    function OpenCursor(transaction: ITransaction; sql: string): IResultSet; overload;
    function OpenCursor(transaction: ITransaction; sql: string;
                             params: array of const): IResultSet; overload;
    function OpenCursorAtStart(transaction: ITransaction; sql: string; aSQLDialect: integer): IResultSet; overload;
    function OpenCursorAtStart(transaction: ITransaction; sql: string; aSQLDialect: integer;
                             params: array of const): IResultSet; overload;
    function OpenCursorAtStart(transaction: ITransaction; sql: string): IResultSet; overload;
    function OpenCursorAtStart(transaction: ITransaction; sql: string;
                             params: array of const): IResultSet; overload;
    function OpenCursorAtStart(sql: string): IResultSet; overload;
    function OpenCursorAtStart(sql: string;
                             params: array of const): IResultSet; overload;
    function Prepare(transaction: ITransaction; sql: string; aSQLDialect: integer): IStatement; overload; virtual; abstract;
    function Prepare(transaction: ITransaction; sql: string): IStatement; overload;
    function PrepareWithNamedParameters(transaction: ITransaction; sql: string;
                       aSQLDialect: integer; GenerateParamNames: boolean=false): IStatement; overload; virtual; abstract;
    function PrepareWithNamedParameters(transaction: ITransaction; sql: string;
                       GenerateParamNames: boolean=false): IStatement; overload;
    function GetEventHandler(Events: TStrings): IEvents; overload; virtual; abstract;
    function GetEventHandler(Event: string): IEvents; overload;

    function GetSQLDialect: integer;
    function OpenBlob(transaction: ITransaction; BlobMetaData: IBlobMetaData; BlobID: TISC_QUAD; BPB: IBPB=nil): IBlob; virtual; abstract; overload;
    function OpenBlob(transaction: ITransaction; Field: ISQLData; BPB: IBPB=nil): IBlob; overload;
    property SQLDialect: integer read FSQLDialect;
    property HasDefaultCharSet: boolean read FHasDefaultCharSet;
    property CharSetID: integer read FCharSetID;
    property CodePage: TSystemCodePage read FCodePage;
    property DPB: IDPB read FDPB;
  end;

implementation

uses FBMessages, FBTransaction;

{ TFBAttachment }

constructor TFBAttachment.Create(DatabaseName: string; DPB: IDPB;
  RaiseExceptionOnConnectError: boolean);
begin
  inherited Create;
  FFirebirdAPI := FirebirdAPI; {Keep reference to interface}
  FSQLDialect := 3;
  FDatabaseName := DatabaseName;
  FDPB := DPB;
  FRaiseExceptionOnConnectError := RaiseExceptionOnConnectError;
end;

function TFBAttachment.GenerateCreateDatabaseSQL(DatabaseName: string;  aDPB: IDPB): string;
var CreateParams: string;
    DPBItem: IDPBItem;
begin
  CreateParams := '';

  if aDPB <> nil then
  begin
    DPBItem :=  aDPB.Find(isc_dpb_user_name);
    if DPBItem <> nil then
      CreateParams += ' USER ''' + DPBItem.AsString + '''';

    DPBItem :=  aDPB.Find(isc_dpb_password);
    if DPBItem <> nil then
      CreateParams += ' Password ''' + DPBItem.AsString + '''';

    DPBItem :=  aDPB.Find(isc_dpb_page_size);
    if DPBItem <> nil then
      CreateParams += ' PAGE_SIZE ' + DPBItem.AsString;

    DPBItem :=  aDPB.Find(isc_dpb_lc_ctype);
    if DPBItem <> nil then
      CreateParams += ' DEFAULT CHARACTER SET ' + DPBItem.AsString;

    DPBItem :=  aDPB.Find(isc_dpb_sql_dialect);
    if DPBItem <> nil then
      FSQLDialect := DPBItem.AsInteger;
  end;

  Result := 'CREATE DATABASE ''' + DatabaseName + ''' ' + CreateParams; {do not localize}
end;

procedure TFBAttachment.EndAllTransactions;
var i: integer;
    intf: TInterfacedObject;
begin
  for i := 0 to InterfaceCount - 1 do
  begin
    intf := GetInterface(i);
    if (intf <> nil) and  (intf is TFBTransaction) then
      TFBTransaction(intf).DoDefaultTransactionEnd(true);
  end;
end;

procedure TFBAttachment.SetParameters(SQLParams: ISQLParams;
  params: array of const);
var i: integer;
begin
  if SQLParams.Count <> Length(params) then
    IBError(ibxeInvalidParamCount,[SQLParams.Count,Length(params)]);

  for i := 0 to High(params) do
  begin
    case params[i].vtype of
      vtinteger    :
        SQLParams[i].AsInteger := params[i].vinteger;
      vtboolean    :
        SQLParams[i].AsBoolean :=  params[i].vboolean;
      vtchar       :
        SQLParams[i].AsString := params[i].vchar;
      vtextended   :
        SQLParams[i].AsDouble := params[i].VExtended^;
      vtCurrency:
        SQLParams[i].AsDouble := params[i].VCurrency^;
      vtString     :
        SQLParams[i].AsString := params[i].VString^;
      vtPChar      :
        SQLParams[i].AsString := strpas(params[i].VPChar);
      vtAnsiString :
        SQLParams[i].AsString := AnsiString(params[i].VAnsiString^);
      vtVariant:
        SQLParams[i].AsVariant := params[i].VVariant^;
    else
        IBError(ibxeInvalidVariantType,[nil]);
    end;
  end;
end;

destructor TFBAttachment.Destroy;
begin
  Disconnect(true);
  inherited Destroy;
end;

function TFBAttachment.getDPB: IDPB;
begin
  Result := FDPB;
end;

function TFBAttachment.AllocateBPB: IBPB;
begin
  Result := TBPB.Create;
end;

procedure TFBAttachment.ExecImmediate(TPB: array of byte; sql: string;
  aSQLDialect: integer);
begin
  ExecImmediate(StartTransaction(TPB,taCommit),sql,aSQLDialect);
end;

procedure TFBAttachment.ExecImmediate(transaction: ITransaction; sql: string);
begin
  ExecImmediate(transaction,sql,FSQLDialect);
end;

procedure TFBAttachment.ExecImmediate(TPB: array of byte; sql: string);
begin
  ExecImmediate(StartTransaction(TPB,taCommit),sql,FSQLDialect);
end;

function TFBAttachment.ExecuteSQL(TPB: array of byte; sql: string;
  SQLDialect: integer; params: array of const): IResults;
begin
  Result := ExecuteSQL(StartTransaction(TPB,taCommit),sql,FSQLDialect,params);
end;

function TFBAttachment.ExecuteSQL(transaction: ITransaction; sql: string;
  SQLDialect: integer; params: array of const): IResults;
begin
  with Prepare(transaction,sql,SQLDialect) do
  begin
    SetParameters(SQLParams,params);
    Result := Execute;
  end;
end;

function TFBAttachment.ExecuteSQL(TPB: array of byte; sql: string;
  params: array of const): IResults;
begin
   Result := ExecuteSQL(StartTransaction(TPB,taCommit),sql,params);
end;

function TFBAttachment.ExecuteSQL(transaction: ITransaction; sql: string;
  params: array of const): IResults;
begin
  with Prepare(transaction,sql,FSQLDialect) do
  begin
    SetParameters(SQLParams,params);
    Result := Execute;
  end;
end;

function TFBAttachment.OpenCursor(transaction: ITransaction; sql: string;
  aSQLDialect: integer): IResultSet;
begin
  Result := OpenCursor(transaction,sql,aSQLDialect,[]);
end;

function TFBAttachment.OpenCursor(transaction: ITransaction; sql: string;
  aSQLDialect: integer; params: array of const): IResultSet;
var Statement: IStatement;
begin
  CheckHandle;
  Statement := Prepare(transaction,sql,aSQLDialect);
  SetParameters(Statement.SQLParams,params);
  Result := Statement.OpenCursor;
end;

function TFBAttachment.OpenCursor(transaction: ITransaction; sql: string
  ): IResultSet;
begin
  Result := OpenCursor(transaction,sql,FSQLDialect,[]);
end;

function TFBAttachment.OpenCursor(transaction: ITransaction; sql: string;
  params: array of const): IResultSet;
begin
  Result := OpenCursor(transaction,sql,FSQLDialect,params);
end;

function TFBAttachment.OpenCursorAtStart(transaction: ITransaction;
  sql: string; aSQLDialect: integer): IResultSet;
begin
  Result := OpenCursor(transaction,sql,aSQLDialect,[]);
  Result.FetchNext;
end;

function TFBAttachment.OpenCursorAtStart(transaction: ITransaction;
  sql: string; aSQLDialect: integer; params: array of const): IResultSet;
begin
  Result := OpenCursor(transaction,sql,aSQLDialect,params);
  Result.FetchNext;
end;

function TFBAttachment.OpenCursorAtStart(transaction: ITransaction; sql: string
  ): IResultSet;
begin
  Result := OpenCursorAtStart(transaction,sql,FSQLDialect,[]);
end;

function TFBAttachment.OpenCursorAtStart(transaction: ITransaction;
  sql: string; params: array of const): IResultSet;
begin
  Result := OpenCursorAtStart(transaction,sql,FSQLDialect,params);
end;

function TFBAttachment.OpenCursorAtStart(sql: string): IResultSet;
begin
  Result := OpenCursorAtStart(sql,[]);
end;

function TFBAttachment.OpenCursorAtStart(sql: string;
  params: array of const): IResultSet;
begin
  Result := OpenCursorAtStart(StartTransaction([isc_tpb_read,isc_tpb_wait,isc_tpb_concurrency],taCommit),sql,FSQLDialect,params);
end;

function TFBAttachment.Prepare(transaction: ITransaction; sql: string
  ): IStatement;
begin
  Result := Prepare(transaction,sql,FSQLDialect);
end;

function TFBAttachment.PrepareWithNamedParameters(transaction: ITransaction;
  sql: string; GenerateParamNames: boolean): IStatement;
begin
  Result := PrepareWithNamedParameters(transaction,sql,FSQLDialect,GenerateParamNames);
end;

function TFBAttachment.GetEventHandler(Event: string): IEvents;
var S: TStringList;
begin
  S := TStringList.Create;
  try
    S.Add(Event);
    Result := GetEventHandler(S);
  finally
    S.Free;
  end;
end;

function TFBAttachment.GetSQLDialect: integer;
begin
  Result := FSQLDialect;
end;

function TFBAttachment.OpenBlob(transaction: ITransaction; Field: ISQLData;
  BPB: IBPB): IBlob;
begin
  Result := OpenBlob(Transaction,Field.GetBlobMetadata, Field.AsQuad,BPB);
end;

end.

Revision:	45
Committed:	Tue Dec 6 10:33:46 2016 UTC (8 years ago) by tony
Content type:	text/x-pascal
Original Path:	*ibx/trunk/fbintf/client/FBAttachment.pas*
File size:	12691 byte(s)
Log Message:	Committing updates for Release R2-0-0
#	User	Rev	Content
1	tony	45	(*
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 FBAttachment;
28
29			{$IFDEF FPC}
30			{$mode objfpc}{$H+}
31			{$interfaces COM}
32			{$ENDIF}
33
34			interface
35
36			uses
37			Classes, SysUtils, IB, FBParamBlock, FBActivityMonitor;
38
39			type
40
41			{ TFBAttachment }
42
43			TFBAttachment = class(TActivityHandler)
44			private
45			FDPB: IDPB;
46			FFirebirdAPI: IFirebirdAPI;
47			protected
48			FDatabaseName: string;
49			FRaiseExceptionOnConnectError: boolean;
50			FSQLDialect: integer;
51			FHasDefaultCharSet: boolean;
52			FCharSetID: integer;
53			FCodePage: TSystemCodePage;
54			constructor Create(DatabaseName: string; DPB: IDPB;
55			RaiseExceptionOnConnectError: boolean);
56			procedure CheckHandle; virtual; abstract;
57			function GenerateCreateDatabaseSQL(DatabaseName: string; aDPB: IDPB): string;
58			procedure EndAllTransactions;
59			procedure SetParameters(SQLParams: ISQLParams; params: array of const);
60			public
61			destructor Destroy; override;
62			function getDPB: IDPB;
63			function AllocateBPB: IBPB;
64			function StartTransaction(TPB: array of byte; DefaultCompletion: TTransactionCompletion): ITransaction; overload; virtual; abstract;
65			function StartTransaction(TPB: ITPB; DefaultCompletion: TTransactionCompletion): ITransaction; overload; virtual; abstract;
66			procedure Disconnect(Force: boolean=false); virtual; abstract;
67			procedure ExecImmediate(transaction: ITransaction; sql: string; aSQLDialect: integer); overload; virtual; abstract;
68			procedure ExecImmediate(TPB: array of byte; sql: string; aSQLDialect: integer); overload;
69			procedure ExecImmediate(transaction: ITransaction; sql: string); overload;
70			procedure ExecImmediate(TPB: array of byte; sql: string); overload;
71			function ExecuteSQL(TPB: array of byte; sql: string; SQLDialect: integer; params: array of const): IResults; overload;
72			function ExecuteSQL(transaction: ITransaction; sql: string; SQLDialect: integer; params: array of const): IResults; overload;
73			function ExecuteSQL(TPB: array of byte; sql: string; params: array of const): IResults; overload;
74			function ExecuteSQL(transaction: ITransaction; sql: string; params: array of const): IResults; overload;
75			function OpenCursor(transaction: ITransaction; sql: string; aSQLDialect: integer): IResultSet; overload;
76			function OpenCursor(transaction: ITransaction; sql: string; aSQLDialect: integer;
77			params: array of const): IResultSet; overload;
78			function OpenCursor(transaction: ITransaction; sql: string): IResultSet; overload;
79			function OpenCursor(transaction: ITransaction; sql: string;
80			params: array of const): IResultSet; overload;
81			function OpenCursorAtStart(transaction: ITransaction; sql: string; aSQLDialect: integer): IResultSet; overload;
82			function OpenCursorAtStart(transaction: ITransaction; sql: string; aSQLDialect: integer;
83			params: array of const): IResultSet; overload;
84			function OpenCursorAtStart(transaction: ITransaction; sql: string): IResultSet; overload;
85			function OpenCursorAtStart(transaction: ITransaction; sql: string;
86			params: array of const): IResultSet; overload;
87			function OpenCursorAtStart(sql: string): IResultSet; overload;
88			function OpenCursorAtStart(sql: string;
89			params: array of const): IResultSet; overload;
90			function Prepare(transaction: ITransaction; sql: string; aSQLDialect: integer): IStatement; overload; virtual; abstract;
91			function Prepare(transaction: ITransaction; sql: string): IStatement; overload;
92			function PrepareWithNamedParameters(transaction: ITransaction; sql: string;
93			aSQLDialect: integer; GenerateParamNames: boolean=false): IStatement; overload; virtual; abstract;
94			function PrepareWithNamedParameters(transaction: ITransaction; sql: string;
95			GenerateParamNames: boolean=false): IStatement; overload;
96			function GetEventHandler(Events: TStrings): IEvents; overload; virtual; abstract;
97			function GetEventHandler(Event: string): IEvents; overload;
98
99			function GetSQLDialect: integer;
100			function OpenBlob(transaction: ITransaction; BlobMetaData: IBlobMetaData; BlobID: TISC_QUAD; BPB: IBPB=nil): IBlob; virtual; abstract; overload;
101			function OpenBlob(transaction: ITransaction; Field: ISQLData; BPB: IBPB=nil): IBlob; overload;
102			property SQLDialect: integer read FSQLDialect;
103			property HasDefaultCharSet: boolean read FHasDefaultCharSet;
104			property CharSetID: integer read FCharSetID;
105			property CodePage: TSystemCodePage read FCodePage;
106			property DPB: IDPB read FDPB;
107			end;
108
109			implementation
110
111			uses FBMessages, FBTransaction;
112
113			{ TFBAttachment }
114
115			constructor TFBAttachment.Create(DatabaseName: string; DPB: IDPB;
116			RaiseExceptionOnConnectError: boolean);
117			begin
118			inherited Create;
119			FFirebirdAPI := FirebirdAPI; {Keep reference to interface}
120			FSQLDialect := 3;
121			FDatabaseName := DatabaseName;
122			FDPB := DPB;
123			FRaiseExceptionOnConnectError := RaiseExceptionOnConnectError;
124			end;
125
126			function TFBAttachment.GenerateCreateDatabaseSQL(DatabaseName: string; aDPB: IDPB): string;
127			var CreateParams: string;
128			DPBItem: IDPBItem;
129			begin
130			CreateParams := '';
131
132			if aDPB <> nil then
133			begin
134			DPBItem := aDPB.Find(isc_dpb_user_name);
135			if DPBItem <> nil then
136			CreateParams += ' USER ''' + DPBItem.AsString + '''';
137
138			DPBItem := aDPB.Find(isc_dpb_password);
139			if DPBItem <> nil then
140			CreateParams += ' Password ''' + DPBItem.AsString + '''';
141
142			DPBItem := aDPB.Find(isc_dpb_page_size);
143			if DPBItem <> nil then
144			CreateParams += ' PAGE_SIZE ' + DPBItem.AsString;
145
146			DPBItem := aDPB.Find(isc_dpb_lc_ctype);
147			if DPBItem <> nil then
148			CreateParams += ' DEFAULT CHARACTER SET ' + DPBItem.AsString;
149
150			DPBItem := aDPB.Find(isc_dpb_sql_dialect);
151			if DPBItem <> nil then
152			FSQLDialect := DPBItem.AsInteger;
153			end;
154
155			Result := 'CREATE DATABASE ''' + DatabaseName + ''' ' + CreateParams; {do not localize}
156			end;
157
158			procedure TFBAttachment.EndAllTransactions;
159			var i: integer;
160			intf: TInterfacedObject;
161			begin
162			for i := 0 to InterfaceCount - 1 do
163			begin
164			intf := GetInterface(i);
165			if (intf <> nil) and (intf is TFBTransaction) then
166			TFBTransaction(intf).DoDefaultTransactionEnd(true);
167			end;
168			end;
169
170			procedure TFBAttachment.SetParameters(SQLParams: ISQLParams;
171			params: array of const);
172			var i: integer;
173			begin
174			if SQLParams.Count <> Length(params) then
175			IBError(ibxeInvalidParamCount,[SQLParams.Count,Length(params)]);
176
177			for i := 0 to High(params) do
178			begin
179			case params[i].vtype of
180			vtinteger :
181			SQLParams[i].AsInteger := params[i].vinteger;
182			vtboolean :
183			SQLParams[i].AsBoolean := params[i].vboolean;
184			vtchar :
185			SQLParams[i].AsString := params[i].vchar;
186			vtextended :
187			SQLParams[i].AsDouble := params[i].VExtended^;
188			vtCurrency:
189			SQLParams[i].AsDouble := params[i].VCurrency^;
190			vtString :
191			SQLParams[i].AsString := params[i].VString^;
192			vtPChar :
193			SQLParams[i].AsString := strpas(params[i].VPChar);
194			vtAnsiString :
195			SQLParams[i].AsString := AnsiString(params[i].VAnsiString^);
196			vtVariant:
197			SQLParams[i].AsVariant := params[i].VVariant^;
198			else
199			IBError(ibxeInvalidVariantType,[nil]);
200			end;
201			end;
202			end;
203
204			destructor TFBAttachment.Destroy;
205			begin
206			Disconnect(true);
207			inherited Destroy;
208			end;
209
210			function TFBAttachment.getDPB: IDPB;
211			begin
212			Result := FDPB;
213			end;
214
215			function TFBAttachment.AllocateBPB: IBPB;
216			begin
217			Result := TBPB.Create;
218			end;
219
220			procedure TFBAttachment.ExecImmediate(TPB: array of byte; sql: string;
221			aSQLDialect: integer);
222			begin
223			ExecImmediate(StartTransaction(TPB,taCommit),sql,aSQLDialect);
224			end;
225
226			procedure TFBAttachment.ExecImmediate(transaction: ITransaction; sql: string);
227			begin
228			ExecImmediate(transaction,sql,FSQLDialect);
229			end;
230
231			procedure TFBAttachment.ExecImmediate(TPB: array of byte; sql: string);
232			begin
233			ExecImmediate(StartTransaction(TPB,taCommit),sql,FSQLDialect);
234			end;
235
236			function TFBAttachment.ExecuteSQL(TPB: array of byte; sql: string;
237			SQLDialect: integer; params: array of const): IResults;
238			begin
239			Result := ExecuteSQL(StartTransaction(TPB,taCommit),sql,FSQLDialect,params);
240			end;
241
242			function TFBAttachment.ExecuteSQL(transaction: ITransaction; sql: string;
243			SQLDialect: integer; params: array of const): IResults;
244			begin
245			with Prepare(transaction,sql,SQLDialect) do
246			begin
247			SetParameters(SQLParams,params);
248			Result := Execute;
249			end;
250			end;
251
252			function TFBAttachment.ExecuteSQL(TPB: array of byte; sql: string;
253			params: array of const): IResults;
254			begin
255			Result := ExecuteSQL(StartTransaction(TPB,taCommit),sql,params);
256			end;
257
258			function TFBAttachment.ExecuteSQL(transaction: ITransaction; sql: string;
259			params: array of const): IResults;
260			begin
261			with Prepare(transaction,sql,FSQLDialect) do
262			begin
263			SetParameters(SQLParams,params);
264			Result := Execute;
265			end;
266			end;
267
268			function TFBAttachment.OpenCursor(transaction: ITransaction; sql: string;
269			aSQLDialect: integer): IResultSet;
270			begin
271			Result := OpenCursor(transaction,sql,aSQLDialect,[]);
272			end;
273
274			function TFBAttachment.OpenCursor(transaction: ITransaction; sql: string;
275			aSQLDialect: integer; params: array of const): IResultSet;
276			var Statement: IStatement;
277			begin
278			CheckHandle;
279			Statement := Prepare(transaction,sql,aSQLDialect);
280			SetParameters(Statement.SQLParams,params);
281			Result := Statement.OpenCursor;
282			end;
283
284			function TFBAttachment.OpenCursor(transaction: ITransaction; sql: string
285			): IResultSet;
286			begin
287			Result := OpenCursor(transaction,sql,FSQLDialect,[]);
288			end;
289
290			function TFBAttachment.OpenCursor(transaction: ITransaction; sql: string;
291			params: array of const): IResultSet;
292			begin
293			Result := OpenCursor(transaction,sql,FSQLDialect,params);
294			end;
295
296			function TFBAttachment.OpenCursorAtStart(transaction: ITransaction;
297			sql: string; aSQLDialect: integer): IResultSet;
298			begin
299			Result := OpenCursor(transaction,sql,aSQLDialect,[]);
300			Result.FetchNext;
301			end;
302
303			function TFBAttachment.OpenCursorAtStart(transaction: ITransaction;
304			sql: string; aSQLDialect: integer; params: array of const): IResultSet;
305			begin
306			Result := OpenCursor(transaction,sql,aSQLDialect,params);
307			Result.FetchNext;
308			end;
309
310			function TFBAttachment.OpenCursorAtStart(transaction: ITransaction; sql: string
311			): IResultSet;
312			begin
313			Result := OpenCursorAtStart(transaction,sql,FSQLDialect,[]);
314			end;
315
316			function TFBAttachment.OpenCursorAtStart(transaction: ITransaction;
317			sql: string; params: array of const): IResultSet;
318			begin
319			Result := OpenCursorAtStart(transaction,sql,FSQLDialect,params);
320			end;
321
322			function TFBAttachment.OpenCursorAtStart(sql: string): IResultSet;
323			begin
324			Result := OpenCursorAtStart(sql,[]);
325			end;
326
327			function TFBAttachment.OpenCursorAtStart(sql: string;
328			params: array of const): IResultSet;
329			begin
330			Result := OpenCursorAtStart(StartTransaction([isc_tpb_read,isc_tpb_wait,isc_tpb_concurrency],taCommit),sql,FSQLDialect,params);
331			end;
332
333			function TFBAttachment.Prepare(transaction: ITransaction; sql: string
334			): IStatement;
335			begin
336			Result := Prepare(transaction,sql,FSQLDialect);
337			end;
338
339			function TFBAttachment.PrepareWithNamedParameters(transaction: ITransaction;
340			sql: string; GenerateParamNames: boolean): IStatement;
341			begin
342			Result := PrepareWithNamedParameters(transaction,sql,FSQLDialect,GenerateParamNames);
343			end;
344
345			function TFBAttachment.GetEventHandler(Event: string): IEvents;
346			var S: TStringList;
347			begin
348			S := TStringList.Create;
349			try
350			S.Add(Event);
351			Result := GetEventHandler(S);
352			finally
353			S.Free;
354			end;
355			end;
356
357			function TFBAttachment.GetSQLDialect: integer;
358			begin
359			Result := FSQLDialect;
360			end;
361
362			function TFBAttachment.OpenBlob(transaction: ITransaction; Field: ISQLData;
363			BPB: IBPB): IBlob;
364			begin
365			Result := OpenBlob(Transaction,Field.GetBlobMetadata, Field.AsQuad,BPB);
366			end;
367
368			end.
369