ViewVC Help
View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing
root/public/ibx/branches/journaling/fbintf/client/FBSQLData.pas
(Generate patch)

Comparing ibx/trunk/fbintf/client/FBSQLData.pas (file contents):
Revision 45 by tony, Tue Dec 6 10:33:46 2016 UTC vs.
Revision 350 by tony, Wed Oct 20 14:58:56 2021 UTC

# Line 60 | Line 60
60   {                                                                        }
61   {************************************************************************}
62   unit FBSQLData;
63 + {$IFDEF MSWINDOWS}
64 + {$DEFINE WINDOWS}
65 + {$ENDIF}
66  
67   {$IFDEF FPC}
68 < {$mode objfpc}{$H+}
68 > {$mode delphi}
69   {$codepage UTF8}
70   {$interfaces COM}
71   {$ENDIF}
# Line 73 | Line 76 | unit FBSQLData;
76    methods are needed for SQL parameters only. The string getters and setters
77    are virtual as SQLVar and Array encodings of string data is different.}
78  
76 { $define ALLOWDIALECT3PARAMNAMES}
77
78 {$ifndef ALLOWDIALECT3PARAMNAMES}
79
80 { Note on SQL Dialects and SQL Parameter Names
81  --------------------------------------------
82
83  Even when dialect 3 quoted format parameter names are not supported, IBX still processes
84  parameter names case insensitive. This does result in some additional overhead
85  due to a call to "AnsiUpperCase". This can be avoided by undefining
86  "UseCaseInSensitiveParamName" below.
87
88  Note: do not define "UseCaseSensitiveParamName" when "ALLOWDIALECT3PARAMNAMES"
89  is defined. This will not give a useful result.
90 }
91 {$define UseCaseInSensitiveParamName}
92 {$endif}
79  
80   interface
81  
82   uses
83 <  Classes, SysUtils, IBExternals, IBHeader, IB,  FBActivityMonitor;
83 >  Classes, SysUtils, IBExternals, {$IFDEF WINDOWS} Windows, {$ENDIF} IB,  FBActivityMonitor, FBClientAPI,
84 >  FmtBCD;
85  
86   type
87  
88 <  { TSQLDataItem }
88 >   {The IExTimeZoneServices is only available in FB4 and onwards}
89 >
90 >   IExTimeZoneServices = interface(ITimeZoneServices)
91 >   ['{789c2eeb-c4a7-4fed-837e-0cbdef775904}']
92 >   {encode/decode - used to encode/decode the wire protocol}
93 >   procedure EncodeTimestampTZ(timestamp: TDateTime; timezoneID: TFBTimeZoneID;
94 >     bufptr: PByte); overload;
95 >   procedure EncodeTimestampTZ(timestamp: TDateTime; timezone: AnsiString;
96 >       bufptr: PByte); overload;
97 >   procedure EncodeTimeTZ(time: TDateTime; timezoneID: TFBTimeZoneID; OnDate: TDateTime;
98 >     bufptr: PByte); overload;
99 >   procedure EncodeTimeTZ(time: TDateTime; timezone: AnsiString; OnDate: TDateTime;
100 >     bufptr: PByte); overload;
101 >   procedure DecodeTimestampTZ(bufptr: PByte; var timestamp: TDateTime;
102 >     var dstOffset: smallint; var timezoneID: TFBTimeZoneID); overload;
103 >   procedure DecodeTimestampTZ(bufptr: PByte; var timestamp: TDateTime;
104 >     var dstOffset: smallint; var timezone: AnsiString); overload;
105 >   procedure DecodeTimestampTZEx(bufptr: PByte; var timestamp: TDateTime;
106 >     var dstOffset: smallint; var timezoneID: TFBTimeZoneID); overload;
107 >   procedure DecodeTimestampTZEx(bufptr: PByte; var timestamp: TDateTime;
108 >     var dstOffset: smallint; var timezone: AnsiString); overload;
109 >   procedure DecodeTimeTZ(bufptr: PByte; OnDate: TDateTime; var time: TDateTime;
110 >     var dstOffset: smallint; var timezoneID: TFBTimeZoneID); overload;
111 >   procedure DecodeTimeTZ(bufptr: PByte; OnDate: TDateTime; var time: TDateTime;
112 >     var dstOffset: smallint; var timezone: AnsiString); overload;
113 >   procedure DecodeTimeTZEx(bufptr: PByte; OnDate: TDateTime; var time: TDateTime;
114 >     var dstOffset: smallint; var timezoneID: TFBTimeZoneID); overload;
115 >   procedure DecodeTimeTZEx(bufptr: PByte; OnDate: TDateTime; var time: TDateTime;
116 >     var dstOffset: smallint; var timezone: AnsiString); overload;
117 >   end;
118 >
119 >   { TSQLDataItem }
120  
121    TSQLDataItem = class(TFBInterfacedObject)
122    private
123 +     FFirebirdClientAPI: TFBClientAPI;
124 +     FTimeZoneServices: IExTimeZoneServices;
125       function AdjustScale(Value: Int64; aScale: Integer): Double;
126       function AdjustScaleToInt64(Value: Int64; aScale: Integer): Int64;
127       function AdjustScaleToCurrency(Value: Int64; aScale: Integer): Currency;
128 +     function GetDateFormatStr(IncludeTime: boolean): AnsiString;
129 +     function GetTimeFormatStr: AnsiString;
130 +     function GetTimestampFormatStr: AnsiString;
131       procedure SetAsInteger(AValue: Integer);
132 +     procedure InternalGetAsDateTime(var aDateTime: TDateTime; var dstOffset: smallint;
133 +       var aTimezone: AnsiString; var aTimeZoneID: TFBTimeZoneID);
134    protected
135       function AdjustScaleFromCurrency(Value: Currency; aScale: Integer): Int64;
136       function AdjustScaleFromDouble(Value: Double; aScale: Integer): Int64;
137       procedure CheckActive; virtual;
138 +     procedure CheckTZSupport;
139 +     function GetAttachment: IAttachment; virtual; abstract;
140       function GetSQLDialect: integer; virtual; abstract;
141 +     function GetTimeZoneServices: IExTimeZoneServices; virtual;
142       procedure Changed; virtual;
143       procedure Changing; virtual;
144 <     procedure InternalSetAsString(Value: String); virtual;
145 <     function SQLData: PChar; virtual; abstract;
144 >     procedure InternalSetAsString(Value: AnsiString); virtual;
145 >     function SQLData: PByte; virtual; abstract;
146       function GetDataLength: cardinal; virtual; abstract;
147       function GetCodePage: TSystemCodePage; virtual; abstract;
148 <     function Transliterate(s: string; CodePage: TSystemCodePage): RawByteString;
148 >     function getCharSetID: cardinal; virtual; abstract;
149 >     function Transliterate(s: AnsiString; CodePage: TSystemCodePage): RawByteString;
150       procedure SetScale(aValue: integer); virtual;
151       procedure SetDataLength(len: cardinal); virtual;
152       procedure SetSQLType(aValue: cardinal); virtual;
153       property DataLength: cardinal read GetDataLength write SetDataLength;
154 <
154 >     property FirebirdClientAPI: TFBClientAPI read FFirebirdClientAPI;
155    public
156 <     function GetSQLType: cardinal; virtual; abstract;
157 <     function GetSQLTypeName: string; overload;
158 <     class function GetSQLTypeName(SQLType: short): string; overload;
159 <     function GetName: string; virtual; abstract;
160 <     function GetScale: integer; virtual; abstract;
156 >     constructor Create(api: TFBClientAPI);
157 >     function GetSQLType: cardinal; virtual; abstract; {Current Field Data SQL Type}
158 >     function GetSQLTypeName: AnsiString; overload;
159 >     class function GetSQLTypeName(SQLType: cardinal): AnsiString; overload;
160 >     function GetStrDataLength: short;
161 >     function GetName: AnsiString; virtual; abstract;
162 >     function GetScale: integer; virtual; abstract; {Current Field Data scale}
163       function GetAsBoolean: boolean;
164       function GetAsCurrency: Currency;
165       function GetAsInt64: Int64;
166 <     function GetAsDateTime: TDateTime;
166 >     function GetAsDateTime: TDateTime; overload;
167 >     procedure GetAsDateTime(var aDateTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString); overload;
168 >     procedure GetAsDateTime(var aDateTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID); overload;
169 >     procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID; OnDate: TDateTime); overload;
170 >     procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString; OnDate: TDateTime); overload;
171 >     procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezoneID: TFBTimeZoneID); overload;
172 >     procedure GetAsTime(var aTime: TDateTime; var dstOffset: smallint; var aTimezone: AnsiString); overload;
173 >     function GetAsUTCDateTime: TDateTime;
174       function GetAsDouble: Double;
175       function GetAsFloat: Float;
176       function GetAsLong: Long;
177       function GetAsPointer: Pointer;
178       function GetAsQuad: TISC_QUAD;
179       function GetAsShort: short;
180 <     function GetAsString: String; virtual;
180 >     function GetAsString: AnsiString; virtual;
181       function GetIsNull: Boolean; virtual;
182 <     function getIsNullable: boolean; virtual;
182 >     function GetIsNullable: boolean; virtual;
183       function GetAsVariant: Variant;
184       function GetModified: boolean; virtual;
185 +     function GetDateTimeStrLength(DateTimeFormat: TIBDateTimeFormats): integer;
186 +     function GetAsBCD: tBCD;
187 +     function GetSize: cardinal; virtual; abstract;
188 +     function GetCharSetWidth: integer; virtual; abstract;
189       procedure SetAsBoolean(AValue: boolean); virtual;
190       procedure SetAsCurrency(Value: Currency); virtual;
191       procedure SetAsInt64(Value: Int64); virtual;
192       procedure SetAsDate(Value: TDateTime); virtual;
193       procedure SetAsLong(Value: Long); virtual;
194 <     procedure SetAsTime(Value: TDateTime); virtual;
195 <     procedure SetAsDateTime(Value: TDateTime);
194 >     procedure SetAsTime(Value: TDateTime); overload;
195 >     procedure SetAsTime(aValue: TDateTime; OnDate: TDateTime;aTimeZoneID: TFBTimeZoneID); overload;
196 >     procedure SetAsTime(aValue: TDateTime; OnDate: TDateTime; aTimeZone: AnsiString); overload;
197 >     procedure SetAsDateTime(Value: TDateTime); overload;
198 >     procedure SetAsDateTime(aValue: TDateTime; aTimeZoneID: TFBTimeZoneID); overload;
199 >     procedure SetAsDateTime(aValue: TDateTime; aTimeZone: AnsiString); overload;
200 >     procedure SetAsUTCDateTime(aUTCTime: TDateTime);
201       procedure SetAsDouble(Value: Double); virtual;
202       procedure SetAsFloat(Value: Float); virtual;
203       procedure SetAsPointer(Value: Pointer);
204       procedure SetAsQuad(Value: TISC_QUAD);
205       procedure SetAsShort(Value: short); virtual;
206 <     procedure SetAsString(Value: String); virtual;
206 >     procedure SetAsString(Value: AnsiString); virtual;
207       procedure SetAsVariant(Value: Variant);
208 +     procedure SetAsNumeric(Value: Int64; aScale: integer);
209 +     procedure SetAsBcd(aValue: tBCD); virtual;
210       procedure SetIsNull(Value: Boolean); virtual;
211       procedure SetIsNullable(Value: Boolean); virtual;
212 <     procedure SetName(aValue: string); virtual;
212 >     procedure SetName(aValue: AnsiString); virtual;
213       property AsDate: TDateTime read GetAsDateTime write SetAsDate;
214       property AsBoolean:boolean read GetAsBoolean write SetAsBoolean;
215       property AsTime: TDateTime read GetAsDateTime write SetAsTime;
# Line 174 | Line 223 | type
223       property AsPointer: Pointer read GetAsPointer write SetAsPointer;
224       property AsQuad: TISC_QUAD read GetAsQuad write SetAsQuad;
225       property AsShort: short read GetAsShort write SetAsShort;
226 <     property AsString: String read GetAsString write SetAsString;
226 >     property AsString: AnsiString read GetAsString write SetAsString;
227       property AsVariant: Variant read GetAsVariant write SetAsVariant;
228       property Modified: Boolean read getModified;
229       property IsNull: Boolean read GetIsNull write SetIsNull;
# Line 191 | Line 240 | type
240  
241    TSQLDataArea = class
242    private
243 +    FCaseSensitiveParams: boolean;
244      function GetColumn(index: integer): TSQLVarData;
245      function GetCount: integer;
246    protected
247 <    FUniqueRelationName: string;
247 >    FUniqueRelationName: AnsiString;
248      FColumnList: array of TSQLVarData;
249      function GetStatement: IStatement; virtual; abstract;
250      function GetPrepareSeqNo: integer; virtual; abstract;
# Line 204 | Line 254 | type
254    public
255      procedure Initialize; virtual;
256      function IsInputDataArea: boolean; virtual; abstract; {Input to Database}
257 <    procedure PreprocessSQL(sSQL: string; GenerateParamNames: boolean;
258 <      var sProcessedSQL: string);
257 >    procedure PreprocessSQL(sSQL: AnsiString; GenerateParamNames: boolean;
258 >      var sProcessedSQL: AnsiString);
259      function ColumnsInUseCount: integer; virtual;
260 <    function ColumnByName(Idx: string): TSQLVarData;
260 >    function ColumnByName(Idx: AnsiString): TSQLVarData;
261      function CheckStatementStatus(Request: TStatementStatus): boolean; virtual; abstract;
262      procedure GetData(index: integer; var IsNull: boolean; var len: short;
263 <      var data: PChar); virtual;
263 >      var data: PByte); virtual;
264      procedure RowChange;
265      function StateChanged(var ChangeSeqNo: integer): boolean; virtual; abstract;
266 +    property CaseSensitiveParams: boolean read FCaseSensitiveParams
267 +                                            write FCaseSensitiveParams; {Only used when IsInputDataArea true}
268 +    function CanChangeMetaData: boolean; virtual; abstract;
269      property Count: integer read GetCount;
270      property Column[index: integer]: TSQLVarData read GetColumn;
271 <    property UniqueRelationName: string read FUniqueRelationName;
271 >    property UniqueRelationName: AnsiString read FUniqueRelationName;
272      property Statement: IStatement read GetStatement;
273      property PrepareSeqNo: integer read GetPrepareSeqNo;
274      property TransactionSeqNo: integer read GetTransactionSeqNo;
# Line 226 | Line 279 | type
279    TSQLVarData = class
280    private
281      FParent: TSQLDataArea;
282 <    FName: string;
282 >    FName: AnsiString;
283      FIndex: integer;
284      FModified: boolean;
285      FUniqueName: boolean;
286      FVarString: RawByteString;
287 +    FColMetaData: IParamMetaData;
288      function GetStatement: IStatement;
289 <    procedure SetName(AValue: string);
289 >    procedure SetName(AValue: AnsiString);
290    protected
291 +    function GetAttachment: IAttachment; virtual; abstract;
292      function GetSQLType: cardinal; virtual; abstract;
293      function GetSubtype: integer; virtual; abstract;
294 <    function GetAliasName: string;  virtual; abstract;
295 <    function GetFieldName: string; virtual; abstract;
296 <    function GetOwnerName: string;  virtual; abstract;
297 <    function GetRelationName: string;  virtual; abstract;
294 >    function GetAliasName: AnsiString;  virtual; abstract;
295 >    function GetFieldName: AnsiString; virtual; abstract;
296 >    function GetOwnerName: AnsiString;  virtual; abstract;
297 >    function GetRelationName: AnsiString;  virtual; abstract;
298      function GetScale: integer; virtual; abstract;
299      function GetCharSetID: cardinal; virtual; abstract;
300 +    function GetCharSetWidth: integer; virtual; abstract;
301      function GetCodePage: TSystemCodePage; virtual; abstract;
302      function GetIsNull: Boolean;   virtual; abstract;
303      function GetIsNullable: boolean; virtual; abstract;
304 <    function GetSQLData: PChar;  virtual; abstract;
305 <    function GetDataLength: cardinal; virtual; abstract;
304 >    function GetSQLData: PByte;  virtual; abstract;
305 >    function GetDataLength: cardinal; virtual; abstract; {current field length}
306 >    function GetSize: cardinal; virtual; abstract; {field length as given by metadata}
307 >    function GetDefaultTextSQLType: cardinal; virtual; abstract;
308      procedure SetIsNull(Value: Boolean); virtual; abstract;
309      procedure SetIsNullable(Value: Boolean);  virtual; abstract;
310 <    procedure SetSQLData(AValue: PChar; len: cardinal); virtual; abstract;
310 >    procedure SetSQLData(AValue: PByte; len: cardinal); virtual; abstract;
311      procedure SetScale(aValue: integer); virtual; abstract;
312      procedure SetDataLength(len: cardinal); virtual; abstract;
313      procedure SetSQLType(aValue: cardinal); virtual; abstract;
314      procedure SetCharSetID(aValue: cardinal); virtual; abstract;
315 +    procedure SetMetaSize(aValue: cardinal); virtual;
316    public
317      constructor Create(aParent: TSQLDataArea; aIndex: integer);
318 <    procedure SetString(aValue: string);
318 >    procedure SetString(aValue: AnsiString);
319      procedure Changed; virtual;
320      procedure RowChange; virtual;
321      function GetAsArray(Array_ID: TISC_QUAD): IArray; virtual; abstract;
# Line 264 | Line 323 | type
323      function CreateBlob: IBlob; virtual; abstract;
324      function GetArrayMetaData: IArrayMetaData; virtual; abstract;
325      function GetBlobMetaData: IBlobMetaData; virtual; abstract;
326 +    function getColMetadata: IParamMetaData;
327      procedure Initialize; virtual;
328 +    procedure SaveMetaData;
329  
330    public
331 <    property AliasName: string read GetAliasName;
332 <    property FieldName: string read GetFieldName;
333 <    property OwnerName: string read GetOwnerName;
334 <    property RelationName: string read GetRelationName;
331 >    property AliasName: AnsiString read GetAliasName;
332 >    property FieldName: AnsiString read GetFieldName;
333 >    property OwnerName: AnsiString read GetOwnerName;
334 >    property RelationName: AnsiString read GetRelationName;
335      property Parent: TSQLDataArea read FParent;
336      property Index: integer read FIndex;
337 <    property Name: string read FName write SetName;
337 >    property Name: AnsiString read FName write SetName;
338      property CharSetID: cardinal read GetCharSetID write SetCharSetID;
339      property SQLType: cardinal read GetSQLType write SetSQLType;
340      property SQLSubtype: integer read GetSubtype;
341 <    property SQLData: PChar read GetSQLData;
341 >    property SQLData: PByte read GetSQLData;
342      property DataLength: cardinal read GetDataLength write SetDataLength;
343      property IsNull: Boolean read GetIsNull write SetIsNull;
344      property IsNullable: Boolean read GetIsNullable write SetIsNullable;
# Line 295 | Line 356 | type
356      FIBXSQLVAR: TSQLVarData;
357      FOwner: IUnknown;         {Keep reference to ensure Metadata/statement not discarded}
358      FPrepareSeqNo: integer;
298    FStatement: IStatement;
359      FChangeSeqNo: integer;
360    protected
361      procedure CheckActive; override;
362 <    function SQLData: PChar; override;
362 >    function GetAttachment: IAttachment; override;
363 >    function SQLData: PByte; override;
364      function GetDataLength: cardinal; override;
365      function GetCodePage: TSystemCodePage; override;
366  
# Line 307 | Line 368 | type
368      constructor Create(aOwner: IUnknown; aIBXSQLVAR: TSQLVarData);
369      destructor Destroy; override;
370      function GetSQLDialect: integer; override;
310    property Statement: IStatement read FStatement;
371  
372    public
373      {IColumnMetaData}
374      function GetIndex: integer;
375      function GetSQLType: cardinal; override;
376      function getSubtype: integer;
377 <    function getRelationName: string;
378 <    function getOwnerName: string;
379 <    function getSQLName: string;    {Name of the column}
380 <    function getAliasName: string;  {Alias Name of column or Column Name if not alias}
381 <    function GetName: string; override;      {Disambiguated uppercase Field Name}
377 >    function getRelationName: AnsiString;
378 >    function getOwnerName: AnsiString;
379 >    function getSQLName: AnsiString;    {Name of the column}
380 >    function getAliasName: AnsiString;  {Alias Name of column or Column Name if not alias}
381 >    function GetName: AnsiString; override;      {Disambiguated uppercase Field Name}
382      function GetScale: integer; override;
383 <    function getCharSetID: cardinal;
383 >    function getCharSetID: cardinal; override;
384      function GetIsNullable: boolean; override;
385 <    function GetSize: cardinal;
385 >    function GetSize: cardinal; override;
386 >    function GetCharSetWidth: integer; override;
387      function GetArrayMetaData: IArrayMetaData;
388      function GetBlobMetaData: IBlobMetaData;
389 <    property Name: string read GetName;
389 >    function GetStatement: IStatement;
390 >    function GetTransaction: ITransaction; virtual;
391 >    property Name: AnsiString read GetName;
392      property Size: cardinal read GetSize;
393      property CharSetID: cardinal read getCharSetID;
394      property SQLSubtype: integer read getSubtype;
395      property IsNullable: Boolean read GetIsNullable;
396 +  public
397 +    property Statement: IStatement read GetStatement;
398    end;
399  
400    { TIBSQLData }
401  
402    TIBSQLData = class(TColumnMetaData,ISQLData)
403 +  private
404 +    FTransaction: ITransaction;
405    protected
406      procedure CheckActive; override;
407    public
408 +    function GetTransaction: ITransaction; override;
409      function GetIsNull: Boolean; override;
410      function GetAsArray: IArray;
411      function GetAsBlob: IBlob; overload;
412      function GetAsBlob(BPB: IBPB): IBlob; overload;
413 <    function GetAsString: String; override;
413 >    function GetAsString: AnsiString; override;
414      property AsBlob: IBlob read GetAsBlob;
415   end;
416  
417 +  { TSQLParamMetaData }
418 +
419 +  TSQLParamMetaData = class(TFBInterfacedObject,IParamMetaData)
420 +  private
421 +    FSQLType: cardinal;
422 +    FSQLSubType: integer;
423 +    FScale: integer;
424 +    FCharSetID: cardinal;
425 +    FNullable: boolean;
426 +    FSize: cardinal;
427 +    FCodePage: TSystemCodePage;
428 +  public
429 +    constructor Create(src: TSQLVarData);
430 +    {IParamMetaData}
431 +    function GetSQLType: cardinal;
432 +    function GetSQLTypeName: AnsiString;
433 +    function getSubtype: integer;
434 +    function getScale: integer;
435 +    function getCharSetID: cardinal;
436 +    function getCodePage: TSystemCodePage;
437 +    function getIsNullable: boolean;
438 +    function GetSize: cardinal;
439 +    property SQLType: cardinal read GetSQLType;
440 +  end;
441 +
442    { TSQLParam }
443  
444 <  TSQLParam = class(TIBSQLData,ISQLParam)
444 >  TSQLParam = class(TIBSQLData,ISQLParam,ISQLData)
445    protected
446      procedure CheckActive; override;
447      procedure Changed; override;
448 <    procedure InternalSetAsString(Value: String); override;
448 >    procedure InternalSetAsString(Value: AnsiString); override;
449      procedure SetScale(aValue: integer); override;
450      procedure SetDataLength(len: cardinal); override;
451      procedure SetSQLType(aValue: cardinal); override;
452    public
453      procedure Clear;
454 +    function getColMetadata: IParamMetaData;
455      function GetModified: boolean; override;
456      function GetAsPointer: Pointer;
457 <    procedure SetName(Value: string); override;
457 >    function GetAsString: AnsiString; override;
458 >    procedure SetName(Value: AnsiString); override;
459      procedure SetIsNull(Value: Boolean);  override;
460      procedure SetIsNullable(Value: Boolean); override;
461      procedure SetAsArray(anArray: IArray);
# Line 371 | Line 466 | type
466      procedure SetAsInt64(AValue: Int64);
467      procedure SetAsDate(AValue: TDateTime);
468      procedure SetAsLong(AValue: Long);
469 <    procedure SetAsTime(AValue: TDateTime);
470 <    procedure SetAsDateTime(AValue: TDateTime);
469 >    procedure SetAsTime(AValue: TDateTime); overload;
470 >    procedure SetAsTime(aValue: TDateTime; OnDate: TDateTime; aTimeZoneID: TFBTimeZoneID); overload;
471 >    procedure SetAsTime(aValue: TDateTime; OnDate: TDateTime; aTimeZone: AnsiString); overload;
472 >    procedure SetAsTime(aValue: TDateTime; aTimeZoneID: TFBTimeZoneID); overload;
473 >    procedure SetAsTime(aValue: TDateTime; aTimeZone: AnsiString); overload;
474 >    procedure SetAsDateTime(AValue: TDateTime); overload;
475 >    procedure SetAsDateTime(aValue: TDateTime; aTimeZoneID: TFBTimeZoneID); overload;
476 >    procedure SetAsDateTime(aValue: TDateTime; aTimeZone: AnsiString); overload;
477      procedure SetAsDouble(AValue: Double);
478      procedure SetAsFloat(AValue: Float);
479      procedure SetAsPointer(AValue: Pointer);
480      procedure SetAsShort(AValue: Short);
481 <    procedure SetAsString(AValue: String); override;
481 >    procedure SetAsString(AValue: AnsiString); override;
482      procedure SetAsVariant(AValue: Variant);
483      procedure SetAsBlob(aValue: IBlob);
484      procedure SetAsQuad(AValue: TISC_QUAD);
485      procedure SetCharSetID(aValue: cardinal);
486 +    procedure SetAsBcd(aValue: tBCD);
487  
488      property AsBlob: IBlob read GetAsBlob write SetAsBlob;
489      property IsNullable: Boolean read GetIsNullable write SetIsNullable;
# Line 400 | Line 502 | type
502      destructor Destroy; override;
503    public
504      {IMetaData}
505 <    function GetUniqueRelationName: string;
505 >    function GetUniqueRelationName: AnsiString;
506      function getCount: integer;
507      function getColumnMetaData(index: integer): IColumnMetaData;
508 <    function ByName(Idx: String): IColumnMetaData;
508 >    function ByName(Idx: AnsiString): IColumnMetaData;
509    end;
510  
511    { TSQLParams }
# Line 422 | Line 524 | type
524      {ISQLParams}
525      function getCount: integer;
526      function getSQLParam(index: integer): ISQLParam;
527 <    function ByName(Idx: String): ISQLParam ;
527 >    function ByName(Idx: AnsiString): ISQLParam ;
528      function GetModified: Boolean;
529 +    function GetHasCaseSensitiveParams: Boolean;
530    end;
531  
532    { TResults }
# Line 442 | Line 545 | type
545       constructor Create(aResults: TSQLDataArea);
546        {IResults}
547       function getCount: integer;
548 <     function ByName(Idx: String): ISQLData;
548 >     function ByName(Idx: AnsiString): ISQLData;
549       function getSQLData(index: integer): ISQLData;
550 <     procedure GetData(index: integer; var IsNull:boolean; var len: short; var data: PChar);
550 >     procedure GetData(index: integer; var IsNull:boolean; var len: short; var data: PByte);
551 >     function GetStatement: IStatement;
552       function GetTransaction: ITransaction; virtual;
553       procedure SetRetainInterfaces(aValue: boolean);
554   end;
555  
556   implementation
557  
558 < uses FBMessages, FBClientAPI, variants, IBUtils, FBTransaction;
558 > uses FBMessages, variants, IBUtils, FBTransaction, DateUtils;
559 >
560 > { TSQLParamMetaData }
561 >
562 > constructor TSQLParamMetaData.Create(src: TSQLVarData);
563 > begin
564 >  inherited Create;
565 >  FSQLType := src.GetSQLType;
566 >  FSQLSubType := src.getSubtype;
567 >  FScale := src.GetScale;
568 >  FCharSetID := src.getCharSetID;
569 >  FNullable := src.GetIsNullable;
570 >  FSize := src.GetSize;
571 >  FCodePage := src.GetCodePage;
572 > end;
573 >
574 > function TSQLParamMetaData.GetSQLType: cardinal;
575 > begin
576 >  Result := FSQLType;
577 > end;
578 >
579 > function TSQLParamMetaData.GetSQLTypeName: AnsiString;
580 > begin
581 >  Result := TSQLDataItem.GetSQLTypeName(FSQLType);
582 > end;
583 >
584 > function TSQLParamMetaData.getSubtype: integer;
585 > begin
586 >  Result := FSQLSubType;
587 > end;
588 >
589 > function TSQLParamMetaData.getScale: integer;
590 > begin
591 >  Result := FScale;
592 > end;
593 >
594 > function TSQLParamMetaData.getCharSetID: cardinal;
595 > begin
596 >  Result := FCharSetID;
597 > end;
598 >
599 > function TSQLParamMetaData.getCodePage: TSystemCodePage;
600 > begin
601 >  Result :=  FCodePage;
602 > end;
603 >
604 > function TSQLParamMetaData.getIsNullable: boolean;
605 > begin
606 >  Result :=  FNullable;
607 > end;
608 >
609 > function TSQLParamMetaData.GetSize: cardinal;
610 > begin
611 >  Result := FSize;
612 > end;
613  
614   { TSQLDataArea }
615  
# Line 471 | Line 629 | procedure TSQLDataArea.SetUniqueRelation
629   var
630    i: Integer;
631    bUnique: Boolean;
632 <  RelationName: string;
632 >  RelationName: AnsiString;
633   begin
634    bUnique := True;
635    for i := 0 to ColumnsInUseCount - 1 do
# Line 502 | Line 660 | begin
660      Column[i].Initialize;
661   end;
662  
663 < procedure TSQLDataArea.PreprocessSQL(sSQL: string; GenerateParamNames: boolean;
664 <  var sProcessedSQL: string);
507 < var
508 <  cCurChar, cNextChar, cQuoteChar: Char;
509 <  sParamName: String;
510 <  j, i, iLenSQL, iSQLPos: Integer;
511 <  iCurState {$ifdef ALLOWDIALECT3PARAMNAMES}, iCurParamState {$endif}: Integer;
512 <  iParamSuffix: Integer;
513 <  slNames: TStrings;
514 <  StrBuffer: PChar;
515 <  found: boolean;
516 <
517 < const
518 <  DefaultState = 0;
519 <  CommentState = 1;
520 <  QuoteState = 2;
521 <  ParamState = 3;
522 < {$ifdef ALLOWDIALECT3PARAMNAMES}
523 <  ParamDefaultState = 0;
524 <  ParamQuoteState = 1;
525 <  {$endif}
526 <
527 <  procedure AddToProcessedSQL(cChar: Char);
528 <  begin
529 <    StrBuffer[iSQLPos] := cChar;
530 <    Inc(iSQLPos);
531 <  end;
663 > procedure TSQLDataArea.PreprocessSQL(sSQL: AnsiString; GenerateParamNames: boolean;
664 >  var sProcessedSQL: AnsiString);
665  
666 < begin
534 <  if not IsInputDataArea then
535 <    IBError(ibxeNotPermitted,[nil]);
666 > var slNames: TStrings;
667  
668 <  sParamName := '';
669 <  iLenSQL := Length(sSQL);
670 <  GetMem(StrBuffer,iLenSQL + 1);
671 <  slNames := TStringList.Create;
672 <  try
542 <    { Do some initializations of variables }
543 <    iParamSuffix := 0;
544 <    cQuoteChar := '''';
545 <    i := 1;
546 <    iSQLPos := 0;
547 <    iCurState := DefaultState;
548 <    {$ifdef ALLOWDIALECT3PARAMNAMES}
549 <    iCurParamState := ParamDefaultState;
550 <    {$endif}
551 <    { Now, traverse through the SQL string, character by character,
552 <     picking out the parameters and formatting correctly for InterBase }
553 <    while (i <= iLenSQL) do begin
554 <      { Get the current token and a look-ahead }
555 <      cCurChar := sSQL[i];
556 <      if i = iLenSQL then
557 <        cNextChar := #0
558 <      else
559 <        cNextChar := sSQL[i + 1];
560 <      { Now act based on the current state }
561 <      case iCurState of
562 <        DefaultState: begin
563 <          case cCurChar of
564 <            '''', '"': begin
565 <              cQuoteChar := cCurChar;
566 <              iCurState := QuoteState;
567 <            end;
568 <            '?', ':': begin
569 <              iCurState := ParamState;
570 <              AddToProcessedSQL('?');
571 <            end;
572 <            '/': if (cNextChar = '*') then begin
573 <              AddToProcessedSQL(cCurChar);
574 <              Inc(i);
575 <              iCurState := CommentState;
576 <            end;
577 <          end;
578 <        end;
579 <        CommentState: begin
580 <          if (cNextChar = #0) then
581 <            IBError(ibxeSQLParseError, [SEOFInComment])
582 <          else if (cCurChar = '*') then begin
583 <            if (cNextChar = '/') then
584 <              iCurState := DefaultState;
585 <          end;
586 <        end;
587 <        QuoteState: begin
588 <          if cNextChar = #0 then
589 <            IBError(ibxeSQLParseError, [SEOFInString])
590 <          else if (cCurChar = cQuoteChar) then begin
591 <            if (cNextChar = cQuoteChar) then begin
592 <              AddToProcessedSQL(cCurChar);
593 <              Inc(i);
594 <            end else
595 <              iCurState := DefaultState;
596 <          end;
597 <        end;
598 <        ParamState:
599 <        begin
600 <          { collect the name of the parameter }
601 <          {$ifdef ALLOWDIALECT3PARAMNAMES}
602 <          if iCurParamState = ParamDefaultState then
603 <          begin
604 <            if cCurChar = '"' then
605 <              iCurParamState := ParamQuoteState
606 <            else
607 <            {$endif}
608 <            if (cCurChar in ['A'..'Z', 'a'..'z', '0'..'9', '_', '$']) then
609 <                sParamName := sParamName + cCurChar
610 <            else if GenerateParamNames then
611 <            begin
612 <              sParamName := 'IBXParam' + IntToStr(iParamSuffix); {do not localize}
613 <              Inc(iParamSuffix);
614 <              iCurState := DefaultState;
615 <              slNames.AddObject(sParamName,self); //Note local convention
616 <                                                  //add pointer to self to mark entry
617 <              sParamName := '';
618 <            end
619 <            else
620 <              IBError(ibxeSQLParseError, [SParamNameExpected]);
621 <          {$ifdef ALLOWDIALECT3PARAMNAMES}
622 <          end
623 <          else begin
624 <            { determine if Quoted parameter name is finished }
625 <            if cCurChar = '"' then
626 <            begin
627 <              Inc(i);
628 <              slNames.Add(sParamName);
629 <              SParamName := '';
630 <              iCurParamState := ParamDefaultState;
631 <              iCurState := DefaultState;
632 <            end
633 <            else
634 <              sParamName := sParamName + cCurChar
635 <          end;
636 <          {$endif}
637 <          { determine if the unquoted parameter name is finished }
638 <          if {$ifdef ALLOWDIALECT3PARAMNAMES}(iCurParamState <> ParamQuoteState) and {$endif}
639 <            (iCurState <> DefaultState) then
640 <          begin
641 <            if not (cNextChar in ['A'..'Z', 'a'..'z',
642 <                                  '0'..'9', '_', '$']) then begin
643 <              Inc(i);
644 <              iCurState := DefaultState;
645 <              slNames.Add(sParamName);
646 <              sParamName := '';
647 <            end;
648 <          end;
649 <        end;
650 <      end;
651 <      if (iCurState <> ParamState) and (i <= iLenSQL) then
652 <        AddToProcessedSQL(sSQL[i]);
653 <      Inc(i);
654 <    end;
655 <    AddToProcessedSQL(#0);
656 <    sProcessedSQL := strpas(StrBuffer);
668 >  procedure SetColumnNames(slNames: TStrings);
669 >  var i, j: integer;
670 >      found: boolean;
671 >  begin
672 >    found := false;
673      SetCount(slNames.Count);
674      for i := 0 to slNames.Count - 1 do
675      begin
# Line 674 | Line 690 | begin
690          Column[i].UniqueName := not found;
691        end;
692      end;
693 +  end;
694 +
695 + begin
696 +  if not IsInputDataArea then
697 +    IBError(ibxeNotPermitted,[nil]);
698 +
699 +  slNames := TStringList.Create;
700 +  try
701 +    sProcessedSQL := TSQLParamProcessor.Execute(sSQL,GenerateParamNames,slNames);
702 +    SetColumnNames(slNames);
703    finally
704      slNames.Free;
679    FreeMem(StrBuffer);
705    end;
706   end;
707  
# Line 685 | Line 710 | begin
710    Result := Count;
711   end;
712  
713 < function TSQLDataArea.ColumnByName(Idx: string): TSQLVarData;
713 > function TSQLDataArea.ColumnByName(Idx: AnsiString): TSQLVarData;
714   var
715 <  s: String;
715 >  s: AnsiString;
716    i: Integer;
717   begin
718 <  {$ifdef UseCaseInSensitiveParamName}
719 <   s := AnsiUpperCase(Idx);
720 <  {$else}
718 >  if not IsInputDataArea or not CaseSensitiveParams then
719 >   s := AnsiUpperCase(Idx)
720 >  else
721     s := Idx;
722 <  {$endif}
722 >
723    for i := 0 to Count - 1 do
724      if Column[i].Name = s then
725      begin
# Line 705 | Line 730 | begin
730   end;
731  
732   procedure TSQLDataArea.GetData(index: integer; var IsNull: boolean;
733 <  var len: short; var data: PChar);
733 >  var len: short; var data: PByte);
734   begin
735    //Do Nothing
736   end;
# Line 724 | Line 749 | begin
749    Result := FParent.Statement;
750   end;
751  
752 < procedure TSQLVarData.SetName(AValue: string);
752 > procedure TSQLVarData.SetName(AValue: AnsiString);
753   begin
754 <  if FName = AValue then Exit;
730 <  {$ifdef UseCaseInSensitiveParamName}
731 <  if Parent.IsInputDataArea then
754 >  if not Parent.IsInputDataArea or not Parent.CaseSensitiveParams then
755      FName := AnsiUpperCase(AValue)
756    else
734  {$endif}
757      FName := AValue;
758   end;
759  
760 + procedure TSQLVarData.SetMetaSize(aValue: cardinal);
761 + begin
762 +  //Ignore
763 + end;
764 +
765 + procedure TSQLVarData.SaveMetaData;
766 + begin
767 +  FColMetaData := TSQLParamMetaData.Create(self);
768 + end;
769 +
770   constructor TSQLVarData.Create(aParent: TSQLDataArea; aIndex: integer);
771   begin
772    inherited Create;
# Line 743 | Line 775 | begin
775    FUniqueName := true;
776   end;
777  
778 < procedure TSQLVarData.SetString(aValue: string);
778 > procedure TSQLVarData.SetString(aValue: AnsiString);
779   begin
780    {we take full advantage here of reference counted strings. When setting a string
781     value, a reference is kept in FVarString and a pointer to it placed in the
782 <   SQLVar. This avoids string copies. Note that PChar is guaranteed to point to
782 >   SQLVar. This avoids string copies. Note that PAnsiChar is guaranteed to point to
783     a zero byte when the string is empty, neatly avoiding a nil pointer error.}
784  
785    FVarString := aValue;
786 <  SQLType := SQL_TEXT;
787 <  SetSQLData(PChar(FVarString),Length(aValue));
786 >  if SQLType = SQL_BLOB then
787 >    SetMetaSize(GetAttachment.GetInlineBlobLimit);
788 >  SQLType := GetDefaultTextSQLType;
789 >  Scale := 0;
790 >  SetSQLData(PByte(PAnsiChar(FVarString)),Length(aValue));
791   end;
792  
793   procedure TSQLVarData.Changed;
# Line 766 | Line 801 | begin
801    FVarString := '';
802   end;
803  
804 + function TSQLVarData.getColMetadata: IParamMetaData;
805 + begin
806 +  Result := FColMetaData;
807 + end;
808 +
809   procedure TSQLVarData.Initialize;
810  
811 <  function FindVarByName(idx: string; limit: integer): TSQLVarData;
811 >  function FindVarByName(idx: AnsiString; limit: integer): TSQLVarData;
812    var
813      k: integer;
814    begin
# Line 783 | Line 823 | procedure TSQLVarData.Initialize;
823  
824   var
825    j, j_len: Integer;
826 <  st: String;
827 <  sBaseName: string;
826 >  st: AnsiString;
827 >  sBaseName: AnsiString;
828   begin
829    RowChange;
830  
# Line 871 | Line 911 | function TSQLDataItem.AdjustScaleToCurre
911   var
912    Scaling : Int64;
913    i : Integer;
914 <  FractionText, PadText, CurrText: string;
914 >  FractionText, PadText, CurrText: AnsiString;
915   begin
916    Result := 0;
917    Scaling := 1;
# Line 890 | Line 930 | begin
930        FractionText := IntToStr(abs(Value mod Scaling));
931        for i := Length(FractionText) to -aScale -1 do
932          PadText := '0' + PadText;
933 +      {$IF declared(DefaultFormatSettings)}
934 +      with DefaultFormatSettings do
935 +      {$ELSE}
936 +      {$IF declared(FormatSettings)}
937 +      with FormatSettings do
938 +      {$IFEND}
939 +      {$IFEND}
940        if Value < 0 then
941 <        CurrText := '-' + IntToStr(Abs(Value div Scaling)) + DefaultFormatSettings.DecimalSeparator + PadText + FractionText
941 >        CurrText := '-' + IntToStr(Abs(Value div Scaling)) + DecimalSeparator + PadText + FractionText
942        else
943 <        CurrText := IntToStr(Abs(Value div Scaling)) + DefaultFormatSettings.DecimalSeparator + PadText + FractionText;
943 >        CurrText := IntToStr(Abs(Value div Scaling)) + DecimalSeparator + PadText + FractionText;
944        try
945          result := StrToCurr(CurrText);
946        except
# Line 905 | Line 952 | begin
952        result := Value;
953   end;
954  
955 + function TSQLDataItem.GetDateFormatStr(IncludeTime: boolean): AnsiString;
956 + begin
957 +  {$IF declared(DefaultFormatSettings)}
958 +  with DefaultFormatSettings do
959 +  {$ELSE}
960 +  {$IF declared(FormatSettings)}
961 +  with FormatSettings do
962 +  {$IFEND}
963 +  {$IFEND}
964 +  case GetSQLDialect of
965 +    1:
966 +      if IncludeTime then
967 +        result := ShortDateFormat + ' ' + LongTimeFormat
968 +      else
969 +        result := ShortDateFormat;
970 +    3:
971 +      result := ShortDateFormat;
972 +  end;
973 + end;
974 +
975 + function TSQLDataItem.GetTimeFormatStr: AnsiString;
976 + begin
977 +  {$IF declared(DefaultFormatSettings)}
978 +  with DefaultFormatSettings do
979 +  {$ELSE}
980 +  {$IF declared(FormatSettings)}
981 +  with FormatSettings do
982 +  {$IFEND}
983 +  {$IFEND}
984 +    Result := 'hh' + TimeSeparator + 'nn' + TimeSeparator + 'ss' + '.zzzz';;
985 + end;
986 +
987 + function TSQLDataItem.GetTimestampFormatStr: AnsiString;
988 + begin
989 +  {$IF declared(DefaultFormatSettings)}
990 +  with DefaultFormatSettings do
991 +  {$ELSE}
992 +  {$IF declared(FormatSettings)}
993 +  with FormatSettings do
994 +  {$IFEND}
995 +  {$IFEND}
996 +    Result := ShortDateFormat + ' ' +  'hh' + TimeSeparator + 'nn' + TimeSeparator + 'ss' + '.zzzz';
997 + end;
998 +
999   procedure TSQLDataItem.SetAsInteger(AValue: Integer);
1000   begin
1001    SetAsLong(aValue);
1002   end;
1003  
1004 + procedure TSQLDataItem.InternalGetAsDateTime(var aDateTime: TDateTime;
1005 +  var dstOffset: smallint; var aTimezone: AnsiString;
1006 +  var aTimeZoneID: TFBTimeZoneID);
1007 + begin
1008 +  CheckActive;
1009 +  aDateTime := 0;
1010 +  dstOffset := 0;
1011 +  aTimezone := '';
1012 +  aTimeZoneID := TimeZoneID_GMT;
1013 +  if not IsNull then
1014 +    with FFirebirdClientAPI do
1015 +    case SQLType of
1016 +      SQL_TEXT, SQL_VARYING:
1017 +        if not ParseDateTimeTZString(AsString,aDateTime,aTimeZone) then
1018 +          IBError(ibxeInvalidDataConversion, [nil]);
1019 +      SQL_TYPE_DATE:
1020 +        aDateTime := SQLDecodeDate(SQLData);
1021 +      SQL_TYPE_TIME:
1022 +        aDateTime := SQLDecodeTime(SQLData);
1023 +      SQL_TIMESTAMP:
1024 +        aDateTime := SQLDecodeDateTime(SQLData);
1025 +      SQL_TIMESTAMP_TZ:
1026 +        begin
1027 +          GetTimeZoneServices.DecodeTimestampTZ(SQLData,aDateTime,dstOffset,aTimeZone);
1028 +          aTimeZoneID := PISC_TIMESTAMP_TZ(SQLData)^.time_zone;
1029 +        end;
1030 +      SQL_TIMESTAMP_TZ_EX:
1031 +      begin
1032 +        GetTimeZoneServices.DecodeTimestampTZEx(SQLData,aDateTime,dstOffset,aTimeZone);
1033 +        aTimeZoneID := PISC_TIMESTAMP_TZ_EX(SQLData)^.time_zone;
1034 +      end;
1035 +      SQL_TIME_TZ:
1036 +        with GetTimeZoneServices do
1037 +        begin
1038 +          DecodeTimeTZ(SQLData,GetTimeTZDate,aDateTime,dstOffset,aTimeZone);
1039 +          aTimeZoneID := PISC_TIME_TZ(SQLData)^.time_zone;
1040 +        end;
1041 +      SQL_TIME_TZ_EX:
1042 +        with GetTimeZoneServices do
1043 +        begin
1044 +          DecodeTimeTZEx(SQLData,GetTimeTZDate,aDateTime,dstOffset,aTimeZone);
1045 +          aTimeZoneID := PISC_TIME_TZ_EX(SQLData)^.time_zone;
1046 +        end;
1047 +      else
1048 +        IBError(ibxeInvalidDataConversion, [nil]);
1049 +    end;
1050 + end;
1051 +
1052   function TSQLDataItem.AdjustScaleFromCurrency(Value: Currency; aScale: Integer
1053    ): Int64;
1054   var
# Line 958 | Line 1097 | begin
1097    end
1098    else
1099      result := trunc(Value);
1100 + //  writeln('Adjusted ',Value,' to ',Result);
1101   end;
1102  
1103   procedure TSQLDataItem.CheckActive;
# Line 965 | Line 1105 | begin
1105    //Do nothing by default
1106   end;
1107  
1108 + procedure TSQLDataItem.CheckTZSupport;
1109 + begin
1110 +  if not FFirebirdClientAPI.HasTimeZoneSupport then
1111 +    IBError(ibxeNoTimezoneSupport,[]);
1112 + end;
1113 +
1114 + function TSQLDataItem.GetTimeZoneServices: IExTimeZoneServices;
1115 + begin
1116 +  if FTimeZoneServices = nil then
1117 +  begin
1118 +    if not GetAttachment.HasTimeZoneSupport then
1119 +      IBError(ibxeNoTimezoneSupport,[]);
1120 +    GetAttachment.GetTimeZoneServices.QueryInterface(IExTimeZoneServices,FTimeZoneServices);
1121 +  end;
1122 +  Result := FTimeZoneServices;
1123 + end;
1124 +
1125   procedure TSQLDataItem.Changed;
1126   begin
1127    //Do nothing by default
# Line 975 | Line 1132 | begin
1132    //Do nothing by default
1133   end;
1134  
1135 < procedure TSQLDataItem.InternalSetAsString(Value: String);
1135 > procedure TSQLDataItem.InternalSetAsString(Value: AnsiString);
1136   begin
1137    //Do nothing by default
1138   end;
1139  
1140 < function TSQLDataItem.Transliterate(s: string; CodePage: TSystemCodePage
1140 > function TSQLDataItem.Transliterate(s: AnsiString; CodePage: TSystemCodePage
1141    ): RawByteString;
1142   begin
1143    Result := s;
# Line 1003 | Line 1160 | begin
1160     //Do nothing by default
1161   end;
1162  
1163 < function TSQLDataItem.GetSQLTypeName: string;
1163 > constructor TSQLDataItem.Create(api: TFBClientAPI);
1164 > begin
1165 >  inherited Create;
1166 >  FFirebirdClientAPI := api;
1167 > end;
1168 >
1169 > function TSQLDataItem.GetSQLTypeName: AnsiString;
1170   begin
1171    Result := GetSQLTypeName(GetSQLType);
1172   end;
1173  
1174 < class function TSQLDataItem.GetSQLTypeName(SQLType: short): string;
1174 > class function TSQLDataItem.GetSQLTypeName(SQLType: cardinal): AnsiString;
1175   begin
1176    Result := 'Unknown';
1177    case SQLType of
# Line 1019 | Line 1182 | begin
1182    SQL_LONG:             Result := 'SQL_LONG';
1183    SQL_SHORT:            Result := 'SQL_SHORT';
1184    SQL_TIMESTAMP:        Result := 'SQL_TIMESTAMP';
1185 +  SQL_TIMESTAMP_TZ:     Result := 'SQL_TIMESTAMP_TZ';
1186 +  SQL_TIMESTAMP_TZ_EX:  Result := 'SQL_TIMESTAMP_TZ_EX';
1187    SQL_BLOB:             Result := 'SQL_BLOB';
1188    SQL_D_FLOAT:          Result := 'SQL_D_FLOAT';
1189    SQL_ARRAY:            Result := 'SQL_ARRAY';
# Line 1026 | Line 1191 | begin
1191    SQL_TYPE_TIME:        Result := 'SQL_TYPE_TIME';
1192    SQL_TYPE_DATE:        Result := 'SQL_TYPE_DATE';
1193    SQL_INT64:            Result := 'SQL_INT64';
1194 +  SQL_TIME_TZ:          Result := 'SQL_TIME_TZ';
1195 +  SQL_TIME_TZ_EX:       Result := 'SQL_TIME_TZ_EX';
1196 +  SQL_DEC_FIXED:        Result := 'SQL_DEC_FIXED';
1197 +  SQL_DEC16:            Result := 'SQL_DEC16';
1198 +  SQL_DEC34:            Result := 'SQL_DEC34';
1199 +  SQL_INT128:           Result := 'SQL_INT128';
1200 +  SQL_NULL:             Result := 'SQL_NULL';
1201 +  SQL_BOOLEAN:          Result := 'SQL_BOOLEAN';
1202    end;
1203   end;
1204  
1205 + function TSQLDataItem.GetStrDataLength: short;
1206 + begin
1207 +  with FFirebirdClientAPI do
1208 +  if SQLType = SQL_VARYING then
1209 +    Result := DecodeInteger(SQLData, 2)
1210 +  else
1211 +    Result := DataLength;
1212 + end;
1213 +
1214   function TSQLDataItem.GetAsBoolean: boolean;
1215   begin
1216    CheckActive;
# Line 1068 | Line 1250 | begin
1250            result := AdjustScaleToCurrency(PInt64(SQLData)^,
1251                                        Scale);
1252          SQL_DOUBLE, SQL_FLOAT, SQL_D_FLOAT:
1253 <          result := Trunc(AsDouble);
1253 >          result := Round(AsDouble);
1254 >
1255 >        SQL_DEC_FIXED,
1256 >        SQL_DEC16,
1257 >        SQL_DEC34,
1258 >        SQL_INT128:
1259 >          if not BCDToCurr(GetAsBCD,Result) then
1260 >            IBError(ibxeInvalidDataConversion, [nil]);
1261 >
1262          else
1263            IBError(ibxeInvalidDataConversion, [nil]);
1264        end;
# Line 1098 | Line 1288 | begin
1288          result := AdjustScaleToInt64(PInt64(SQLData)^,
1289                                      Scale);
1290        SQL_DOUBLE, SQL_FLOAT, SQL_D_FLOAT:
1291 <        result := Trunc(AsDouble);
1291 >        result := Round(AsDouble);
1292        else
1293          IBError(ibxeInvalidDataConversion, [nil]);
1294      end;
1295   end;
1296  
1297   function TSQLDataItem.GetAsDateTime: TDateTime;
1298 + var aTimezone: AnsiString;
1299 +    aTimeZoneID: TFBTimeZoneID;
1300 +    dstOffset: smallint;
1301 + begin
1302 +  InternalGetAsDateTime(Result,dstOffset,aTimeZone,aTimeZoneID);
1303 + end;
1304 +
1305 + procedure TSQLDataItem.GetAsDateTime(var aDateTime: TDateTime;
1306 +  var dstOffset: smallint; var aTimezone: AnsiString);
1307 + var aTimeZoneID: TFBTimeZoneID;
1308 + begin
1309 +  InternalGetAsDateTime(aDateTime,dstOffset,aTimeZone,aTimeZoneID);
1310 + end;
1311 +
1312 + procedure TSQLDataItem.GetAsDateTime(var aDateTime: TDateTime; var dstOffset: smallint;
1313 +  var aTimezoneID: TFBTimeZoneID);
1314 + var aTimezone: AnsiString;
1315 + begin
1316 +  InternalGetAsDateTime(aDateTime,dstOffset,aTimeZone,aTimeZoneID);
1317 + end;
1318 +
1319 + procedure TSQLDataItem.GetAsTime(var aTime: TDateTime; var dstOffset: smallint;
1320 +  var aTimezoneID: TFBTimeZoneID; OnDate: TDateTime);
1321 + var aTimeZone: AnsiString;
1322   begin
1323    CheckActive;
1324 <  result := 0;
1324 >  aTime := 0;
1325 >  dstOffset := 0;
1326    if not IsNull then
1327 <    with FirebirdClientAPI do
1327 >    with FFirebirdClientAPI do
1328      case SQLType of
1329 <      SQL_TEXT, SQL_VARYING: begin
1330 <        try
1331 <          result := StrToDate(AsString);
1332 <        except
1333 <          on E: EConvertError do IBError(ibxeInvalidDataConversion, [nil]);
1329 >      SQL_TIME_TZ:
1330 >        begin
1331 >          GetTimeZoneServices.DecodeTimeTZ(SQLData,OnDate,aTime,dstOffset,aTimeZone);
1332 >          aTimeZoneID := PISC_TIME_TZ(SQLData)^.time_zone;
1333 >        end;
1334 >      SQL_TIME_TZ_EX:
1335 >        begin
1336 >          GetTimeZoneServices.DecodeTimeTZEx(SQLData,OnDate,aTime,dstOffset,aTimeZone);
1337 >          aTimeZoneID := PISC_TIME_TZ_EX(SQLData)^.time_zone;
1338          end;
1339 +    else
1340 +      IBError(ibxeInvalidDataConversion, [nil]);
1341 +    end;
1342 + end;
1343 +
1344 + procedure TSQLDataItem.GetAsTime(var aTime: TDateTime; var dstOffset: smallint;
1345 +  var aTimezone: AnsiString; OnDate: TDateTime);
1346 + begin
1347 +  CheckActive;
1348 +  aTime := 0;
1349 +  dstOffset := 0;
1350 +  if not IsNull then
1351 +    with FFirebirdClientAPI do
1352 +    case SQLType of
1353 +      SQL_TIME_TZ:
1354 +        GetTimeZoneServices.DecodeTimeTZ(SQLData,OnDate,aTime,dstOffset,aTimeZone);
1355 +      SQL_TIME_TZ_EX:
1356 +        GetTimeZoneServices.DecodeTimeTZEx(SQLData,OnDate,aTime,dstOffset,aTimeZone);
1357 +    else
1358 +      IBError(ibxeInvalidDataConversion, [nil]);
1359 +    end;
1360 + end;
1361 +
1362 + procedure TSQLDataItem.GetAsTime(var aTime: TDateTime; var dstOffset: smallint;
1363 +  var aTimezoneID: TFBTimeZoneID);
1364 + begin
1365 +  GetAsTime(aTime,dstOffset,aTimeZoneID,GetTimeZoneServices.GetTimeTZDate);
1366 + end;
1367 +
1368 + procedure TSQLDataItem.GetAsTime(var aTime: TDateTime; var dstOffset: smallint;
1369 +  var aTimezone: AnsiString);
1370 + begin
1371 +  GetAsTime(aTime,dstOffset,aTimeZone,GetTimeZoneServices.GetTimeTZDate);
1372 + end;
1373 +
1374 + function TSQLDataItem.GetAsUTCDateTime: TDateTime;
1375 + var aTimezone: AnsiString;
1376 + begin
1377 +  CheckActive;
1378 +  result := 0;
1379 +  aTimezone := '';
1380 +  if not IsNull then
1381 +    with FFirebirdClientAPI do
1382 +    case SQLType of
1383 +      SQL_TEXT, SQL_VARYING:
1384 +      begin
1385 +        if not ParseDateTimeTZString(AsString,Result,aTimeZone) then
1386 +          IBError(ibxeInvalidDataConversion, [nil]);
1387 +        Result := GetTimeZoneServices.LocalTimeToGMT(Result,aTimeZone);
1388        end;
1389        SQL_TYPE_DATE:
1390          result := SQLDecodeDate(SQLData);
1391 <      SQL_TYPE_TIME:
1391 >      SQL_TYPE_TIME,
1392 >      SQL_TIME_TZ,
1393 >      SQL_TIME_TZ_EX:
1394          result := SQLDecodeTime(SQLData);
1395 <      SQL_TIMESTAMP:
1395 >      SQL_TIMESTAMP,
1396 >      SQL_TIMESTAMP_TZ,
1397 >      SQL_TIMESTAMP_TZ_EX:
1398          result := SQLDecodeDateTime(SQLData);
1399        else
1400          IBError(ibxeInvalidDataConversion, [nil]);
1401 <    end;
1401 >      end;
1402   end;
1403  
1404   function TSQLDataItem.GetAsDouble: Double;
# Line 1154 | Line 1426 | begin
1426          result := PFloat(SQLData)^;
1427        SQL_DOUBLE, SQL_D_FLOAT:
1428          result := PDouble(SQLData)^;
1429 +      SQL_DEC_FIXED,
1430 +      SQL_DEC16,
1431 +      SQL_DEC34,
1432 +      SQL_INT128:
1433 +        Result := BCDToDouble(GetAsBCD);
1434        else
1435          IBError(ibxeInvalidDataConversion, [nil]);
1436      end;
# Line 1190 | Line 1467 | begin
1467          end;
1468        end;
1469        SQL_SHORT:
1470 <        result := Trunc(AdjustScale(Int64(PShort(SQLData)^),
1470 >        result := Round(AdjustScale(Int64(PShort(SQLData)^),
1471                                      Scale));
1472        SQL_LONG:
1473 <        result := Trunc(AdjustScale(Int64(PLong(SQLData)^),
1473 >        result := Round(AdjustScale(Int64(PLong(SQLData)^),
1474                                      Scale));
1475        SQL_INT64:
1476 <        result := Trunc(AdjustScale(PInt64(SQLData)^, Scale));
1476 >        result := Round(AdjustScale(PInt64(SQLData)^, Scale));
1477        SQL_DOUBLE, SQL_FLOAT, SQL_D_FLOAT:
1478 <        result := Trunc(AsDouble);
1478 >        result := Round(AsDouble);
1479 >      SQL_DEC_FIXED,
1480 >      SQL_DEC16,
1481 >      SQL_DEC34,
1482 >      SQL_INT128:
1483 >        Result := BCDToInteger(GetAsBCD);
1484        else
1485 <        IBError(ibxeInvalidDataConversion, [nil]);
1485 >        IBError(ibxeInvalidDataConversion, [GetSQLTypeName]);
1486      end;
1487   end;
1488  
# Line 1238 | Line 1520 | begin
1520    end;
1521   end;
1522  
1523 + {Copied from LazUTF8}
1524 +
1525 + function UTF8CodepointSizeFull(p: PAnsiChar): integer;
1526 + const TopBitSetMask   = $80; {%10000000}
1527 +      Top2BitsSetMask = $C0; {%11000000}
1528 +      Top3BitsSetMask = $E0; {%11100000}
1529 +      Top4BitsSetMask = $F0; {%11110000}
1530 +      Top5BitsSetMask = $F8; {%11111000}
1531 + begin
1532 +  case p^ of
1533 +  #0..#191: // %11000000
1534 +    // regular single byte character (#0 is a character, this is Pascal ;)
1535 +    Result:=1;
1536 +  #192..#223: // p^ and %11100000 = %11000000
1537 +    begin
1538 +      // could be 2 byte character
1539 +      if (ord(p[1]) and Top2BitsSetMask) = TopBitSetMask then
1540 +        Result:=2
1541 +      else
1542 +        Result:=1;
1543 +    end;
1544 +  #224..#239: // p^ and %11110000 = %11100000
1545 +    begin
1546 +      // could be 3 byte character
1547 +      if ((ord(p[1]) and Top2BitsSetMask) = TopBitSetMask)
1548 +      and ((ord(p[2]) and Top2BitsSetMask) = TopBitSetMask) then
1549 +        Result:=3
1550 +      else
1551 +        Result:=1;
1552 +    end;
1553 +  #240..#247: // p^ and %11111000 = %11110000
1554 +    begin
1555 +      // could be 4 byte character
1556 +      if ((ord(p[1]) and Top2BitsSetMask) = TopBitSetMask)
1557 +      and ((ord(p[2]) and Top2BitsSetMask) = TopBitSetMask)
1558 +      and ((ord(p[3]) and Top2BitsSetMask) = TopBitSetMask) then
1559 +        Result:=4
1560 +      else
1561 +        Result:=1;
1562 +    end;
1563 +  else
1564 +    Result:=1;
1565 +  end;
1566 + end;
1567 +
1568 + {Returns the byte length of a UTF8 string with a fixed charwidth}
1569  
1570 < function TSQLDataItem.GetAsString: String;
1570 > function GetStrLen(p: PAnsiChar; FieldWidth, MaxDataLength: cardinal): integer;
1571 > var i: integer;
1572 >    cplen: integer;
1573 >    s: AnsiString;
1574 > begin
1575 >  Result := 0;
1576 >  s := strpas(p);
1577 >  for i := 1 to FieldWidth do
1578 >  begin
1579 >    cplen := UTF8CodepointSizeFull(p);
1580 >    Inc(p,cplen);
1581 >    Inc(Result,cplen);
1582 >    if Result >= MaxDataLength then
1583 >    begin
1584 >      Result := MaxDataLength;
1585 >      Exit;
1586 >    end;
1587 >  end;
1588 > end;
1589 >
1590 > function TSQLDataItem.GetAsString: AnsiString;
1591   var
1592 <  sz: PChar;
1592 >  sz: PByte;
1593    str_len: Integer;
1594    rs: RawByteString;
1595 +  aTimeZone: AnsiString;
1596 +  aDateTime: TDateTime;
1597 +  dstOffset: smallint;
1598   begin
1599    CheckActive;
1600    result := '';
1601    { Check null, if so return a default string }
1602    if not IsNull then
1603 <  with FirebirdClientAPI do
1603 >  with FFirebirdClientAPI do
1604      case SQLType of
1605        SQL_BOOLEAN:
1606          if AsBoolean then
# Line 1261 | Line 1612 | begin
1612        begin
1613          sz := SQLData;
1614          if (SQLType = SQL_TEXT) then
1615 <          str_len := DataLength
1615 >        begin
1616 >          if GetCodePage = cp_utf8 then
1617 >            str_len := GetStrLen(PAnsiChar(sz),GetSize div GetCharSetWidth,DataLength)
1618 >          else
1619 >            str_len := DataLength
1620 >        end
1621          else begin
1622 <          str_len := DecodeInteger(SQLData, 2);
1622 >          str_len := DecodeInteger(sz, 2);
1623            Inc(sz, 2);
1624          end;
1625 <        SetString(rs, sz, str_len);
1625 >        SetString(rs, PAnsiChar(sz), str_len);
1626          SetCodePage(rs,GetCodePage,false);
1627 <        Result := Trim(rs);
1627 >        Result := rs;
1628        end;
1629 +
1630        SQL_TYPE_DATE:
1631 <        case GetSQLDialect of
1275 <          1 : result := DateTimeToStr(AsDateTime);
1276 <          3 : result := DateToStr(AsDateTime);
1277 <        end;
1278 <      SQL_TYPE_TIME :
1279 <        result := TimeToStr(AsDateTime);
1631 >        Result := DateToStr(GetAsDateTime);
1632        SQL_TIMESTAMP:
1633 <        result := FormatDateTime(FormatSettings.ShortDateFormat + ' ' +
1634 <                            FormatSettings.LongTimeFormat+'.zzz',AsDateTime);
1633 >        Result := FBFormatDateTime(GetTimestampFormatStr,GetAsDateTime);
1634 >      SQL_TYPE_TIME:
1635 >        Result := FBFormatDateTime(GetTimeFormatStr,GetAsDateTime);
1636 >      SQL_TIMESTAMP_TZ,
1637 >      SQL_TIMESTAMP_TZ_EX:
1638 >        with GetAttachment.GetTimeZoneServices do
1639 >        begin
1640 >          if GetTZTextOption = tzGMT then
1641 >            Result := FBFormatDateTime(GetTimestampFormatStr,GetAsUTCDateTime)
1642 >          else
1643 >          begin
1644 >            GetAsDateTime(aDateTime,dstOffset,aTimeZone);
1645 >            if GetTZTextOption = tzOffset then
1646 >              Result := FBFormatDateTime(GetTimestampFormatStr,aDateTime) + ' ' + FormatTimeZoneOffset(dstOffset)
1647 >            else
1648 >              Result := FBFormatDateTime(GetTimestampFormatStr,aDateTime) + ' ' + aTimeZone;
1649 >          end;
1650 >        end;
1651 >      SQL_TIME_TZ,
1652 >      SQL_TIME_TZ_EX:
1653 >        with GetAttachment.GetTimeZoneServices do
1654 >        begin
1655 >          if GetTZTextOption = tzGMT then
1656 >             Result := FBFormatDateTime(GetTimeFormatStr,GetAsUTCDateTime)
1657 >          else
1658 >          begin
1659 >            GetAsTime(aDateTime,dstOffset,aTimeZone,GetTimeTZDate);
1660 >            if GetTZTextOption = tzOffset then
1661 >              Result := FBFormatDateTime(GetTimeFormatStr,aDateTime) + ' ' + FormatTimeZoneOffset(dstOffset)
1662 >            else
1663 >              Result := FBFormatDateTime(GetTimeFormatStr,aDateTime) + ' ' + aTimeZone;
1664 >          end;
1665 >        end;
1666 >
1667        SQL_SHORT, SQL_LONG:
1668          if Scale = 0 then
1669            result := IntToStr(AsLong)
# Line 1296 | Line 1680 | begin
1680            result := FloatToStr(AsDouble);
1681        SQL_DOUBLE, SQL_FLOAT, SQL_D_FLOAT:
1682          result := FloatToStr(AsDouble);
1683 +
1684 +      SQL_DEC16,
1685 +      SQL_DEC34:
1686 +        result := BCDToStr(GetAsBCD);
1687 +
1688 +      SQL_DEC_FIXED,
1689 +      SQL_INT128:
1690 +        result := Int128ToStr(SQLData,scale);
1691 +
1692        else
1693          IBError(ibxeInvalidDataConversion, [nil]);
1694      end;
# Line 1307 | Line 1700 | begin
1700    Result := false;
1701   end;
1702  
1703 < function TSQLDataItem.getIsNullable: boolean;
1703 > function TSQLDataItem.GetIsNullable: boolean;
1704   begin
1705    CheckActive;
1706    Result := false;
1707   end;
1708  
1709   function TSQLDataItem.GetAsVariant: Variant;
1710 + var ts: TDateTime;
1711 +  dstOffset: smallint;
1712 +    timezone: AnsiString;
1713   begin
1714    CheckActive;
1715    if IsNull then
# Line 1327 | Line 1723 | begin
1723          result := AsString;
1724        SQL_TIMESTAMP, SQL_TYPE_DATE, SQL_TYPE_TIME:
1725          result := AsDateTime;
1726 +      SQL_TIMESTAMP_TZ,
1727 +      SQL_TIME_TZ,
1728 +      SQL_TIMESTAMP_TZ_EX,
1729 +      SQL_TIME_TZ_EX:
1730 +        begin
1731 +          GetAsDateTime(ts,dstOffset,timezone);
1732 +          result := VarArrayOf([ts,dstOffset,timezone]);
1733 +        end;
1734        SQL_SHORT, SQL_LONG:
1735          if Scale = 0 then
1736            result := AsLong
# Line 1345 | Line 1749 | begin
1749          result := AsDouble;
1750        SQL_BOOLEAN:
1751          result := AsBoolean;
1752 +      SQL_DEC_FIXED,
1753 +      SQL_DEC16,
1754 +      SQL_DEC34,
1755 +      SQL_INT128:
1756 +        result := VarFmtBCDCreate(GetAsBcd);
1757        else
1758          IBError(ibxeInvalidDataConversion, [nil]);
1759      end;
# Line 1355 | Line 1764 | begin
1764    Result := false;
1765   end;
1766  
1767 + function TSQLDataItem.GetDateTimeStrLength(DateTimeFormat: TIBDateTimeFormats
1768 +  ): integer;
1769 + begin
1770 +  case DateTimeFormat of
1771 +  dfTimestamp:
1772 +    Result := Length(GetTimestampFormatStr);
1773 +  dfDateTime:
1774 +    Result := Length(GetDateFormatStr(true));
1775 +  dfTime:
1776 +    Result := Length(GetTimeFormatStr);
1777 +  dfTimestampTZ:
1778 +    Result := Length(GetTimestampFormatStr) + 6; {assume time offset format}
1779 +  dfTimeTZ:
1780 +    Result := Length(GetTimeFormatStr)+ 6;
1781 +  else
1782 +    Result := 0;
1783 +  end;end;
1784 +
1785 + function TSQLDataItem.GetAsBCD: tBCD;
1786 +
1787 + begin
1788 +  CheckActive;
1789 +  if IsNull then
1790 +   with Result do
1791 +   begin
1792 +     FillChar(Result,sizeof(Result),0);
1793 +     Precision := 1;
1794 +     exit;
1795 +   end;
1796 +
1797 +  case SQLType of
1798 +  SQL_DEC16,
1799 +  SQL_DEC34:
1800 +    with FFirebirdClientAPI do
1801 +      Result := SQLDecFloatDecode(SQLType,  SQLData);
1802 +
1803 +  SQL_DEC_FIXED,
1804 +  SQL_INT128:
1805 +    with FFirebirdClientAPI do
1806 +      Result := StrToBCD(Int128ToStr(SQLData,scale));
1807 +  else
1808 +    if not CurrToBCD(GetAsCurrency,Result) then
1809 +      IBError(ibxeBadBCDConversion,[]);
1810 +  end;
1811 + end;
1812 +
1813  
1814   procedure TSQLDataItem.SetIsNull(Value: Boolean);
1815   begin
# Line 1366 | Line 1821 | begin
1821    //ignore unless overridden
1822   end;
1823  
1824 < procedure TSQLDataItem.SetName(aValue: string);
1824 > procedure TSQLDataItem.SetName(aValue: AnsiString);
1825   begin
1826    //ignore unless overridden
1827   end;
# Line 1418 | Line 1873 | begin
1873  
1874    SQLType := SQL_TYPE_DATE;
1875    DataLength := SizeOf(ISC_DATE);
1876 <  with FirebirdClientAPI do
1876 >  with FFirebirdClientAPI do
1877      SQLEncodeDate(Value,SQLData);
1878    Changed;
1879   end;
# Line 1438 | Line 1893 | begin
1893  
1894    SQLType := SQL_TYPE_TIME;
1895    DataLength := SizeOf(ISC_TIME);
1896 <  with FirebirdClientAPI do
1896 >  with FFirebirdClientAPI do
1897      SQLEncodeTime(Value,SQLData);
1898    Changed;
1899   end;
1900  
1901 + procedure TSQLDataItem.SetAsTime(aValue: TDateTime; OnDate: TDateTime; aTimeZoneID: TFBTimeZoneID);
1902 + begin
1903 +  CheckActive;
1904 +  CheckTZSupport;
1905 +  if GetSQLDialect < 3 then
1906 +  begin
1907 +    AsDateTime := aValue;
1908 +    exit;
1909 +  end;
1910 +
1911 +  Changing;
1912 +  if IsNullable then
1913 +    IsNull := False;
1914 +
1915 +  SQLType := SQL_TIME_TZ;
1916 +  DataLength := SizeOf(ISC_TIME_TZ);
1917 +  GetTimeZoneServices.EncodeTimeTZ(aValue, aTimeZoneID,OnDate,SQLData);
1918 +  Changed;
1919 + end;
1920 +
1921 + procedure TSQLDataItem.SetAsTime(aValue: TDateTime; OnDate: TDateTime; aTimeZone: AnsiString);
1922 + begin
1923 +  CheckActive;
1924 +  CheckTZSupport;
1925 +  if GetSQLDialect < 3 then
1926 +  begin
1927 +    AsDateTime := aValue;
1928 +    exit;
1929 +  end;
1930 +
1931 +  Changing;
1932 +  if IsNullable then
1933 +    IsNull := False;
1934 +
1935 +  SQLType := SQL_TIME_TZ;
1936 +  DataLength := SizeOf(ISC_TIME_TZ);
1937 +  GetTimeZoneServices.EncodeTimeTZ(aValue, aTimeZone,OnDate,SQLData);
1938 +  Changed;
1939 + end;
1940 +
1941   procedure TSQLDataItem.SetAsDateTime(Value: TDateTime);
1942   begin
1943    CheckActive;
# Line 1451 | Line 1946 | begin
1946  
1947    Changing;
1948    SQLType := SQL_TIMESTAMP;
1949 <  DataLength := SizeOf(TISC_QUAD);
1950 <  with FirebirdClientAPI do
1949 >  DataLength := SizeOf(ISC_TIME) + sizeof(ISC_DATE);
1950 >  with FFirebirdClientAPI do
1951      SQLEncodeDateTime(Value,SQLData);
1952    Changed;
1953   end;
1954  
1955 + procedure TSQLDataItem.SetAsDateTime(aValue: TDateTime;
1956 +  aTimeZoneID: TFBTimeZoneID);
1957 + begin
1958 +  CheckActive;
1959 +  CheckTZSupport;
1960 +  if IsNullable then
1961 +    IsNull := False;
1962 +
1963 +  Changing;
1964 +  SQLType := SQL_TIMESTAMP_TZ;
1965 +  DataLength := SizeOf(ISC_TIMESTAMP_TZ);
1966 +  GetTimeZoneServices.EncodeTimestampTZ(aValue,aTimeZoneID,SQLData);
1967 +  Changed;
1968 + end;
1969 +
1970 + procedure TSQLDataItem.SetAsDateTime(aValue: TDateTime; aTimeZone: AnsiString
1971 +  );
1972 + begin
1973 +  CheckActive;
1974 +  CheckTZSupport;
1975 +  if IsNullable then
1976 +    IsNull := False;
1977 +
1978 +  Changing;
1979 +  SQLType := SQL_TIMESTAMP_TZ;
1980 +  DataLength := SizeOf(ISC_TIMESTAMP_TZ);
1981 +  GetTimeZoneServices.EncodeTimestampTZ(aValue,aTimeZone,SQLData);
1982 +  Changed;
1983 + end;
1984 +
1985 + procedure TSQLDataItem.SetAsUTCDateTime(aUTCTime: TDateTime);
1986 + begin
1987 +  SetAsDateTime(aUTCTime,TimeZoneID_GMT);
1988 + end;
1989 +
1990   procedure TSQLDataItem.SetAsDouble(Value: Double);
1991   begin
1992    CheckActive;
# Line 1542 | Line 2072 | begin
2072    Changed;
2073   end;
2074  
2075 < procedure TSQLDataItem.SetAsString(Value: String);
2075 > procedure TSQLDataItem.SetAsString(Value: AnsiString);
2076   begin
2077    InternalSetAsString(Value);
2078   end;
# Line 1552 | Line 2082 | begin
2082    CheckActive;
2083    if VarIsNull(Value) then
2084      IsNull := True
2085 +  else
2086 +  if VarIsArray(Value) then {must be datetime plus timezone}
2087 +    SetAsDateTime(Value[0],AnsiString(Value[1]))
2088    else case VarType(Value) of
2089      varEmpty, varNull:
2090        IsNull := True;
# Line 1574 | Line 2107 | begin
2107        IBError(ibxeNotSupported, [nil]);
2108      varByRef, varDispatch, varError, varUnknown, varVariant:
2109        IBError(ibxeNotPermitted, [nil]);
2110 +    else
2111 +      if VarIsFmtBCD(Value) then
2112 +        SetAsBCD(VarToBCD(Value))
2113 +      else
2114 +        IBError(ibxeNotSupported, [nil]);
2115    end;
2116   end;
2117  
2118 + procedure TSQLDataItem.SetAsNumeric(Value: Int64; aScale: integer);
2119 + begin
2120 +  CheckActive;
2121 +  Changing;
2122 +  if IsNullable then
2123 +    IsNull := False;
2124 +
2125 +  SQLType := SQL_INT64;
2126 +  Scale := aScale;
2127 +  DataLength := SizeOf(Int64);
2128 +  PInt64(SQLData)^ := Value;
2129 +  Changed;
2130 + end;
2131 +
2132 + procedure TSQLDataItem.SetAsBcd(aValue: tBCD);
2133 + var C: Currency;
2134 + begin
2135 +  CheckActive;
2136 +  Changing;
2137 +  if IsNullable then
2138 +    IsNull := False;
2139 +
2140 +
2141 +  with FFirebirdClientAPI do
2142 +  if aValue.Precision <= 16 then
2143 +  begin
2144 +    if not HasDecFloatSupport then
2145 +      IBError(ibxeDecFloatNotSupported,[]);
2146 +
2147 +    SQLType := SQL_DEC16;
2148 +    DataLength := 8;
2149 +    SQLDecFloatEncode(aValue,SQLType,SQLData);
2150 +  end
2151 +  else
2152 +  if aValue.Precision <= 34 then
2153 +  begin
2154 +    if not HasDecFloatSupport then
2155 +      IBError(ibxeDecFloatNotSupported,[]);
2156 +
2157 +    SQLType := SQL_DEC34;
2158 +    DataLength := 16;
2159 +    SQLDecFloatEncode(aValue,SQLType,SQLData);
2160 +  end
2161 +  else
2162 +  if aValue.Precision <= 38 then
2163 +  begin
2164 +    if not HasInt128Support then
2165 +      IBError(ibxeInt128NotSupported,[]);
2166 +
2167 +    SQLType := SQL_INT128;
2168 +    DataLength := 16;
2169 +    StrToInt128(scale,BcdToStr(aValue),SQLData);
2170 +  end
2171 +  else
2172 +    IBError(ibxeBCDOverflow,[BCDToStr(aValue)]);
2173 +
2174 +  Changed;
2175 + end;
2176 +
2177   procedure TSQLDataItem.SetAsBoolean(AValue: boolean);
2178   begin
2179    CheckActive;
# Line 1607 | Line 2204 | begin
2204      IBError(ibxeStatementNotPrepared, [nil]);
2205   end;
2206  
2207 < function TColumnMetaData.SQLData: PChar;
2207 > function TColumnMetaData.GetAttachment: IAttachment;
2208 > begin
2209 >  Result := GetStatement.GetAttachment;
2210 > end;
2211 >
2212 > function TColumnMetaData.SQLData: PByte;
2213   begin
2214    Result := FIBXSQLVAR.SQLData;
2215   end;
# Line 1624 | Line 2226 | end;
2226  
2227   constructor TColumnMetaData.Create(aOwner: IUnknown; aIBXSQLVAR: TSQLVarData);
2228   begin
2229 <  inherited Create;
2229 >  inherited Create(aIBXSQLVAR.GetStatement.GetAttachment.getFirebirdAPI as TFBClientAPI);
2230    FIBXSQLVAR := aIBXSQLVAR;
2231    FOwner := aOwner;
2232    FPrepareSeqNo := FIBXSQLVAR.Parent.PrepareSeqNo;
# Line 1660 | Line 2262 | begin
2262    result := FIBXSQLVAR.SQLSubtype;
2263   end;
2264  
2265 < function TColumnMetaData.getRelationName: string;
2265 > function TColumnMetaData.getRelationName: AnsiString;
2266   begin
2267    CheckActive;
2268     result :=  FIBXSQLVAR.RelationName;
2269   end;
2270  
2271 < function TColumnMetaData.getOwnerName: string;
2271 > function TColumnMetaData.getOwnerName: AnsiString;
2272   begin
2273    CheckActive;
2274    result :=  FIBXSQLVAR.OwnerName;
2275   end;
2276  
2277 < function TColumnMetaData.getSQLName: string;
2277 > function TColumnMetaData.getSQLName: AnsiString;
2278   begin
2279    CheckActive;
2280    result :=  FIBXSQLVAR.FieldName;
2281   end;
2282  
2283 < function TColumnMetaData.getAliasName: string;
2283 > function TColumnMetaData.getAliasName: AnsiString;
2284   begin
2285    CheckActive;
2286    result := FIBXSQLVAR.AliasName;
2287   end;
2288  
2289 < function TColumnMetaData.GetName: string;
2289 > function TColumnMetaData.GetName: AnsiString;
2290   begin
2291    CheckActive;
2292    Result := FIBXSQLVAR. Name;
# Line 1711 | Line 2313 | end;
2313   function TColumnMetaData.GetSize: cardinal;
2314   begin
2315    CheckActive;
2316 <  result := FIBXSQLVAR.DataLength;
2316 >  result := FIBXSQLVAR.GetSize;
2317 > end;
2318 >
2319 > function TColumnMetaData.GetCharSetWidth: integer;
2320 > begin
2321 >  CheckActive;
2322 >  result := FIBXSQLVAR.GetCharSetWidth;
2323   end;
2324  
2325   function TColumnMetaData.GetArrayMetaData: IArrayMetaData;
# Line 1726 | Line 2334 | begin
2334    result := FIBXSQLVAR.GetBlobMetaData;
2335   end;
2336  
2337 + function TColumnMetaData.GetStatement: IStatement;
2338 + begin
2339 +  Result := FIBXSQLVAR.GetStatement;
2340 + end;
2341 +
2342 + function TColumnMetaData.GetTransaction: ITransaction;
2343 + begin
2344 +  Result := GetStatement.GetTransaction;
2345 + end;
2346 +
2347   { TIBSQLData }
2348  
2349   procedure TIBSQLData.CheckActive;
# Line 1745 | Line 2363 | begin
2363      IBError(ibxeBOF,[nil]);
2364   end;
2365  
2366 + function TIBSQLData.GetTransaction: ITransaction;
2367 + begin
2368 +  if FTransaction = nil then
2369 +    Result := inherited GetTransaction
2370 +  else
2371 +    Result := FTransaction;
2372 + end;
2373 +
2374   function TIBSQLData.GetIsNull: Boolean;
2375   begin
2376    CheckActive;
# Line 1769 | Line 2395 | begin
2395    result := FIBXSQLVAR.GetAsBlob(AsQuad,BPB);
2396   end;
2397  
2398 < function TIBSQLData.GetAsString: String;
2398 > function TIBSQLData.GetAsString: AnsiString;
2399   begin
2400    CheckActive;
2401    Result := '';
# Line 1777 | Line 2403 | begin
2403    if not IsNull then
2404    case SQLType of
2405      SQL_ARRAY:
2406 <      result := '(Array)'; {do not localize}
2406 >      result := SArray;
2407      SQL_BLOB:
2408 <      Result := Trim(FIBXSQLVAR.GetAsBlob(AsQuad,nil).GetAsString);
2408 >      Result := FIBXSQLVAR.GetAsBlob(AsQuad,nil).GetAsString;
2409      else
2410        Result := inherited GetAsString;
2411    end;
# Line 1787 | Line 2413 | end;
2413  
2414   { TSQLParam }
2415  
2416 < procedure TSQLParam.InternalSetAsString(Value: String);
2416 > procedure TSQLParam.InternalSetAsString(Value: AnsiString);
2417 >
2418 > procedure DoSetString;
2419 > begin
2420 >  Changing;
2421 >  FIBXSQLVar.SetString(Transliterate(Value,GetCodePage));
2422 >  Changed;
2423 > end;
2424 >
2425 > function TryStrToNumeric(S: Ansistring; out Value: int64; out scale: integer): boolean;
2426 > var i: integer;
2427 >    ds: integer;
2428 > begin
2429 >  Result := false;
2430 >  ds := 0;
2431 >  S := Trim(S);
2432 >  {$IF declared(DefaultFormatSettings)}
2433 >  with DefaultFormatSettings do
2434 >  {$ELSE}
2435 >  {$IF declared(FormatSettings)}
2436 >  with FormatSettings do
2437 >  {$IFEND}
2438 >  {$IFEND}
2439 >  begin
2440 >    {ThousandSeparator not allowed as by Delphi specs}
2441 >    if (ThousandSeparator <> DecimalSeparator) and
2442 >       (Pos(ThousandSeparator, S) <> 0) then
2443 >        Exit;
2444 >
2445 >    for i := length(S) downto 1 do
2446 >    begin
2447 >      if S[i] = AnsiChar(DecimalSeparator) then
2448 >      begin
2449 >          if ds <> 0 then Exit; {only one allowed}
2450 >          ds := i-1;
2451 >          system.Delete(S,i,1);
2452 >      end
2453 >      else
2454 >      if (i > 1) and (S[i] in ['+','-']) then
2455 >        Exit
2456 >      else
2457 >      if not (S[i] in ['0'..'9']) then
2458 >          Exit; {bad character}
2459 >
2460 >    end;
2461 >    if ds = 0 then
2462 >      scale := 0
2463 >    else
2464 >      scale := ds - Length(S);
2465 >    Result := TryStrToInt64(S,Value);
2466 >  end;
2467 > end;
2468 >
2469   var b: IBlob;
2470 +    dt: TDateTime;
2471 +    timezone: AnsiString;
2472 +    {$ifdef FPC_HAS_TYPE_EXTENDED}
2473 +    FloatValue: Extended;
2474 +    {$else}
2475 +    FloatValue: Double;
2476 +    {$endif}
2477 +    Int64Value: Int64;
2478 +    BCDValue: TBCD;
2479 +    aScale: integer;
2480   begin
2481    CheckActive;
2482    if IsNullable then
2483      IsNull := False;
2484 <  case SQLTYPE of
2484 >  with FFirebirdClientAPI do
2485 >  case getColMetaData.SQLTYPE of
2486    SQL_BOOLEAN:
2487 <    if CompareText(Value,STrue) = 0 then
2487 >    if AnsiCompareText(Value,STrue) = 0 then
2488        AsBoolean := true
2489      else
2490 <    if CompareText(Value,SFalse) = 0 then
2490 >    if AnsiCompareText(Value,SFalse) = 0 then
2491        AsBoolean := false
2492      else
2493        IBError(ibxeInvalidDataConversion,[nil]);
2494  
2495    SQL_BLOB:
2496 +    if Length(Value) < GetAttachment.GetInlineBlobLimit then
2497 +      DoSetString
2498 +    else
2499      begin
2500        Changing;
2501        b := FIBXSQLVAR.CreateBlob;
# Line 1814 | Line 2506 | begin
2506  
2507    SQL_VARYING,
2508    SQL_TEXT:
2509 +    DoSetString;
2510 +
2511 +  SQL_SHORT,
2512 +  SQL_LONG,
2513 +  SQL_INT64:
2514 +    if TryStrToNumeric(Value,Int64Value,aScale) then
2515      begin
2516 <      Changing;
2517 <      FIBXSQLVar.SetString(Transliterate(Value,GetCodePage));
2518 <      Changed;
2519 <    end;
2516 >      if aScale = 0 then
2517 >        SetAsInt64(Int64Value)
2518 >      else
2519 >        SetAsNumeric(Int64Value,aScale);
2520 >    end
2521 >    else
2522 >    if TryStrToFloat(Value,FloatValue) then
2523 >      SetAsDouble(FloatValue)
2524 >    else
2525 >      DoSetString;
2526  
2527 <    SQL_SHORT,
2528 <    SQL_LONG,
2529 <    SQL_INT64:
2530 <      SetAsInt64(StrToInt(Value));
2531 <
2532 <    SQL_D_FLOAT,
2533 <    SQL_DOUBLE,
2534 <    SQL_FLOAT:
1831 <      SetAsDouble(StrToFloat(Value));
2527 >  SQL_DEC_FIXED,
2528 >  SQL_DEC16,
2529 >  SQL_DEC34,
2530 >  SQL_INT128:
2531 >    if TryStrToBCD(Value,BCDValue) then
2532 >      SetAsBCD(BCDValue)
2533 >    else
2534 >      DoSetString;
2535  
2536 <    SQL_TIMESTAMP:
2537 <      SetAsDateTime(StrToDateTime(Value));
2536 >  SQL_D_FLOAT,
2537 >  SQL_DOUBLE,
2538 >  SQL_FLOAT:
2539 >    if TryStrToFloat(Value,FloatValue) then
2540 >      SetAsDouble(FloatValue)
2541 >    else
2542 >      DoSetString;
2543  
2544 <    SQL_TYPE_DATE:
2545 <      SetAsDate(StrToDateTime(Value));
2544 >  SQL_TIMESTAMP:
2545 >      if TryStrToDateTime(Value,dt) then
2546 >        SetAsDateTime(dt)
2547 >      else
2548 >        DoSetString;
2549  
2550 <    SQL_TYPE_TIME:
2551 <      SetAsTime(StrToDateTime(Value));
2550 >  SQL_TYPE_DATE:
2551 >      if TryStrToDateTime(Value,dt) then
2552 >        SetAsDate(dt)
2553 >      else
2554 >        DoSetString;
2555  
2556 <    else
2557 <      IBError(ibxeInvalidDataConversion,[nil]);
2556 >  SQL_TYPE_TIME:
2557 >      if TryStrToDateTime(Value,dt) then
2558 >        SetAsTime(dt)
2559 >      else
2560 >        DoSetString;
2561 >
2562 >  SQL_TIMESTAMP_TZ,
2563 >  SQL_TIMESTAMP_TZ_EX:
2564 >      if ParseDateTimeTZString(value,dt,timezone) then
2565 >        SetAsDateTime(dt,timezone)
2566 >      else
2567 >        DoSetString;
2568 >
2569 >  SQL_TIME_TZ,
2570 >  SQL_TIME_TZ_EX:
2571 >      if ParseDateTimeTZString(value,dt,timezone,true) then
2572 >        SetAsTime(dt,GetAttachment.GetTimeZoneServices.GetTimeTZDate,timezone)
2573 >      else
2574 >        DoSetString;
2575 >
2576 >  else
2577 >    IBError(ibxeInvalidDataConversion,[GetSQLTypeName(getColMetaData.SQLTYPE)]);
2578    end;
2579   end;
2580  
# Line 1878 | Line 2612 | begin
2612    IsNull := true;
2613   end;
2614  
2615 + function TSQLParam.getColMetadata: IParamMetaData;
2616 + begin
2617 +  Result := FIBXSQLVAR.getColMetadata;
2618 + end;
2619 +
2620   function TSQLParam.GetModified: boolean;
2621   begin
2622    CheckActive;
# Line 1891 | Line 2630 | begin
2630    Result := inherited GetAsPointer;
2631   end;
2632  
2633 < procedure TSQLParam.SetName(Value: string);
2633 > function TSQLParam.GetAsString: AnsiString;
2634 > var rs: RawByteString;
2635 > begin
2636 >  Result := '';
2637 >  if (SQLType = SQL_VARYING) and not IsNull then
2638 >  {SQLData points to start of string - default is to length word}
2639 >  begin
2640 >    CheckActive;
2641 >    SetString(rs,PAnsiChar(SQLData),DataLength);
2642 >    SetCodePage(rs,GetCodePage,false);
2643 >    Result := rs;
2644 >  end
2645 >  else
2646 >    Result := inherited GetAsString;
2647 > end;
2648 >
2649 > procedure TSQLParam.SetName(Value: AnsiString);
2650   begin
2651    CheckActive;
2652    FIBXSQLVAR.Name := Value;
# Line 2082 | Line 2837 | begin
2837    end;
2838   end;
2839  
2840 + procedure TSQLParam.SetAsTime(aValue: TDateTime; OnDate: TDateTime; aTimeZoneID: TFBTimeZoneID);
2841 + var i: integer;
2842 +    OldSQLVar: TSQLVarData;
2843 + begin
2844 +  if FIBXSQLVAR.UniqueName then
2845 +    inherited SetAsTime(AValue,OnDate, aTimeZoneID)
2846 +  else
2847 +  with FIBXSQLVAR.Parent do
2848 +  begin
2849 +    for i := 0 to Count - 1 do
2850 +      if Column[i].Name = Name then
2851 +      begin
2852 +        OldSQLVar := FIBXSQLVAR;
2853 +        FIBXSQLVAR := Column[i];
2854 +        try
2855 +          inherited SetAsTime(AValue,OnDate, aTimeZoneID);
2856 +        finally
2857 +          FIBXSQLVAR := OldSQLVar;
2858 +        end;
2859 +      end;
2860 +  end;
2861 + end;
2862 +
2863 + procedure TSQLParam.SetAsTime(aValue: TDateTime; OnDate: TDateTime; aTimeZone: AnsiString);
2864 + var i: integer;
2865 +    OldSQLVar: TSQLVarData;
2866 + begin
2867 +  if FIBXSQLVAR.UniqueName then
2868 +    inherited SetAsTime(AValue,OnDate,aTimeZone)
2869 +  else
2870 +  with FIBXSQLVAR.Parent do
2871 +  begin
2872 +    for i := 0 to Count - 1 do
2873 +      if Column[i].Name = Name then
2874 +      begin
2875 +        OldSQLVar := FIBXSQLVAR;
2876 +        FIBXSQLVAR := Column[i];
2877 +        try
2878 +          inherited SetAsTime(AValue,OnDate,aTimeZone);
2879 +        finally
2880 +          FIBXSQLVAR := OldSQLVar;
2881 +        end;
2882 +      end;
2883 +  end;
2884 + end;
2885 +
2886 + procedure TSQLParam.SetAsTime(aValue: TDateTime; aTimeZoneID: TFBTimeZoneID);
2887 + begin
2888 +  SetAsTime(aValue,GetTimeZoneServices.GetTimeTZDate,aTimeZoneID);
2889 + end;
2890 +
2891 + procedure TSQLParam.SetAsTime(aValue: TDateTime; aTimeZone: AnsiString);
2892 + begin
2893 +  SetAsTime(aValue,GetTimeZoneServices.GetTimeTZDate,aTimeZone);
2894 + end;
2895 +
2896   procedure TSQLParam.SetAsDateTime(AValue: TDateTime);
2897   var i: integer;
2898      OldSQLVar: TSQLVarData;
# Line 2105 | Line 2916 | begin
2916    end;
2917   end;
2918  
2919 + procedure TSQLParam.SetAsDateTime(aValue: TDateTime; aTimeZoneID: TFBTimeZoneID
2920 +  );
2921 + var i: integer;
2922 +    OldSQLVar: TSQLVarData;
2923 + begin
2924 +  if FIBXSQLVAR.UniqueName then
2925 +    inherited SetAsDateTime(AValue,aTimeZoneID)
2926 +  else
2927 +  with FIBXSQLVAR.Parent do
2928 +  begin
2929 +    for i := 0 to Count - 1 do
2930 +      if Column[i].Name = Name then
2931 +      begin
2932 +        OldSQLVar := FIBXSQLVAR;
2933 +        FIBXSQLVAR := Column[i];
2934 +        try
2935 +          inherited SetAsDateTime(AValue,aTimeZoneID);
2936 +        finally
2937 +          FIBXSQLVAR := OldSQLVar;
2938 +        end;
2939 +      end;
2940 +  end;
2941 + end;
2942 +
2943 + procedure TSQLParam.SetAsDateTime(aValue: TDateTime; aTimeZone: AnsiString);
2944 + var i: integer;
2945 +    OldSQLVar: TSQLVarData;
2946 + begin
2947 +  if FIBXSQLVAR.UniqueName then
2948 +    inherited SetAsDateTime(AValue,aTimeZone)
2949 +  else
2950 +  with FIBXSQLVAR.Parent do
2951 +  begin
2952 +    for i := 0 to Count - 1 do
2953 +      if Column[i].Name = Name then
2954 +      begin
2955 +        OldSQLVar := FIBXSQLVAR;
2956 +        FIBXSQLVAR := Column[i];
2957 +        try
2958 +          inherited SetAsDateTime(AValue,aTimeZone);
2959 +        finally
2960 +          FIBXSQLVAR := OldSQLVar;
2961 +        end;
2962 +      end;
2963 +  end;
2964 + end;
2965 +
2966   procedure TSQLParam.SetAsDouble(AValue: Double);
2967   var i: integer;
2968      OldSQLVar: TSQLVarData;
# Line 2197 | Line 3055 | begin
3055    end;
3056   end;
3057  
3058 < procedure TSQLParam.SetAsString(AValue: String);
3058 > procedure TSQLParam.SetAsString(AValue: AnsiString);
3059   var i: integer;
3060      OldSQLVar: TSQLVarData;
3061   begin
# Line 2285 | Line 3143 | begin
3143    FIBXSQLVAR.SetCharSetID(aValue);
3144   end;
3145  
3146 + procedure TSQLParam.SetAsBcd(aValue: tBCD);
3147 + var i: integer;
3148 +    OldSQLVar: TSQLVarData;
3149 + begin
3150 +  if FIBXSQLVAR.UniqueName then
3151 +    inherited SetAsBcd(AValue)
3152 +  else
3153 +  with FIBXSQLVAR.Parent do
3154 +  begin
3155 +    for i := 0 to Count - 1 do
3156 +      if Column[i].Name = Name then
3157 +      begin
3158 +        OldSQLVar := FIBXSQLVAR;
3159 +        FIBXSQLVAR := Column[i];
3160 +        try
3161 +          inherited SetAsBcd(AValue);
3162 +        finally
3163 +          FIBXSQLVAR := OldSQLVar;
3164 +        end;
3165 +      end;
3166 +  end;
3167 + end;
3168 +
3169   { TMetaData }
3170  
3171   procedure TMetaData.CheckActive;
# Line 2310 | Line 3191 | begin
3191    inherited Destroy;
3192   end;
3193  
3194 < function TMetaData.GetUniqueRelationName: string;
3194 > function TMetaData.GetUniqueRelationName: AnsiString;
3195   begin
3196    CheckActive;
3197    Result := FMetaData.UniqueRelationName;
# Line 2338 | Line 3219 | begin
3219    end;
3220   end;
3221  
3222 < function TMetaData.ByName(Idx: String): IColumnMetaData;
3222 > function TMetaData.ByName(Idx: AnsiString): IColumnMetaData;
3223   var aIBXSQLVAR: TSQLVarData;
3224   begin
3225    CheckActive;
# Line 2398 | Line 3279 | begin
3279    end;
3280   end;
3281  
3282 < function TSQLParams.ByName(Idx: String): ISQLParam;
3282 > function TSQLParams.ByName(Idx: AnsiString): ISQLParam;
3283   var aIBXSQLVAR: TSQLVarData;
3284   begin
3285    CheckActive;
# Line 2423 | Line 3304 | begin
3304      end;
3305   end;
3306  
3307 + function TSQLParams.GetHasCaseSensitiveParams: Boolean;
3308 + begin
3309 +  Result := FSQLParams.CaseSensitiveParams;
3310 + end;
3311 +
3312   { TResults }
3313  
3314   procedure TResults.CheckActive;
# Line 2435 | Line 3321 | begin
3321    if not FResults.CheckStatementStatus(ssPrepared)  then
3322      IBError(ibxeStatementNotPrepared, [nil]);
3323  
3324 <  with GetTransaction as TFBTransaction do
3324 >  with GetTransaction do
3325    if not InTransaction or (FResults.TransactionSeqNo <> FTransactionSeqNo) then
3326      IBError(ibxeInterfaceOutofDate,[nil]);
3327   end;
3328  
3329   function TResults.GetISQLData(aIBXSQLVAR: TSQLVarData): ISQLData;
3330 + var col: TIBSQLData;
3331   begin
3332    if (aIBXSQLVAR.Index < 0) or (aIBXSQLVAR.Index >= getCount) then
3333      IBError(ibxeInvalidColumnIndex,[nil]);
3334  
3335    if not HasInterface(aIBXSQLVAR.Index) then
3336      AddInterface(aIBXSQLVAR.Index, TIBSQLData.Create(self,aIBXSQLVAR));
3337 <  Result := TIBSQLData(GetInterface(aIBXSQLVAR.Index));
3337 >  col := TIBSQLData(GetInterface(aIBXSQLVAR.Index));
3338 >  col.FTransaction := GetTransaction;
3339 >  Result := col;
3340   end;
3341  
3342   constructor TResults.Create(aResults: TSQLDataArea);
# Line 2466 | Line 3355 | begin
3355    Result := FResults.Count;
3356   end;
3357  
3358 < function TResults.ByName(Idx: String): ISQLData;
3358 > function TResults.ByName(Idx: AnsiString): ISQLData;
3359   var col: TSQLVarData;
3360   begin
3361    Result := nil;
# Line 2498 | Line 3387 | begin
3387   end;
3388  
3389   procedure TResults.GetData(index: integer; var IsNull: boolean; var len: short;
3390 <  var data: PChar);
3390 >  var data: PByte);
3391   begin
3392    CheckActive;
3393    FResults.GetData(index,IsNull, len,data);
3394   end;
3395  
3396 + function TResults.GetStatement: IStatement;
3397 + begin
3398 +  Result := FStatement;
3399 + end;
3400 +
3401   function TResults.GetTransaction: ITransaction;
3402   begin
3403    Result := FStatement.GetTransaction;
# Line 2514 | Line 3408 | begin
3408    RetainInterfaces := aValue;
3409   end;
3410  
2517
3411   end.
3412  

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines