trunk/runtime/IBQuery.pas

{************************************************************************}
{                                                                        }
{       Borland Delphi Visual Component Library                          }
{       InterBase Express core components                                }
{                                                                        }
{       Copyright (c) 1998-2000 Inprise Corporation                      }
{                                                                        }
{    InterBase Express is based in part on the product                   }
{    Free IB Components, written by Gregory H. Deatz for                 }
{    Hoagland, Longo, Moran, Dunst & Doukas Company.                     }
{    Free IB Components is used under license.                           }
{                                                                        }
{    The contents of this file are subject to the InterBase              }
{    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 at http://www.Inprise.com/IPL.html }
{    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 Original Code was created by InterBase Software Corporation     }
{       and its successors.                                              }
{    Portions created by Inprise Corporation are Copyright (C) Inprise   }
{       Corporation. All Rights Reserved.                                }
{    Contributor(s): Jeff Overcash                                       }
{                                                                        }
{    IBX For Lazarus (Firebird Express)                                  }
{    Contributor: Tony Whyman, MWA Software http://www.mwasoftware.co.uk }
{    Portions created by MWA Software are copyright McCallum Whyman      }
{    Associates Ltd 2011                                                 }
{                                                                        }
{************************************************************************}

unit IBQuery;

interface

{$Mode Delphi}

uses
{$IFDEF WINDOWS }
  Windows,
{$ELSE}
  unix,
{$ENDIF}
 SysUtils, Graphics, Classes, Controls, Db,
     IBHeader, IB, IBCustomDataSet, IBSQL;

type

{ TIBQuery }

  TIBQuery = class(TIBCustomDataSet)
  private
    FSQL: TStrings;
    FPrepared: Boolean;
    FParams: TParams;
    FText: string;
    FRowsAffected: Integer;
    FCheckRowsAffected: Boolean;
    FGenerateParamNames: Boolean;
    function GetRowsAffected: Integer;
    procedure PrepareSQL(Value: PChar);
    procedure QueryChanged(Sender: TObject);
    procedure ReadParamData(Reader: TReader);
    procedure SetQuery(Value: TStrings);
    procedure SetParamsList(Value: TParams);
    procedure SetParams;
    procedure SetParamsFromCursor;
    procedure SetPrepared(Value: Boolean);
    procedure SetPrepare(Value: Boolean);
    procedure WriteParamData(Writer: TWriter);
    function GetStmtHandle: TISC_STMT_HANDLE;

  protected
    { IProviderSupport }
(*    procedure PSExecute; override;
    function PSGetParams: TParams; override;
    function PSGetTableName: string; override;
    procedure PSSetCommandText(const CommandText: string); override;
    procedure PSSetParams(AParams: TParams); override;  *)

    procedure DefineProperties(Filer: TFiler); override;
    procedure InitFieldDefs; override;
    procedure InternalOpen; override;
    procedure Disconnect; override;
    function GetParamsCount: Word;
    function GenerateQueryForLiveUpdate : Boolean;
    procedure SetFiltered(Value: Boolean); override;

  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    procedure BatchInput(InputObject: TIBBatchInput);
    procedure BatchOutput(OutputObject: TIBBatchOutput);
    procedure ExecSQL;
    procedure GetDetailLinkFields(MasterFields, DetailFields: TList);(* override;*)
    function ParamByName(const Value: string): TParam;
    procedure Prepare;
    procedure UnPrepare;
    property Prepared: Boolean read FPrepared write SetPrepare;
    property ParamCount: Word read GetParamsCount;
    property StmtHandle: TISC_STMT_HANDLE read GetStmtHandle;
    property StatementType;
    property Text: string read FText;
    property RowsAffected: Integer read GetRowsAffected;
    property GenerateParamNames: Boolean read FGenerateParamNames write FGenerateParamNames;
 //   property Params: TParams read FParams write SetParamsList;

  published
    property Active;
    property BufferChunks;
    property CachedUpdates;
    property DataSource read GetDataSource write SetDataSource;
 //   property Constraints stored ConstraintsStored;
    property GeneratorField;
    property ParamCheck;
    property SQL: TStrings read FSQL write SetQuery;
   property Params: TParams read FParams write SetParamsList;
    property UniDirectional default False;
    property UpdateObject;
    property Filtered;

    property BeforeDatabaseDisconnect;
    property AfterDatabaseDisconnect;
    property DatabaseFree;
    property BeforeTransactionEnd;
    property AfterTransactionEnd;
    property TransactionFree;
    property OnFilterRecord;
end;

implementation

{ TIBQuery }

constructor TIBQuery.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FSQL := TStringList.Create;
  TStringList(SQL).OnChange := QueryChanged;
  FParams := TParams.Create(Self);
  ParamCheck := True;
  FGenerateParamNames := False;
  FRowsAffected := -1;
end;

destructor TIBQuery.Destroy;
begin
  Destroying;
  Disconnect;
  SQL.Free;
  FParams.Free;
  inherited Destroy;
end;

procedure TIBQuery.InitFieldDefs;
begin
  inherited InitFieldDefs;
end;

procedure TIBQuery.InternalOpen;
begin
  ActivateConnection();
  ActivateTransaction;
  QSelect.GenerateParamNames := FGenerateParamNames;
  SetPrepared(True);
  if DataSource <> nil then
    SetParamsFromCursor;
  SetParams;
  inherited InternalOpen;
end;

procedure TIBQuery.Disconnect;
begin
  Close;
  UnPrepare;
end;

procedure TIBQuery.SetPrepare(Value: Boolean);
begin
  if Value then
    Prepare
  else
    UnPrepare;
end;

procedure TIBQuery.Prepare;
begin
  SetPrepared(True);
end;

procedure TIBQuery.UnPrepare;
begin
  SetPrepared(False);
end;

procedure TIBQuery.SetQuery(Value: TStrings);
begin
  if SQL.Text <> Value.Text then
  begin
    Disconnect;
    SQL.BeginUpdate;
    try
      SQL.Assign(Value);
    finally
      SQL.EndUpdate;
    end;
  end;
end;

procedure TIBQuery.QueryChanged(Sender: TObject);
var
  List: TParams;
begin
  if not (csReading in ComponentState) then
  begin
    Disconnect;
    if ParamCheck or (csDesigning in ComponentState) then
    begin
      List := TParams.Create(Self);
      try
        FText := List.ParseSQL(SQL.Text, True);
        List.AssignValues(FParams);
        FParams.Clear;
        FParams.Assign(List);
      finally
        List.Free;
      end;
    end else
      FText := SQL.Text;
    DataEvent(dePropertyChange, 0);
  end else
    FText := FParams.ParseSQL(SQL.Text, true);
  SelectSQL.Assign(SQL);
end;

procedure TIBQuery.SetParamsList(Value: TParams);
begin
  FParams.AssignValues(Value);
end;

function TIBQuery.GetParamsCount: Word;
begin
  Result := FParams.Count;
end;

procedure TIBQuery.DefineProperties(Filer: TFiler);

  function WriteData: Boolean;
  begin
  {The following results in a stream read error with nested frames. Hence commented out until
   someone fixes the LCL }
{    if Filer.Ancestor <> nil then
      Result := not FParams.IsEqual(TIBQuery(Filer.Ancestor).FParams) else}
      Result := FParams.Count > 0;
  end;

begin
  inherited DefineProperties(Filer);
  Filer.DefineProperty('ParamData', ReadParamData, WriteParamData, WriteData); {do not localize}
end;

procedure TIBQuery.ReadParamData(Reader: TReader);
begin
  FParams.Clear;
  Reader.ReadValue;
  Reader.ReadCollection(FParams);
end;

procedure TIBQuery.WriteParamData(Writer: TWriter);
begin
  Writer.WriteCollection(Params);
end;

procedure TIBQuery.SetPrepared(Value: Boolean);
begin
  CheckDatasetClosed;
  if Value <> Prepared then
  begin
    if Value then
    begin
      FRowsAffected := -1;
      FCheckRowsAffected := True;
      if Length(Text) > 1 then PrepareSQL(PChar(Text))
      else IBError(ibxeEmptySQLStatement, [nil]);
    end
    else
    begin
      if FCheckRowsAffected then
        FRowsAffected := RowsAffected;
      InternalUnPrepare;
    end;
    FPrepared := Value;
  end;
end;

procedure TIBQuery.SetParamsFromCursor;
var
  I: Integer;
  DataSet: TDataSet;
  Field: TField;

  procedure CheckRequiredParams;
  var
    I: Integer;
  begin
    for I := 0 to FParams.Count - 1 do
    with FParams[I] do
      if not Bound then
        IBError(ibxeRequiredParamNotSet, [nil]);
  end;

begin
  if DataSource <> nil then
  begin
    DataSet := DataSource.DataSet;
    if DataSet <> nil then
    begin
      DataSet.FieldDefs.Update;
      for I := 0 to FParams.Count - 1 do
      if not FParams[I].Bound then
      begin
        Field := DataSet.FindField(FParams[I].Name);
        if assigned(Field) then
        begin
            FParams[I].AssignField(Field);
            FParams[I].Bound := False;
        end;
      end;
    end
    else
      CheckRequiredParams;
  end
  else
    CheckRequiredParams;
end;


function TIBQuery.ParamByName(const Value: string): TParam;
begin
  Result := FParams.ParamByName(Value);
end;

procedure TIBQuery.BatchInput(InputObject: TIBBatchInput);
begin
  InternalBatchInput(InputObject);
end;

procedure TIBQuery.BatchOutput(OutputObject: TIBBatchOutput);
begin
  InternalBatchOutput(OutputObject);
end;

procedure TIBQuery.ExecSQL;
var
  DidActivate: Boolean;
begin
  CheckInActive;
  if SQL.Count <= 0 then
  begin
    FCheckRowsAffected := False;
    IBError(ibxeEmptySQLStatement, [nil]);
  end;
  ActivateConnection();
  DidActivate := ActivateTransaction;
  try
    SetPrepared(True);
    if DataSource <> nil then SetParamsFromCursor;
    if FParams.Count > 0 then SetParams;
    InternalExecQuery;
  finally
    if DidActivate then
      DeactivateTransaction;
    FCheckRowsAffected := True;
  end;
end;

procedure TIBQuery.SetParams;

var
i : integer;
Buffer: Pointer;

begin
  for I := 0 to FParams.Count - 1 do
  begin
    if Params[i].IsNull then
      SQLParams[i].IsNull := True
    else begin
      SQLParams[i].IsNull := False;
      case Params[i].DataType of
        ftBytes:
        begin
          GetMem(Buffer,Params[i].GetDataSize);
          try
            Params[i].GetData(Buffer);
            SQLParams[i].AsPointer := Buffer;
          finally
            FreeMem(Buffer);
          end;
        end;
        ftString:
          SQLParams[i].AsString := Params[i].AsString;
        ftBoolean, ftSmallint, ftWord:
          SQLParams[i].AsShort := Params[i].AsSmallInt;
        ftInteger:
          SQLParams[i].AsLong := Params[i].AsInteger;
{        ftLargeInt:
          SQLParams[i].AsInt64 := Params[i].AsLargeInt;  }
        ftFloat:
         SQLParams[i].AsDouble := Params[i].AsFloat;
        ftBCD, ftCurrency:
          SQLParams[i].AsCurrency := Params[i].AsCurrency;
        ftDate:
          SQLParams[i].AsDate := Params[i].AsDateTime;
        ftTime:
          SQLParams[i].AsTime := Params[i].AsDateTime;
        ftDateTime:
          SQLParams[i].AsDateTime := Params[i].AsDateTime;
        ftBlob, ftMemo:
          SQLParams[i].AsString := Params[i].AsString;
        else
          IBError(ibxeNotSupported, [nil]);
      end;
    end;
  end;
end;

procedure TIBQuery.PrepareSQL(Value: PChar);
begin
  QSelect.GenerateParamNames := FGenerateParamNames;
  InternalPrepare;
end;


function TIBQuery.GetRowsAffected: Integer;
begin
  Result := -1;
  if Prepared then
   Result := QSelect.RowsAffected
end;


procedure TIBQuery.GetDetailLinkFields(MasterFields, DetailFields: TList);

  function AddFieldToList(const FieldName: string; DataSet: TDataSet;
    List: TList): Boolean;
  var
    Field: TField;
  begin
    Field := DataSet.FindField(FieldName);
    if (Field <> nil) then
      List.Add(Field);
    Result := Field <> nil;
  end;

var
  i: Integer;
begin
  MasterFields.Clear;
  DetailFields.Clear;
  if (DataSource <> nil) and (DataSource.DataSet <> nil) then
    for i := 0 to Params.Count - 1 do
      if AddFieldToList(Params[i].Name, DataSource.DataSet, MasterFields) then
        AddFieldToList(Params[i].Name, Self, DetailFields);
end;

function TIBQuery.GetStmtHandle: TISC_STMT_HANDLE;
begin
  Result := SelectStmtHandle;
end;

function TIBQuery.GenerateQueryForLiveUpdate : Boolean;
begin
  Result := False;
end;

procedure TIBQuery.SetFiltered(Value: Boolean);
begin
  if(Filtered <> Value) then
  begin
    inherited SetFiltered(value);
    if Active then
    begin
      Close;
      Open;
    end;
  end
  else
    inherited SetFiltered(value);
end;

{ TIBQuery IProviderSupport }
 (*
function TIBQuery.PSGetParams: TParams;
begin
  Result := Params;
end;

procedure TIBQuery.PSSetParams(AParams: TParams);
begin
  if AParams.Count <> 0 then
    Params.Assign(AParams);
  Close;
end;

function TIBQuery.PSGetTableName: string;
begin
  Result := inherited PSGetTableName;
end;

procedure TIBQuery.PSExecute;
begin
  ExecSQL;
end;

procedure TIBQuery.PSSetCommandText(const CommandText: string);
begin
  if CommandText <> '' then
    SQL.Text := CommandText;
end;
 *)
end.

Revision:	17
Committed:	Sat Dec 28 19:22:24 2013 UTC (10 years, 11 months ago) by tony
Content type:	text/x-pascal
File size:	14212 byte(s)
Log Message:	Committing updates for Release R1-0-5
#	Content
1	{************************************************************************}
2	{ }
3	{ Borland Delphi Visual Component Library }
4	{ InterBase Express core components }
5	{ }
6	{ Copyright (c) 1998-2000 Inprise Corporation }
7	{ }
8	{ InterBase Express is based in part on the product }
9	{ Free IB Components, written by Gregory H. Deatz for }
10	{ Hoagland, Longo, Moran, Dunst & Doukas Company. }
11	{ Free IB Components is used under license. }
12	{ }
13	{ The contents of this file are subject to the InterBase }
14	{ Public License Version 1.0 (the "License"); you may not }
15	{ use this file except in compliance with the License. You }
16	{ may obtain a copy of the License at http://www.Inprise.com/IPL.html }
17	{ Software distributed under the License is distributed on }
18	{ an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either }
19	{ express or implied. See the License for the specific language }
20	{ governing rights and limitations under the License. }
21	{ The Original Code was created by InterBase Software Corporation }
22	{ and its successors. }
23	{ Portions created by Inprise Corporation are Copyright (C) Inprise }
24	{ Corporation. All Rights Reserved. }
25	{ Contributor(s): Jeff Overcash }
26	{ }
27	{ IBX For Lazarus (Firebird Express) }
28	{ Contributor: Tony Whyman, MWA Software http://www.mwasoftware.co.uk }
29	{ Portions created by MWA Software are copyright McCallum Whyman }
30	{ Associates Ltd 2011 }
31	{ }
32	{************************************************************************}
33
34	unit IBQuery;
35
36	interface
37
38	{$Mode Delphi}
39
40	uses
41	{$IFDEF WINDOWS }
42	Windows,
43	{$ELSE}
44	unix,
45	{$ENDIF}
46	SysUtils, Graphics, Classes, Controls, Db,
47	IBHeader, IB, IBCustomDataSet, IBSQL;
48
49	type
50
51	{ TIBQuery }
52
53	TIBQuery = class(TIBCustomDataSet)
54	private
55	FSQL: TStrings;
56	FPrepared: Boolean;
57	FParams: TParams;
58	FText: string;
59	FRowsAffected: Integer;
60	FCheckRowsAffected: Boolean;
61	FGenerateParamNames: Boolean;
62	function GetRowsAffected: Integer;
63	procedure PrepareSQL(Value: PChar);
64	procedure QueryChanged(Sender: TObject);
65	procedure ReadParamData(Reader: TReader);
66	procedure SetQuery(Value: TStrings);
67	procedure SetParamsList(Value: TParams);
68	procedure SetParams;
69	procedure SetParamsFromCursor;
70	procedure SetPrepared(Value: Boolean);
71	procedure SetPrepare(Value: Boolean);
72	procedure WriteParamData(Writer: TWriter);
73	function GetStmtHandle: TISC_STMT_HANDLE;
74
75	protected
76	{ IProviderSupport }
77	(* procedure PSExecute; override;
78	function PSGetParams: TParams; override;
79	function PSGetTableName: string; override;
80	procedure PSSetCommandText(const CommandText: string); override;
81	procedure PSSetParams(AParams: TParams); override; *)
82
83	procedure DefineProperties(Filer: TFiler); override;
84	procedure InitFieldDefs; override;
85	procedure InternalOpen; override;
86	procedure Disconnect; override;
87	function GetParamsCount: Word;
88	function GenerateQueryForLiveUpdate : Boolean;
89	procedure SetFiltered(Value: Boolean); override;
90
91	public
92	constructor Create(AOwner: TComponent); override;
93	destructor Destroy; override;
94	procedure BatchInput(InputObject: TIBBatchInput);
95	procedure BatchOutput(OutputObject: TIBBatchOutput);
96	procedure ExecSQL;
97	procedure GetDetailLinkFields(MasterFields, DetailFields: TList);(* override;*)
98	function ParamByName(const Value: string): TParam;
99	procedure Prepare;
100	procedure UnPrepare;
101	property Prepared: Boolean read FPrepared write SetPrepare;
102	property ParamCount: Word read GetParamsCount;
103	property StmtHandle: TISC_STMT_HANDLE read GetStmtHandle;
104	property StatementType;
105	property Text: string read FText;
106	property RowsAffected: Integer read GetRowsAffected;
107	property GenerateParamNames: Boolean read FGenerateParamNames write FGenerateParamNames;
108	// property Params: TParams read FParams write SetParamsList;
109
110	published
111	property Active;
112	property BufferChunks;
113	property CachedUpdates;
114	property DataSource read GetDataSource write SetDataSource;
115	// property Constraints stored ConstraintsStored;
116	property GeneratorField;
117	property ParamCheck;
118	property SQL: TStrings read FSQL write SetQuery;
119	property Params: TParams read FParams write SetParamsList;
120	property UniDirectional default False;
121	property UpdateObject;
122	property Filtered;
123
124	property BeforeDatabaseDisconnect;
125	property AfterDatabaseDisconnect;
126	property DatabaseFree;
127	property BeforeTransactionEnd;
128	property AfterTransactionEnd;
129	property TransactionFree;
130	property OnFilterRecord;
131	end;
132
133	implementation
134
135	{ TIBQuery }
136
137	constructor TIBQuery.Create(AOwner: TComponent);
138	begin
139	inherited Create(AOwner);
140	FSQL := TStringList.Create;
141	TStringList(SQL).OnChange := QueryChanged;
142	FParams := TParams.Create(Self);
143	ParamCheck := True;
144	FGenerateParamNames := False;
145	FRowsAffected := -1;
146	end;
147
148	destructor TIBQuery.Destroy;
149	begin
150	Destroying;
151	Disconnect;
152	SQL.Free;
153	FParams.Free;
154	inherited Destroy;
155	end;
156
157	procedure TIBQuery.InitFieldDefs;
158	begin
159	inherited InitFieldDefs;
160	end;
161
162	procedure TIBQuery.InternalOpen;
163	begin
164	ActivateConnection();
165	ActivateTransaction;
166	QSelect.GenerateParamNames := FGenerateParamNames;
167	SetPrepared(True);
168	if DataSource <> nil then
169	SetParamsFromCursor;
170	SetParams;
171	inherited InternalOpen;
172	end;
173
174	procedure TIBQuery.Disconnect;
175	begin
176	Close;
177	UnPrepare;
178	end;
179
180	procedure TIBQuery.SetPrepare(Value: Boolean);
181	begin
182	if Value then
183	Prepare
184	else
185	UnPrepare;
186	end;
187
188	procedure TIBQuery.Prepare;
189	begin
190	SetPrepared(True);
191	end;
192
193	procedure TIBQuery.UnPrepare;
194	begin
195	SetPrepared(False);
196	end;
197
198	procedure TIBQuery.SetQuery(Value: TStrings);
199	begin
200	if SQL.Text <> Value.Text then
201	begin
202	Disconnect;
203	SQL.BeginUpdate;
204	try
205	SQL.Assign(Value);
206	finally
207	SQL.EndUpdate;
208	end;
209	end;
210	end;
211
212	procedure TIBQuery.QueryChanged(Sender: TObject);
213	var
214	List: TParams;
215	begin
216	if not (csReading in ComponentState) then
217	begin
218	Disconnect;
219	if ParamCheck or (csDesigning in ComponentState) then
220	begin
221	List := TParams.Create(Self);
222	try
223	FText := List.ParseSQL(SQL.Text, True);
224	List.AssignValues(FParams);
225	FParams.Clear;
226	FParams.Assign(List);
227	finally
228	List.Free;
229	end;
230	end else
231	FText := SQL.Text;
232	DataEvent(dePropertyChange, 0);
233	end else
234	FText := FParams.ParseSQL(SQL.Text, true);
235	SelectSQL.Assign(SQL);
236	end;
237
238	procedure TIBQuery.SetParamsList(Value: TParams);
239	begin
240	FParams.AssignValues(Value);
241	end;
242
243	function TIBQuery.GetParamsCount: Word;
244	begin
245	Result := FParams.Count;
246	end;
247
248	procedure TIBQuery.DefineProperties(Filer: TFiler);
249
250	function WriteData: Boolean;
251	begin
252	{The following results in a stream read error with nested frames. Hence commented out until
253	someone fixes the LCL }
254	{ if Filer.Ancestor <> nil then
255	Result := not FParams.IsEqual(TIBQuery(Filer.Ancestor).FParams) else}
256	Result := FParams.Count > 0;
257	end;
258
259	begin
260	inherited DefineProperties(Filer);
261	Filer.DefineProperty('ParamData', ReadParamData, WriteParamData, WriteData); {do not localize}
262	end;
263
264	procedure TIBQuery.ReadParamData(Reader: TReader);
265	begin
266	FParams.Clear;
267	Reader.ReadValue;
268	Reader.ReadCollection(FParams);
269	end;
270
271	procedure TIBQuery.WriteParamData(Writer: TWriter);
272	begin
273	Writer.WriteCollection(Params);
274	end;
275
276	procedure TIBQuery.SetPrepared(Value: Boolean);
277	begin
278	CheckDatasetClosed;
279	if Value <> Prepared then
280	begin
281	if Value then
282	begin
283	FRowsAffected := -1;
284	FCheckRowsAffected := True;
285	if Length(Text) > 1 then PrepareSQL(PChar(Text))
286	else IBError(ibxeEmptySQLStatement, [nil]);
287	end
288	else
289	begin
290	if FCheckRowsAffected then
291	FRowsAffected := RowsAffected;
292	InternalUnPrepare;
293	end;
294	FPrepared := Value;
295	end;
296	end;
297
298	procedure TIBQuery.SetParamsFromCursor;
299	var
300	I: Integer;
301	DataSet: TDataSet;
302	Field: TField;
303
304	procedure CheckRequiredParams;
305	var
306	I: Integer;
307	begin
308	for I := 0 to FParams.Count - 1 do
309	with FParams[I] do
310	if not Bound then
311	IBError(ibxeRequiredParamNotSet, [nil]);
312	end;
313
314	begin
315	if DataSource <> nil then
316	begin
317	DataSet := DataSource.DataSet;
318	if DataSet <> nil then
319	begin
320	DataSet.FieldDefs.Update;
321	for I := 0 to FParams.Count - 1 do
322	if not FParams[I].Bound then
323	begin
324	Field := DataSet.FindField(FParams[I].Name);
325	if assigned(Field) then
326	begin
327	FParams[I].AssignField(Field);
328	FParams[I].Bound := False;
329	end;
330	end;
331	end
332	else
333	CheckRequiredParams;
334	end
335	else
336	CheckRequiredParams;
337	end;
338
339
340	function TIBQuery.ParamByName(const Value: string): TParam;
341	begin
342	Result := FParams.ParamByName(Value);
343	end;
344
345	procedure TIBQuery.BatchInput(InputObject: TIBBatchInput);
346	begin
347	InternalBatchInput(InputObject);
348	end;
349
350	procedure TIBQuery.BatchOutput(OutputObject: TIBBatchOutput);
351	begin
352	InternalBatchOutput(OutputObject);
353	end;
354
355	procedure TIBQuery.ExecSQL;
356	var
357	DidActivate: Boolean;
358	begin
359	CheckInActive;
360	if SQL.Count <= 0 then
361	begin
362	FCheckRowsAffected := False;
363	IBError(ibxeEmptySQLStatement, [nil]);
364	end;
365	ActivateConnection();
366	DidActivate := ActivateTransaction;
367	try
368	SetPrepared(True);
369	if DataSource <> nil then SetParamsFromCursor;
370	if FParams.Count > 0 then SetParams;
371	InternalExecQuery;
372	finally
373	if DidActivate then
374	DeactivateTransaction;
375	FCheckRowsAffected := True;
376	end;
377	end;
378
379	procedure TIBQuery.SetParams;
380
381	var
382	i : integer;
383	Buffer: Pointer;
384
385	begin
386	for I := 0 to FParams.Count - 1 do
387	begin
388	if Params[i].IsNull then
389	SQLParams[i].IsNull := True
390	else begin
391	SQLParams[i].IsNull := False;
392	case Params[i].DataType of
393	ftBytes:
394	begin
395	GetMem(Buffer,Params[i].GetDataSize);
396	try
397	Params[i].GetData(Buffer);
398	SQLParams[i].AsPointer := Buffer;
399	finally
400	FreeMem(Buffer);
401	end;
402	end;
403	ftString:
404	SQLParams[i].AsString := Params[i].AsString;
405	ftBoolean, ftSmallint, ftWord:
406	SQLParams[i].AsShort := Params[i].AsSmallInt;
407	ftInteger:
408	SQLParams[i].AsLong := Params[i].AsInteger;
409	{ ftLargeInt:
410	SQLParams[i].AsInt64 := Params[i].AsLargeInt; }
411	ftFloat:
412	SQLParams[i].AsDouble := Params[i].AsFloat;
413	ftBCD, ftCurrency:
414	SQLParams[i].AsCurrency := Params[i].AsCurrency;
415	ftDate:
416	SQLParams[i].AsDate := Params[i].AsDateTime;
417	ftTime:
418	SQLParams[i].AsTime := Params[i].AsDateTime;
419	ftDateTime:
420	SQLParams[i].AsDateTime := Params[i].AsDateTime;
421	ftBlob, ftMemo:
422	SQLParams[i].AsString := Params[i].AsString;
423	else
424	IBError(ibxeNotSupported, [nil]);
425	end;
426	end;
427	end;
428	end;
429
430	procedure TIBQuery.PrepareSQL(Value: PChar);
431	begin
432	QSelect.GenerateParamNames := FGenerateParamNames;
433	InternalPrepare;
434	end;
435
436
437	function TIBQuery.GetRowsAffected: Integer;
438	begin
439	Result := -1;
440	if Prepared then
441	Result := QSelect.RowsAffected
442	end;
443
444
445	procedure TIBQuery.GetDetailLinkFields(MasterFields, DetailFields: TList);
446
447	function AddFieldToList(const FieldName: string; DataSet: TDataSet;
448	List: TList): Boolean;
449	var
450	Field: TField;
451	begin
452	Field := DataSet.FindField(FieldName);
453	if (Field <> nil) then
454	List.Add(Field);
455	Result := Field <> nil;
456	end;
457
458	var
459	i: Integer;
460	begin
461	MasterFields.Clear;
462	DetailFields.Clear;
463	if (DataSource <> nil) and (DataSource.DataSet <> nil) then
464	for i := 0 to Params.Count - 1 do
465	if AddFieldToList(Params[i].Name, DataSource.DataSet, MasterFields) then
466	AddFieldToList(Params[i].Name, Self, DetailFields);
467	end;
468
469	function TIBQuery.GetStmtHandle: TISC_STMT_HANDLE;
470	begin
471	Result := SelectStmtHandle;
472	end;
473
474	function TIBQuery.GenerateQueryForLiveUpdate : Boolean;
475	begin
476	Result := False;
477	end;
478
479	procedure TIBQuery.SetFiltered(Value: Boolean);
480	begin
481	if(Filtered <> Value) then
482	begin
483	inherited SetFiltered(value);
484	if Active then
485	begin
486	Close;
487	Open;
488	end;
489	end
490	else
491	inherited SetFiltered(value);
492	end;
493
494	{ TIBQuery IProviderSupport }
495	(*
496	function TIBQuery.PSGetParams: TParams;
497	begin
498	Result := Params;
499	end;
500
501	procedure TIBQuery.PSSetParams(AParams: TParams);
502	begin
503	if AParams.Count <> 0 then
504	Params.Assign(AParams);
505	Close;
506	end;
507
508	function TIBQuery.PSGetTableName: string;
509	begin
510	Result := inherited PSGetTableName;
511	end;
512
513	procedure TIBQuery.PSExecute;
514	begin
515	ExecSQL;
516	end;
517
518	procedure TIBQuery.PSSetCommandText(const CommandText: string);
519	begin
520	if CommandText <> '' then
521	SQL.Text := CommandText;
522	end;
523	*)
524	end.
525