trunk/runtime/IBUpdate.pas

(*
 *  IBX For Lazarus (Firebird Express)
 *
 *  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) 2015 Tony Whyman, MWA Software
 *  (http://www.mwasoftware.co.uk).
 *
 *  All Rights Reserved.
 *
 *  Contributor(s): ______________________________________.
 *
*) 
            
unit IBUpdate;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, IBCustomDataSet, DB, IB, IBDatabase, IBExternals, FBMessages;

type

  TOnApplyUpdates = procedure(Sender: TObject; UpdateKind: TUpdateKind; Params: ISQLParams) of object;

  { TIBUpdate}

  TIBUpdate = class(TIBDataSetUpdateObject)
  private
    FDataSet: TIBCustomDataSet;
    FDummySQL: TStrings;
    FOnApplyUpdates: TOnApplyUpdates;
  protected
    function GetSQL(UpdateKind: TUpdateKind): TStrings; override;
    function GetDataSet: TIBCustomDataSet; override;
    procedure SetDataSet(ADataSet: TIBCustomDataSet); override;
    procedure Apply(UpdateKind: TUpdateKind; buff: PChar); override;
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    property DataSet;
  published
    property OnApplyUpdates: TOnApplyUpdates read FOnApplyUpdates write FOnApplyUpdates;
 end;


implementation

uses variants;

type

  { TParamListIntf }

  TParamListIntf = class(TInterfacedObject,ISQLParams)
  private
    type TParamRec = record
      Name: string;
      Value: variant;
      Modified: boolean;
    end;
  private
    FDatabase: TIBDatabase;
    FModified: boolean;
    FParams: array of TParamRec;
    procedure SetParam(index: integer; aValue: variant);
  public
    constructor Create(aFields: TFields; aDatabase: TIBDatabase);
    destructor Destroy; override;
    property Database: TIBDatabase read FDatabase;
  public
    {ISQLParams}
    function getCount: integer;
    function getSQLParam(index: integer): ISQLParam;
    function ByName(Idx: AnsiString): ISQLParam ;
    function GetModified: Boolean;
  end;

  { TParamIntf }

  TParamIntf = class(TInterfacedObject,ISQLParam)
  private
    FIndex: integer;
    FOwner: TParamListIntf;
  public
    constructor Create(aOwner: TParamListIntf; aIndex: integer);
    function GetIndex: integer;
    function GetSQLType: cardinal;
    function GetSQLTypeName: AnsiString;
    function getSubtype: integer;
    function getName: AnsiString;
    function getScale: integer;
    function getCharSetID: cardinal;
    function getCodePage: TSystemCodePage;
    function getIsNullable: boolean;
    function GetSize: cardinal;
    function GetAsBoolean: boolean;
    function GetAsCurrency: Currency;
    function GetAsInt64: Int64;
    function GetAsDateTime: TDateTime;
    function GetAsDouble: Double;
    function GetAsFloat: Float;
    function GetAsLong: Long;
    function GetAsPointer: Pointer;
    function GetAsQuad: TISC_QUAD;
    function GetAsShort: short;
    function GetAsString: AnsiString;
    function GetIsNull: boolean;
    function GetAsVariant: Variant;
    function GetAsBlob: IBlob;
    function GetAsArray: IArray;
    procedure Clear;
    function GetModified: boolean;
    procedure SetAsBoolean(AValue: boolean);
    procedure SetAsCurrency(aValue: Currency);
    procedure SetAsInt64(aValue: Int64);
    procedure SetAsDate(aValue: TDateTime);
    procedure SetAsLong(aValue: Long);
    procedure SetAsTime(aValue: TDateTime);
    procedure SetAsDateTime(aValue: TDateTime);
    procedure SetAsDouble(aValue: Double);
    procedure SetAsFloat(aValue: Float);
    procedure SetAsPointer(aValue: Pointer);
    procedure SetAsShort(aValue: Short);
    procedure SetAsString(aValue: AnsiString);
    procedure SetAsVariant(aValue: Variant);
    procedure SetIsNull(aValue: Boolean);
    procedure SetAsBlob(aValue: IBlob);
    procedure SetAsArray(anArray: IArray);
    procedure SetAsQuad(aValue: TISC_QUAD);
    procedure SetCharSetID(aValue: cardinal);
  end;

{ TParamIntf }

constructor TParamIntf.Create(aOwner: TParamListIntf; aIndex: integer);
begin
  FOwner := aOwner;
  FIndex := aIndex;
end;

function TParamIntf.GetIndex: integer;
begin
  Result := Findex;
end;

function TParamIntf.GetSQLType: cardinal;
begin
  IBError(ibxeNotSupported,[]);
end;

function TParamIntf.GetSQLTypeName: AnsiString;
begin
  IBError(ibxeNotSupported,[]);
end;

function TParamIntf.getSubtype: integer;
begin
  IBError(ibxeNotSupported,[]);
end;

function TParamIntf.getName: AnsiString;
begin
  Result := FOwner.FParams[FIndex].Name;
end;

function TParamIntf.getScale: integer;
begin
  IBError(ibxeNotSupported,[]);
end;

function TParamIntf.getCharSetID: cardinal;
var id: integer;
begin
   FOwner.Database.Attachment.CodePage2CharSetID(StringCodePage(FOwner.FParams[FIndex].Value),id);
   Result := id;
end;

function TParamIntf.getCodePage: TSystemCodePage;
begin
  Result := StringCodePage(FOwner.FParams[FIndex].Value);
end;

function TParamIntf.getIsNullable: boolean;
begin
  Result := true;
end;

function TParamIntf.GetSize: cardinal;
begin
  IBError(ibxeNotSupported,[]);
end;

function TParamIntf.GetAsBoolean: boolean;
begin
  Result := FOwner.FParams[FIndex].Value;
end;

function TParamIntf.GetAsCurrency: Currency;
begin
  Result := FOwner.FParams[FIndex].Value;
end;

function TParamIntf.GetAsInt64: Int64;
begin
  Result := FOwner.FParams[FIndex].Value;
end;

function TParamIntf.GetAsDateTime: TDateTime;
begin
  Result := FOwner.FParams[FIndex].Value;
end;

function TParamIntf.GetAsDouble: Double;
begin
  Result := FOwner.FParams[FIndex].Value;
end;

function TParamIntf.GetAsFloat: Float;
begin
  Result := FOwner.FParams[FIndex].Value;
end;

function TParamIntf.GetAsLong: Long;
begin
  Result := FOwner.FParams[FIndex].Value;
end;

function TParamIntf.GetAsPointer: Pointer;
begin
  IBError(ibxeNotSupported,[]);
end;

function TParamIntf.GetAsQuad: TISC_QUAD;
begin
  IBError(ibxeNotSupported,[]);
end;

function TParamIntf.GetAsShort: short;
begin
  Result := FOwner.FParams[FIndex].Value;
end;

function TParamIntf.GetAsString: AnsiString;
var v: variant;
begin
  v := FOwner.FParams[FIndex].Value;
  Case varType(v) of
      varEmpty,
      varNull:
          Result := '';
      varShortInt,
      varSmallint,
      varInteger,
      varInt64,
      varByte,
      varWord,
      varDecimal,
      varLongWord,
      varQWord,
      varSingle:
          Result := IntToStr(v);
      varCurrency,
      varDouble:
          Result := FloatToStr(v);
      varDate:
          Result := DateTimeToStr(v);
      varStrArg,
      varString:
          Result := v;
      varBoolean:
          if v then
            Result := 'true'
          else
            Result := 'false';
      varVariant:
          Result := v;
   else
     Result := v;
   end;
end;

function TParamIntf.GetIsNull: boolean;
begin
  Result := VarIsNull(FOwner.FParams[FIndex].Value);
end;

function TParamIntf.GetAsVariant: Variant;
begin
  Result := FOwner.FParams[FIndex].Value;
end;

function TParamIntf.GetAsBlob: IBlob;
begin
  IBError(ibxeNotSupported,[]);
end;

function TParamIntf.GetAsArray: IArray;
begin
  IBError(ibxeNotSupported,[]);
end;

procedure TParamIntf.Clear;
begin
  FOwner.SetParam(FIndex,NULL);
end;

function TParamIntf.GetModified: boolean;
begin
  Result := FOwner.FParams[FIndex].Modified;
end;

procedure TParamIntf.SetAsBoolean(AValue: boolean);
begin
  FOwner.SetParam(FIndex,AValue);
end;

procedure TParamIntf.SetAsCurrency(aValue: Currency);
begin
  FOwner.SetParam(FIndex,AValue);
end;

procedure TParamIntf.SetAsInt64(aValue: Int64);
begin
  FOwner.SetParam(FIndex,AValue);
end;

procedure TParamIntf.SetAsDate(aValue: TDateTime);
begin
  FOwner.SetParam(FIndex,AValue);
end;

procedure TParamIntf.SetAsLong(aValue: Long);
begin
  FOwner.SetParam(FIndex,AValue);
end;

procedure TParamIntf.SetAsTime(aValue: TDateTime);
begin
  FOwner.SetParam(FIndex,AValue);
end;

procedure TParamIntf.SetAsDateTime(aValue: TDateTime);
begin
  FOwner.SetParam(FIndex,AValue);
end;

procedure TParamIntf.SetAsDouble(aValue: Double);
begin
  FOwner.SetParam(FIndex,AValue);
end;

procedure TParamIntf.SetAsFloat(aValue: Float);
begin
  FOwner.SetParam(FIndex,AValue);
end;

procedure TParamIntf.SetAsPointer(aValue: Pointer);
begin
  IBError(ibxeNotSupported,[]);
end;

procedure TParamIntf.SetAsShort(aValue: Short);
begin
  FOwner.SetParam(FIndex,AValue);
end;

procedure TParamIntf.SetAsString(aValue: AnsiString);
begin
  FOwner.SetParam(FIndex,AValue);
end;

procedure TParamIntf.SetAsVariant(aValue: Variant);
begin
  FOwner.SetParam(FIndex,AValue);
end;

procedure TParamIntf.SetIsNull(aValue: Boolean);
begin
  if aValue then
    FOwner.SetParam(FIndex,NULL)
end;

procedure TParamIntf.SetAsBlob(aValue: IBlob);
begin
  IBError(ibxeNotSupported,[]);
end;

procedure TParamIntf.SetAsArray(anArray: IArray);
begin
  IBError(ibxeNotSupported,[]);
end;

procedure TParamIntf.SetAsQuad(aValue: TISC_QUAD);
begin
  IBError(ibxeNotSupported,[]);
end;

procedure TParamIntf.SetCharSetID(aValue: cardinal);
var s: RawByteString;
    codepage: TSystemCodePage;
    str: string;
begin
  str := FOwner.FParams[FIndex].Value;
  s := str;
  if FOwner.Database.Attachment.CharSetID2CodePage(aValue,codepage) then
    SetCodePage(s,codepage,codepage <> cp_none);
end;

{ TParamListIntf }

procedure TParamListIntf.SetParam(index: integer; aValue: variant);
begin
  FParams[index].Value := aValue;
  FParams[index].Modified := true;
  FModified := true;
end;

constructor TParamListIntf.Create(aFields: TFields; aDatabase: TIBDatabase);
var i,j: integer;
begin
  inherited Create;
  FDatabase := aDatabase;
  SetLength(FParams,aFields.Count*2);
  j := 0;
  {set up both current and "OLD" parameters from Field Names}
  for i := 0 to aFields.Count - 1 do
  if aFields[i].FieldKind = fkData then
  begin
    FParams[j].Name := aFields[i].FieldName;
    FParams[j].Value := NULL;
    FParams[j].Modified := false;
    Inc(j);
    FParams[j].Name := 'OLD_' + aFields[i].FieldName;
    FParams[j].Value := NULL;
    FParams[j].Modified := false;
    Inc(j);
  end;
  SetLength(FParams,j);
end;

destructor TParamListIntf.Destroy;
begin
  SetLength(FParams,0);
  inherited Destroy;
end;

function TParamListIntf.getCount: integer;
begin
  Result := Length(FParams);
end;

function TParamListIntf.getSQLParam(index: integer): ISQLParam;
begin
  if (index < 0) or (index >= getCount) then
    IBError(ibxeInvalidColumnIndex,[nil]);
  Result := TParamIntf.Create(self,index);
end;

function TParamListIntf.ByName(Idx: AnsiString): ISQLParam;
var i: integer;
begin
  Result := nil;
  for i := 0 to getCount - 1 do
    if CompareText(FParams[i].Name,Idx) = 0 then
    begin
      Result := getSQLParam(i);
      Exit;
    end;
end;

function TParamListIntf.GetModified: Boolean;
begin
  Result := FModified;
end;

{ TIBUpdate }

function TIBUpdate.GetSQL(UpdateKind: TUpdateKind): TStrings;
begin
  Result := FDummySQL; {non empty result}
end;

function TIBUpdate.GetDataSet: TIBCustomDataSet;
begin
  Result := FDataSet;
end;

procedure TIBUpdate.SetDataSet(ADataSet: TIBCustomDataSet);
begin
  FDataSet := ADataset;
end;

procedure TIBUpdate.Apply(UpdateKind: TUpdateKind; buff: PChar);
var Params: ISQLParams;
begin
  Params := TParamListIntf.Create(Dataset.Fields,(DataSet.Database as TIBDatabase));
  InternalSetParams(Params,buff);
  if assigned(FOnApplyUpdates) then
    OnApplyUpdates(self,UpdateKind,Params);
end;

constructor TIBUpdate.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FDummySQL := TStringList.Create;
  FDummySQL.Text := '*';
end;

destructor TIBUpdate.Destroy;
begin
  if assigned(FDummySQL) then FDummySQL.Free;
  inherited Destroy;
end;

end.

Revision:	158
Committed:	Thu Mar 1 11:23:33 2018 UTC (6 years, 1 month ago) by tony
Content type:	text/x-pascal
File size:	12145 byte(s)
Log Message:	Repository resync
#	Content
1	(*
2	* IBX For Lazarus (Firebird Express)
3	*
4	* The contents of this file are subject to the Initial Developer's
5	* Public License Version 1.0 (the "License"); you may not use this
6	* file except in compliance with the License. You may obtain a copy
7	* of the License here:
8	*
9	* http://www.firebirdsql.org/index.php?op=doc&id=idpl
10	*
11	* Software distributed under the License is distributed on an "AS
12	* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
13	* implied. See the License for the specific language governing rights
14	* and limitations under the License.
15	*
16	* The Initial Developer of the Original Code is Tony Whyman.
17	*
18	* The Original Code is (C) 2015 Tony Whyman, MWA Software
19	* (http://www.mwasoftware.co.uk).
20	*
21	* All Rights Reserved.
22	*
23	* Contributor(s): ______________________________________.
24	*
25	*)
26
27	unit IBUpdate;
28
29	{$mode objfpc}{$H+}
30
31	interface
32
33	uses
34	Classes, SysUtils, IBCustomDataSet, DB, IB, IBDatabase, IBExternals, FBMessages;
35
36	type
37
38	TOnApplyUpdates = procedure(Sender: TObject; UpdateKind: TUpdateKind; Params: ISQLParams) of object;
39
40	{ TIBUpdate}
41
42	TIBUpdate = class(TIBDataSetUpdateObject)
43	private
44	FDataSet: TIBCustomDataSet;
45	FDummySQL: TStrings;
46	FOnApplyUpdates: TOnApplyUpdates;
47	protected
48	function GetSQL(UpdateKind: TUpdateKind): TStrings; override;
49	function GetDataSet: TIBCustomDataSet; override;
50	procedure SetDataSet(ADataSet: TIBCustomDataSet); override;
51	procedure Apply(UpdateKind: TUpdateKind; buff: PChar); override;
52	public
53	constructor Create(AOwner: TComponent); override;
54	destructor Destroy; override;
55	property DataSet;
56	published
57	property OnApplyUpdates: TOnApplyUpdates read FOnApplyUpdates write FOnApplyUpdates;
58	end;
59
60
61	implementation
62
63	uses variants;
64
65	type
66
67	{ TParamListIntf }
68
69	TParamListIntf = class(TInterfacedObject,ISQLParams)
70	private
71	type TParamRec = record
72	Name: string;
73	Value: variant;
74	Modified: boolean;
75	end;
76	private
77	FDatabase: TIBDatabase;
78	FModified: boolean;
79	FParams: array of TParamRec;
80	procedure SetParam(index: integer; aValue: variant);
81	public
82	constructor Create(aFields: TFields; aDatabase: TIBDatabase);
83	destructor Destroy; override;
84	property Database: TIBDatabase read FDatabase;
85	public
86	{ISQLParams}
87	function getCount: integer;
88	function getSQLParam(index: integer): ISQLParam;
89	function ByName(Idx: AnsiString): ISQLParam ;
90	function GetModified: Boolean;
91	end;
92
93	{ TParamIntf }
94
95	TParamIntf = class(TInterfacedObject,ISQLParam)
96	private
97	FIndex: integer;
98	FOwner: TParamListIntf;
99	public
100	constructor Create(aOwner: TParamListIntf; aIndex: integer);
101	function GetIndex: integer;
102	function GetSQLType: cardinal;
103	function GetSQLTypeName: AnsiString;
104	function getSubtype: integer;
105	function getName: AnsiString;
106	function getScale: integer;
107	function getCharSetID: cardinal;
108	function getCodePage: TSystemCodePage;
109	function getIsNullable: boolean;
110	function GetSize: cardinal;
111	function GetAsBoolean: boolean;
112	function GetAsCurrency: Currency;
113	function GetAsInt64: Int64;
114	function GetAsDateTime: TDateTime;
115	function GetAsDouble: Double;
116	function GetAsFloat: Float;
117	function GetAsLong: Long;
118	function GetAsPointer: Pointer;
119	function GetAsQuad: TISC_QUAD;
120	function GetAsShort: short;
121	function GetAsString: AnsiString;
122	function GetIsNull: boolean;
123	function GetAsVariant: Variant;
124	function GetAsBlob: IBlob;
125	function GetAsArray: IArray;
126	procedure Clear;
127	function GetModified: boolean;
128	procedure SetAsBoolean(AValue: boolean);
129	procedure SetAsCurrency(aValue: Currency);
130	procedure SetAsInt64(aValue: Int64);
131	procedure SetAsDate(aValue: TDateTime);
132	procedure SetAsLong(aValue: Long);
133	procedure SetAsTime(aValue: TDateTime);
134	procedure SetAsDateTime(aValue: TDateTime);
135	procedure SetAsDouble(aValue: Double);
136	procedure SetAsFloat(aValue: Float);
137	procedure SetAsPointer(aValue: Pointer);
138	procedure SetAsShort(aValue: Short);
139	procedure SetAsString(aValue: AnsiString);
140	procedure SetAsVariant(aValue: Variant);
141	procedure SetIsNull(aValue: Boolean);
142	procedure SetAsBlob(aValue: IBlob);
143	procedure SetAsArray(anArray: IArray);
144	procedure SetAsQuad(aValue: TISC_QUAD);
145	procedure SetCharSetID(aValue: cardinal);
146	end;
147
148	{ TParamIntf }
149
150	constructor TParamIntf.Create(aOwner: TParamListIntf; aIndex: integer);
151	begin
152	FOwner := aOwner;
153	FIndex := aIndex;
154	end;
155
156	function TParamIntf.GetIndex: integer;
157	begin
158	Result := Findex;
159	end;
160
161	function TParamIntf.GetSQLType: cardinal;
162	begin
163	IBError(ibxeNotSupported,[]);
164	end;
165
166	function TParamIntf.GetSQLTypeName: AnsiString;
167	begin
168	IBError(ibxeNotSupported,[]);
169	end;
170
171	function TParamIntf.getSubtype: integer;
172	begin
173	IBError(ibxeNotSupported,[]);
174	end;
175
176	function TParamIntf.getName: AnsiString;
177	begin
178	Result := FOwner.FParams[FIndex].Name;
179	end;
180
181	function TParamIntf.getScale: integer;
182	begin
183	IBError(ibxeNotSupported,[]);
184	end;
185
186	function TParamIntf.getCharSetID: cardinal;
187	var id: integer;
188	begin
189	FOwner.Database.Attachment.CodePage2CharSetID(StringCodePage(FOwner.FParams[FIndex].Value),id);
190	Result := id;
191	end;
192
193	function TParamIntf.getCodePage: TSystemCodePage;
194	begin
195	Result := StringCodePage(FOwner.FParams[FIndex].Value);
196	end;
197
198	function TParamIntf.getIsNullable: boolean;
199	begin
200	Result := true;
201	end;
202
203	function TParamIntf.GetSize: cardinal;
204	begin
205	IBError(ibxeNotSupported,[]);
206	end;
207
208	function TParamIntf.GetAsBoolean: boolean;
209	begin
210	Result := FOwner.FParams[FIndex].Value;
211	end;
212
213	function TParamIntf.GetAsCurrency: Currency;
214	begin
215	Result := FOwner.FParams[FIndex].Value;
216	end;
217
218	function TParamIntf.GetAsInt64: Int64;
219	begin
220	Result := FOwner.FParams[FIndex].Value;
221	end;
222
223	function TParamIntf.GetAsDateTime: TDateTime;
224	begin
225	Result := FOwner.FParams[FIndex].Value;
226	end;
227
228	function TParamIntf.GetAsDouble: Double;
229	begin
230	Result := FOwner.FParams[FIndex].Value;
231	end;
232
233	function TParamIntf.GetAsFloat: Float;
234	begin
235	Result := FOwner.FParams[FIndex].Value;
236	end;
237
238	function TParamIntf.GetAsLong: Long;
239	begin
240	Result := FOwner.FParams[FIndex].Value;
241	end;
242
243	function TParamIntf.GetAsPointer: Pointer;
244	begin
245	IBError(ibxeNotSupported,[]);
246	end;
247
248	function TParamIntf.GetAsQuad: TISC_QUAD;
249	begin
250	IBError(ibxeNotSupported,[]);
251	end;
252
253	function TParamIntf.GetAsShort: short;
254	begin
255	Result := FOwner.FParams[FIndex].Value;
256	end;
257
258	function TParamIntf.GetAsString: AnsiString;
259	var v: variant;
260	begin
261	v := FOwner.FParams[FIndex].Value;
262	Case varType(v) of
263	varEmpty,
264	varNull:
265	Result := '';
266	varShortInt,
267	varSmallint,
268	varInteger,
269	varInt64,
270	varByte,
271	varWord,
272	varDecimal,
273	varLongWord,
274	varQWord,
275	varSingle:
276	Result := IntToStr(v);
277	varCurrency,
278	varDouble:
279	Result := FloatToStr(v);
280	varDate:
281	Result := DateTimeToStr(v);
282	varStrArg,
283	varString:
284	Result := v;
285	varBoolean:
286	if v then
287	Result := 'true'
288	else
289	Result := 'false';
290	varVariant:
291	Result := v;
292	else
293	Result := v;
294	end;
295	end;
296
297	function TParamIntf.GetIsNull: boolean;
298	begin
299	Result := VarIsNull(FOwner.FParams[FIndex].Value);
300	end;
301
302	function TParamIntf.GetAsVariant: Variant;
303	begin
304	Result := FOwner.FParams[FIndex].Value;
305	end;
306
307	function TParamIntf.GetAsBlob: IBlob;
308	begin
309	IBError(ibxeNotSupported,[]);
310	end;
311
312	function TParamIntf.GetAsArray: IArray;
313	begin
314	IBError(ibxeNotSupported,[]);
315	end;
316
317	procedure TParamIntf.Clear;
318	begin
319	FOwner.SetParam(FIndex,NULL);
320	end;
321
322	function TParamIntf.GetModified: boolean;
323	begin
324	Result := FOwner.FParams[FIndex].Modified;
325	end;
326
327	procedure TParamIntf.SetAsBoolean(AValue: boolean);
328	begin
329	FOwner.SetParam(FIndex,AValue);
330	end;
331
332	procedure TParamIntf.SetAsCurrency(aValue: Currency);
333	begin
334	FOwner.SetParam(FIndex,AValue);
335	end;
336
337	procedure TParamIntf.SetAsInt64(aValue: Int64);
338	begin
339	FOwner.SetParam(FIndex,AValue);
340	end;
341
342	procedure TParamIntf.SetAsDate(aValue: TDateTime);
343	begin
344	FOwner.SetParam(FIndex,AValue);
345	end;
346
347	procedure TParamIntf.SetAsLong(aValue: Long);
348	begin
349	FOwner.SetParam(FIndex,AValue);
350	end;
351
352	procedure TParamIntf.SetAsTime(aValue: TDateTime);
353	begin
354	FOwner.SetParam(FIndex,AValue);
355	end;
356
357	procedure TParamIntf.SetAsDateTime(aValue: TDateTime);
358	begin
359	FOwner.SetParam(FIndex,AValue);
360	end;
361
362	procedure TParamIntf.SetAsDouble(aValue: Double);
363	begin
364	FOwner.SetParam(FIndex,AValue);
365	end;
366
367	procedure TParamIntf.SetAsFloat(aValue: Float);
368	begin
369	FOwner.SetParam(FIndex,AValue);
370	end;
371
372	procedure TParamIntf.SetAsPointer(aValue: Pointer);
373	begin
374	IBError(ibxeNotSupported,[]);
375	end;
376
377	procedure TParamIntf.SetAsShort(aValue: Short);
378	begin
379	FOwner.SetParam(FIndex,AValue);
380	end;
381
382	procedure TParamIntf.SetAsString(aValue: AnsiString);
383	begin
384	FOwner.SetParam(FIndex,AValue);
385	end;
386
387	procedure TParamIntf.SetAsVariant(aValue: Variant);
388	begin
389	FOwner.SetParam(FIndex,AValue);
390	end;
391
392	procedure TParamIntf.SetIsNull(aValue: Boolean);
393	begin
394	if aValue then
395	FOwner.SetParam(FIndex,NULL)
396	end;
397
398	procedure TParamIntf.SetAsBlob(aValue: IBlob);
399	begin
400	IBError(ibxeNotSupported,[]);
401	end;
402
403	procedure TParamIntf.SetAsArray(anArray: IArray);
404	begin
405	IBError(ibxeNotSupported,[]);
406	end;
407
408	procedure TParamIntf.SetAsQuad(aValue: TISC_QUAD);
409	begin
410	IBError(ibxeNotSupported,[]);
411	end;
412
413	procedure TParamIntf.SetCharSetID(aValue: cardinal);
414	var s: RawByteString;
415	codepage: TSystemCodePage;
416	str: string;
417	begin
418	str := FOwner.FParams[FIndex].Value;
419	s := str;
420	if FOwner.Database.Attachment.CharSetID2CodePage(aValue,codepage) then
421	SetCodePage(s,codepage,codepage <> cp_none);
422	end;
423
424	{ TParamListIntf }
425
426	procedure TParamListIntf.SetParam(index: integer; aValue: variant);
427	begin
428	FParams[index].Value := aValue;
429	FParams[index].Modified := true;
430	FModified := true;
431	end;
432
433	constructor TParamListIntf.Create(aFields: TFields; aDatabase: TIBDatabase);
434	var i,j: integer;
435	begin
436	inherited Create;
437	FDatabase := aDatabase;
438	SetLength(FParams,aFields.Count*2);
439	j := 0;
440	{set up both current and "OLD" parameters from Field Names}
441	for i := 0 to aFields.Count - 1 do
442	if aFields[i].FieldKind = fkData then
443	begin
444	FParams[j].Name := aFields[i].FieldName;
445	FParams[j].Value := NULL;
446	FParams[j].Modified := false;
447	Inc(j);
448	FParams[j].Name := 'OLD_' + aFields[i].FieldName;
449	FParams[j].Value := NULL;
450	FParams[j].Modified := false;
451	Inc(j);
452	end;
453	SetLength(FParams,j);
454	end;
455
456	destructor TParamListIntf.Destroy;
457	begin
458	SetLength(FParams,0);
459	inherited Destroy;
460	end;
461
462	function TParamListIntf.getCount: integer;
463	begin
464	Result := Length(FParams);
465	end;
466
467	function TParamListIntf.getSQLParam(index: integer): ISQLParam;
468	begin
469	if (index < 0) or (index >= getCount) then
470	IBError(ibxeInvalidColumnIndex,[nil]);
471	Result := TParamIntf.Create(self,index);
472	end;
473
474	function TParamListIntf.ByName(Idx: AnsiString): ISQLParam;
475	var i: integer;
476	begin
477	Result := nil;
478	for i := 0 to getCount - 1 do
479	if CompareText(FParams[i].Name,Idx) = 0 then
480	begin
481	Result := getSQLParam(i);
482	Exit;
483	end;
484	end;
485
486	function TParamListIntf.GetModified: Boolean;
487	begin
488	Result := FModified;
489	end;
490
491	{ TIBUpdate }
492
493	function TIBUpdate.GetSQL(UpdateKind: TUpdateKind): TStrings;
494	begin
495	Result := FDummySQL; {non empty result}
496	end;
497
498	function TIBUpdate.GetDataSet: TIBCustomDataSet;
499	begin
500	Result := FDataSet;
501	end;
502
503	procedure TIBUpdate.SetDataSet(ADataSet: TIBCustomDataSet);
504	begin
505	FDataSet := ADataset;
506	end;
507
508	procedure TIBUpdate.Apply(UpdateKind: TUpdateKind; buff: PChar);
509	var Params: ISQLParams;
510	begin
511	Params := TParamListIntf.Create(Dataset.Fields,(DataSet.Database as TIBDatabase));
512	InternalSetParams(Params,buff);
513	if assigned(FOnApplyUpdates) then
514	OnApplyUpdates(self,UpdateKind,Params);
515	end;
516
517	constructor TIBUpdate.Create(AOwner: TComponent);
518	begin
519	inherited Create(AOwner);
520	FDummySQL := TStringList.Create;
521	FDummySQL.Text := '*';
522	end;
523
524	destructor TIBUpdate.Destroy;
525	begin
526	if assigned(FDummySQL) then FDummySQL.Free;
527	inherited Destroy;
528	end;
529
530	end.
531