ViewVC Help

View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing

root/public/ibx/branches/udr/client/FBSQLData.pas

Comparing ibx/trunk/fbintf/client/FBSQLData.pas (file contents):
Revision 45 by tony, Tue Dec 6 10:33:46 2016 UTC vs.
Revision 56 by tony, Mon Mar 6 10:20:02 2017 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 113 | Line 116 | type
116		function GetSQLDialect: integer; virtual; abstract;
117		procedure Changed; virtual;
118		procedure Changing; virtual;
119	<	procedure InternalSetAsString(Value: String); virtual;
120	<	function SQLData: PChar; virtual; abstract;
119	>	procedure InternalSetAsString(Value: AnsiString); virtual;
120	>	function SQLData: PByte; virtual; abstract;
121		function GetDataLength: cardinal; virtual; abstract;
122		function GetCodePage: TSystemCodePage; virtual; abstract;
123	<	function Transliterate(s: string; CodePage: TSystemCodePage): RawByteString;
123	>	function getCharSetID: cardinal; virtual; abstract;
124	>	function Transliterate(s: AnsiString; CodePage: TSystemCodePage): RawByteString;
125		procedure SetScale(aValue: integer); virtual;
126		procedure SetDataLength(len: cardinal); virtual;
127		procedure SetSQLType(aValue: cardinal); virtual;
#	Line 125 | Line 129 | type
129
130		public
131		function GetSQLType: cardinal; virtual; abstract;
132	<	function GetSQLTypeName: string; overload;
133	<	class function GetSQLTypeName(SQLType: short): string; overload;
134	<	function GetName: string; virtual; abstract;
132	>	function GetSQLTypeName: AnsiString; overload;
133	>	class function GetSQLTypeName(SQLType: short): AnsiString; overload;
134	>	function GetName: AnsiString; virtual; abstract;
135		function GetScale: integer; virtual; abstract;
136		function GetAsBoolean: boolean;
137		function GetAsCurrency: Currency;
#	Line 139 | Line 143 | type
143		function GetAsPointer: Pointer;
144		function GetAsQuad: TISC_QUAD;
145		function GetAsShort: short;
146	<	function GetAsString: String; virtual;
146	>	function GetAsString: AnsiString; virtual;
147		function GetIsNull: Boolean; virtual;
148		function getIsNullable: boolean; virtual;
149		function GetAsVariant: Variant;
#	Line 156 | Line 160 | type
160		procedure SetAsPointer(Value: Pointer);
161		procedure SetAsQuad(Value: TISC_QUAD);
162		procedure SetAsShort(Value: short); virtual;
163	<	procedure SetAsString(Value: String); virtual;
163	>	procedure SetAsString(Value: AnsiString); virtual;
164		procedure SetAsVariant(Value: Variant);
165		procedure SetIsNull(Value: Boolean); virtual;
166		procedure SetIsNullable(Value: Boolean); virtual;
167	<	procedure SetName(aValue: string); virtual;
167	>	procedure SetName(aValue: AnsiString); virtual;
168		property AsDate: TDateTime read GetAsDateTime write SetAsDate;
169		property AsBoolean:boolean read GetAsBoolean write SetAsBoolean;
170		property AsTime: TDateTime read GetAsDateTime write SetAsTime;
#	Line 174 | Line 178 | type
178		property AsPointer: Pointer read GetAsPointer write SetAsPointer;
179		property AsQuad: TISC_QUAD read GetAsQuad write SetAsQuad;
180		property AsShort: short read GetAsShort write SetAsShort;
181	<	property AsString: String read GetAsString write SetAsString;
181	>	property AsString: AnsiString read GetAsString write SetAsString;
182		property AsVariant: Variant read GetAsVariant write SetAsVariant;
183		property Modified: Boolean read getModified;
184		property IsNull: Boolean read GetIsNull write SetIsNull;
#	Line 194 | Line 198 | type
198		function GetColumn(index: integer): TSQLVarData;
199		function GetCount: integer;
200		protected
201	<	FUniqueRelationName: string;
201	>	FUniqueRelationName: AnsiString;
202		FColumnList: array of TSQLVarData;
203		function GetStatement: IStatement; virtual; abstract;
204		function GetPrepareSeqNo: integer; virtual; abstract;
#	Line 204 | Line 208 | type
208		public
209		procedure Initialize; virtual;
210		function IsInputDataArea: boolean; virtual; abstract; {Input to Database}
211	<	procedure PreprocessSQL(sSQL: string; GenerateParamNames: boolean;
212	<	var sProcessedSQL: string);
211	>	procedure PreprocessSQL(sSQL: AnsiString; GenerateParamNames: boolean;
212	>	var sProcessedSQL: AnsiString);
213		function ColumnsInUseCount: integer; virtual;
214	<	function ColumnByName(Idx: string): TSQLVarData;
214	>	function ColumnByName(Idx: AnsiString): TSQLVarData;
215		function CheckStatementStatus(Request: TStatementStatus): boolean; virtual; abstract;
216		procedure GetData(index: integer; var IsNull: boolean; var len: short;
217	<	var data: PChar); virtual;
217	>	var data: PByte); virtual;
218		procedure RowChange;
219		function StateChanged(var ChangeSeqNo: integer): boolean; virtual; abstract;
220		property Count: integer read GetCount;
221		property Column[index: integer]: TSQLVarData read GetColumn;
222	<	property UniqueRelationName: string read FUniqueRelationName;
222	>	property UniqueRelationName: AnsiString read FUniqueRelationName;
223		property Statement: IStatement read GetStatement;
224		property PrepareSeqNo: integer read GetPrepareSeqNo;
225		property TransactionSeqNo: integer read GetTransactionSeqNo;
#	Line 226 | Line 230 | type
230		TSQLVarData = class
231		private
232		FParent: TSQLDataArea;
233	<	FName: string;
233	>	FName: AnsiString;
234		FIndex: integer;
235		FModified: boolean;
236		FUniqueName: boolean;
237		FVarString: RawByteString;
238		function GetStatement: IStatement;
239	<	procedure SetName(AValue: string);
239	>	procedure SetName(AValue: AnsiString);
240		protected
241		function GetSQLType: cardinal; virtual; abstract;
242		function GetSubtype: integer; virtual; abstract;
243	<	function GetAliasName: string;  virtual; abstract;
244	<	function GetFieldName: string; virtual; abstract;
245	<	function GetOwnerName: string;  virtual; abstract;
246	<	function GetRelationName: string;  virtual; abstract;
243	>	function GetAliasName: AnsiString;  virtual; abstract;
244	>	function GetFieldName: AnsiString; virtual; abstract;
245	>	function GetOwnerName: AnsiString;  virtual; abstract;
246	>	function GetRelationName: AnsiString;  virtual; abstract;
247		function GetScale: integer; virtual; abstract;
248		function GetCharSetID: cardinal; virtual; abstract;
249		function GetCodePage: TSystemCodePage; virtual; abstract;
250		function GetIsNull: Boolean;   virtual; abstract;
251		function GetIsNullable: boolean; virtual; abstract;
252	<	function GetSQLData: PChar;  virtual; abstract;
252	>	function GetSQLData: PByte;  virtual; abstract;
253		function GetDataLength: cardinal; virtual; abstract;
254		procedure SetIsNull(Value: Boolean); virtual; abstract;
255		procedure SetIsNullable(Value: Boolean);  virtual; abstract;
256	<	procedure SetSQLData(AValue: PChar; len: cardinal); virtual; abstract;
256	>	procedure SetSQLData(AValue: PByte; len: cardinal); virtual; abstract;
257		procedure SetScale(aValue: integer); virtual; abstract;
258		procedure SetDataLength(len: cardinal); virtual; abstract;
259		procedure SetSQLType(aValue: cardinal); virtual; abstract;
260		procedure SetCharSetID(aValue: cardinal); virtual; abstract;
261		public
262		constructor Create(aParent: TSQLDataArea; aIndex: integer);
263	<	procedure SetString(aValue: string);
263	>	procedure SetString(aValue: AnsiString);
264		procedure Changed; virtual;
265		procedure RowChange; virtual;
266		function GetAsArray(Array_ID: TISC_QUAD): IArray; virtual; abstract;
#	Line 267 | Line 271 | type
271		procedure Initialize; virtual;
272
273		public
274	<	property AliasName: string read GetAliasName;
275	<	property FieldName: string read GetFieldName;
276	<	property OwnerName: string read GetOwnerName;
277	<	property RelationName: string read GetRelationName;
274	>	property AliasName: AnsiString read GetAliasName;
275	>	property FieldName: AnsiString read GetFieldName;
276	>	property OwnerName: AnsiString read GetOwnerName;
277	>	property RelationName: AnsiString read GetRelationName;
278		property Parent: TSQLDataArea read FParent;
279		property Index: integer read FIndex;
280	<	property Name: string read FName write SetName;
280	>	property Name: AnsiString read FName write SetName;
281		property CharSetID: cardinal read GetCharSetID write SetCharSetID;
282		property SQLType: cardinal read GetSQLType write SetSQLType;
283		property SQLSubtype: integer read GetSubtype;
284	<	property SQLData: PChar read GetSQLData;
284	>	property SQLData: PByte read GetSQLData;
285		property DataLength: cardinal read GetDataLength write SetDataLength;
286		property IsNull: Boolean read GetIsNull write SetIsNull;
287		property IsNullable: Boolean read GetIsNullable write SetIsNullable;
#	Line 299 | Line 303 | type
303		FChangeSeqNo: integer;
304		protected
305		procedure CheckActive; override;
306	<	function SQLData: PChar; override;
306	>	function SQLData: PByte; override;
307		function GetDataLength: cardinal; override;
308		function GetCodePage: TSystemCodePage; override;
309
#	Line 314 | Line 318 | type
318		function GetIndex: integer;
319		function GetSQLType: cardinal; override;
320		function getSubtype: integer;
321	<	function getRelationName: string;
322	<	function getOwnerName: string;
323	<	function getSQLName: string;    {Name of the column}
324	<	function getAliasName: string;  {Alias Name of column or Column Name if not alias}
325	<	function GetName: string; override;      {Disambiguated uppercase Field Name}
321	>	function getRelationName: AnsiString;
322	>	function getOwnerName: AnsiString;
323	>	function getSQLName: AnsiString;    {Name of the column}
324	>	function getAliasName: AnsiString;  {Alias Name of column or Column Name if not alias}
325	>	function GetName: AnsiString; override;      {Disambiguated uppercase Field Name}
326		function GetScale: integer; override;
327	<	function getCharSetID: cardinal;
327	>	function getCharSetID: cardinal; override;
328		function GetIsNullable: boolean; override;
329		function GetSize: cardinal;
330		function GetArrayMetaData: IArrayMetaData;
331		function GetBlobMetaData: IBlobMetaData;
332	<	property Name: string read GetName;
332	>	property Name: AnsiString read GetName;
333		property Size: cardinal read GetSize;
334		property CharSetID: cardinal read getCharSetID;
335		property SQLSubtype: integer read getSubtype;
#	Line 342 | Line 346 | type
346		function GetAsArray: IArray;
347		function GetAsBlob: IBlob; overload;
348		function GetAsBlob(BPB: IBPB): IBlob; overload;
349	<	function GetAsString: String; override;
349	>	function GetAsString: AnsiString; override;
350		property AsBlob: IBlob read GetAsBlob;
351		end;
352
#	Line 352 | Line 356 | type
356		protected
357		procedure CheckActive; override;
358		procedure Changed; override;
359	<	procedure InternalSetAsString(Value: String); override;
359	>	procedure InternalSetAsString(Value: AnsiString); override;
360		procedure SetScale(aValue: integer); override;
361		procedure SetDataLength(len: cardinal); override;
362		procedure SetSQLType(aValue: cardinal); override;
#	Line 360 | Line 364 | type
364		procedure Clear;
365		function GetModified: boolean; override;
366		function GetAsPointer: Pointer;
367	<	procedure SetName(Value: string); override;
367	>	procedure SetName(Value: AnsiString); override;
368		procedure SetIsNull(Value: Boolean);  override;
369		procedure SetIsNullable(Value: Boolean); override;
370		procedure SetAsArray(anArray: IArray);
#	Line 377 | Line 381 | type
381		procedure SetAsFloat(AValue: Float);
382		procedure SetAsPointer(AValue: Pointer);
383		procedure SetAsShort(AValue: Short);
384	<	procedure SetAsString(AValue: String); override;
384	>	procedure SetAsString(AValue: AnsiString); override;
385		procedure SetAsVariant(AValue: Variant);
386		procedure SetAsBlob(aValue: IBlob);
387		procedure SetAsQuad(AValue: TISC_QUAD);
#	Line 400 | Line 404 | type
404		destructor Destroy; override;
405		public
406		{IMetaData}
407	<	function GetUniqueRelationName: string;
407	>	function GetUniqueRelationName: AnsiString;
408		function getCount: integer;
409		function getColumnMetaData(index: integer): IColumnMetaData;
410	<	function ByName(Idx: String): IColumnMetaData;
410	>	function ByName(Idx: AnsiString): IColumnMetaData;
411		end;
412
413		{ TSQLParams }
#	Line 422 | Line 426 | type
426		{ISQLParams}
427		function getCount: integer;
428		function getSQLParam(index: integer): ISQLParam;
429	<	function ByName(Idx: String): ISQLParam ;
429	>	function ByName(Idx: AnsiString): ISQLParam ;
430		function GetModified: Boolean;
431		end;
432
#	Line 442 | Line 446 | type
446		constructor Create(aResults: TSQLDataArea);
447		{IResults}
448		function getCount: integer;
449	<	function ByName(Idx: String): ISQLData;
449	>	function ByName(Idx: AnsiString): ISQLData;
450		function getSQLData(index: integer): ISQLData;
451	<	procedure GetData(index: integer; var IsNull:boolean; var len: short; var data: PChar);
451	>	procedure GetData(index: integer; var IsNull:boolean; var len: short; var data: PByte);
452		function GetTransaction: ITransaction; virtual;
453		procedure SetRetainInterfaces(aValue: boolean);
454		end;
#	Line 453 | Line 457 | implementation
457
458		uses FBMessages, FBClientAPI, variants, IBUtils, FBTransaction;
459
460	+
461		{ TSQLDataArea }
462
463		function TSQLDataArea.GetColumn(index: integer): TSQLVarData;
#	Line 471 | Line 476 | procedure TSQLDataArea.SetUniqueRelation
476		var
477		i: Integer;
478		bUnique: Boolean;
479	<	RelationName: string;
479	>	RelationName: AnsiString;
480		begin
481		bUnique := True;
482		for i := 0 to ColumnsInUseCount - 1 do
#	Line 502 | Line 507 | begin
507		Column[i].Initialize;
508		end;
509
510	<	procedure TSQLDataArea.PreprocessSQL(sSQL: string; GenerateParamNames: boolean;
511	<	var sProcessedSQL: string);
510	>	procedure TSQLDataArea.PreprocessSQL(sSQL: AnsiString; GenerateParamNames: boolean;
511	>	var sProcessedSQL: AnsiString);
512		var
513	<	cCurChar, cNextChar, cQuoteChar: Char;
514	<	sParamName: String;
513	>	cCurChar, cNextChar, cQuoteChar: AnsiChar;
514	>	sParamName: AnsiString;
515		j, i, iLenSQL, iSQLPos: Integer;
516		iCurState {$ifdef ALLOWDIALECT3PARAMNAMES}, iCurParamState {$endif}: Integer;
517		iParamSuffix: Integer;
518		slNames: TStrings;
519	<	StrBuffer: PChar;
519	>	StrBuffer: PByte;
520		found: boolean;
521
522		const
#	Line 519 | Line 524 | const
524		CommentState = 1;
525		QuoteState = 2;
526		ParamState = 3;
527	+	ArrayDimState = 4;
528		{$ifdef ALLOWDIALECT3PARAMNAMES}
529		ParamDefaultState = 0;
530		ParamQuoteState = 1;
531		{$endif}
532
533	<	procedure AddToProcessedSQL(cChar: Char);
533	>	procedure AddToProcessedSQL(cChar: AnsiChar);
534		begin
535	<	StrBuffer[iSQLPos] := cChar;
535	>	StrBuffer[iSQLPos] := byte(cChar);
536		Inc(iSQLPos);
537		end;
538
#	Line 559 | Line 565 | begin
565		cNextChar := sSQL[i + 1];
566		{ Now act based on the current state }
567		case iCurState of
568	<	DefaultState: begin
568	>	DefaultState:
569	>	begin
570		case cCurChar of
571	<	'''', '"': begin
571	>	'''', '"':
572	>	begin
573		cQuoteChar := cCurChar;
574		iCurState := QuoteState;
575		end;
576	<	'?', ':': begin
576	>	'?', ':':
577	>	begin
578		iCurState := ParamState;
579		AddToProcessedSQL('?');
580		end;
581	<	'/': if (cNextChar = '*') then begin
581	>	'/': if (cNextChar = '*') then
582	>	begin
583		AddToProcessedSQL(cCurChar);
584		Inc(i);
585		iCurState := CommentState;
586		end;
587	+	'[':
588	+	begin
589	+	AddToProcessedSQL(cCurChar);
590	+	Inc(i);
591	+	iCurState := ArrayDimState;
592	+	end;
593	+	end;
594	+	end;
595	+
596	+	ArrayDimState:
597	+	begin
598	+	case cCurChar of
599	+	':',',','0'..'9',' ',#9,#10,#13:
600	+	begin
601	+	AddToProcessedSQL(cCurChar);
602	+	Inc(i);
603	+	end;
604	+	else
605	+	begin
606	+	AddToProcessedSQL(cCurChar);
607	+	Inc(i);
608	+	iCurState := DefaultState;
609	+	end;
610		end;
611		end;
612	<	CommentState: begin
612	>
613	>	CommentState:
614	>	begin
615		if (cNextChar = #0) then
616		IBError(ibxeSQLParseError, [SEOFInComment])
617		else if (cCurChar = '*') then begin
#	Line 653 | Line 688 | begin
688		Inc(i);
689		end;
690		AddToProcessedSQL(#0);
691	<	sProcessedSQL := strpas(StrBuffer);
691	>	sProcessedSQL := strpas(PAnsiChar(StrBuffer));
692		SetCount(slNames.Count);
693		for i := 0 to slNames.Count - 1 do
694		begin
#	Line 685 | Line 720 | begin
720		Result := Count;
721		end;
722
723	<	function TSQLDataArea.ColumnByName(Idx: string): TSQLVarData;
723	>	function TSQLDataArea.ColumnByName(Idx: AnsiString): TSQLVarData;
724		var
725	<	s: String;
725	>	s: AnsiString;
726		i: Integer;
727		begin
728		{$ifdef UseCaseInSensitiveParamName}
#	Line 705 | Line 740 | begin
740		end;
741
742		procedure TSQLDataArea.GetData(index: integer; var IsNull: boolean;
743	<	var len: short; var data: PChar);
743	>	var len: short; var data: PByte);
744		begin
745		//Do Nothing
746		end;
#	Line 724 | Line 759 | begin
759		Result := FParent.Statement;
760		end;
761
762	<	procedure TSQLVarData.SetName(AValue: string);
762	>	procedure TSQLVarData.SetName(AValue: AnsiString);
763		begin
764		if FName = AValue then Exit;
765		{$ifdef UseCaseInSensitiveParamName}
#	Line 743 | Line 778 | begin
778		FUniqueName := true;
779		end;
780
781	<	procedure TSQLVarData.SetString(aValue: string);
781	>	procedure TSQLVarData.SetString(aValue: AnsiString);
782		begin
783		{we take full advantage here of reference counted strings. When setting a string
784		value, a reference is kept in FVarString and a pointer to it placed in the
785	<	SQLVar. This avoids string copies. Note that PChar is guaranteed to point to
785	>	SQLVar. This avoids string copies. Note that PAnsiChar is guaranteed to point to
786		a zero byte when the string is empty, neatly avoiding a nil pointer error.}
787
788		FVarString := aValue;
789		SQLType := SQL_TEXT;
790	<	SetSQLData(PChar(FVarString),Length(aValue));
790	>	SetSQLData(PByte(PAnsiChar(FVarString)),Length(aValue));
791		end;
792
793		procedure TSQLVarData.Changed;
#	Line 768 | Line 803 | end;
803
804		procedure TSQLVarData.Initialize;
805
806	<	function FindVarByName(idx: string; limit: integer): TSQLVarData;
806	>	function FindVarByName(idx: AnsiString; limit: integer): TSQLVarData;
807		var
808		k: integer;
809		begin
#	Line 783 | Line 818 | procedure TSQLVarData.Initialize;
818
819		var
820		j, j_len: Integer;
821	<	st: String;
822	<	sBaseName: string;
821	>	st: AnsiString;
822	>	sBaseName: AnsiString;
823		begin
824		RowChange;
825
#	Line 871 | Line 906 | function TSQLDataItem.AdjustScaleToCurre
906		var
907		Scaling : Int64;
908		i : Integer;
909	<	FractionText, PadText, CurrText: string;
909	>	FractionText, PadText, CurrText: AnsiString;
910		begin
911		Result := 0;
912		Scaling := 1;
#	Line 890 | Line 925 | begin
925		FractionText := IntToStr(abs(Value mod Scaling));
926		for i := Length(FractionText) to -aScale -1 do
927		PadText := '0' + PadText;
928	+	{$IF declared(DefaultFormatSettings)}
929	+	with DefaultFormatSettings do
930	+	{$ELSE}
931	+	{$IF declared(FormatSettings)}
932	+	with FormatSettings do
933	+	{$IFEND}
934	+	{$IFEND}
935		if Value < 0 then
936	<	CurrText := '-' + IntToStr(Abs(Value div Scaling)) + DefaultFormatSettings.DecimalSeparator + PadText + FractionText
936	>	CurrText := '-' + IntToStr(Abs(Value div Scaling)) + DecimalSeparator + PadText + FractionText
937		else
938	<	CurrText := IntToStr(Abs(Value div Scaling)) + DefaultFormatSettings.DecimalSeparator + PadText + FractionText;
938	>	CurrText := IntToStr(Abs(Value div Scaling)) + DecimalSeparator + PadText + FractionText;
939		try
940		result := StrToCurr(CurrText);
941		except
#	Line 975 | Line 1017 | begin
1017		//Do nothing by default
1018		end;
1019
1020	<	procedure TSQLDataItem.InternalSetAsString(Value: String);
1020	>	procedure TSQLDataItem.InternalSetAsString(Value: AnsiString);
1021		begin
1022		//Do nothing by default
1023		end;
1024
1025	<	function TSQLDataItem.Transliterate(s: string; CodePage: TSystemCodePage
1025	>	function TSQLDataItem.Transliterate(s: AnsiString; CodePage: TSystemCodePage
1026		): RawByteString;
1027		begin
1028		Result := s;
#	Line 1003 | Line 1045 | begin
1045		//Do nothing by default
1046		end;
1047
1048	<	function TSQLDataItem.GetSQLTypeName: string;
1048	>	function TSQLDataItem.GetSQLTypeName: AnsiString;
1049		begin
1050		Result := GetSQLTypeName(GetSQLType);
1051		end;
1052
1053	<	class function TSQLDataItem.GetSQLTypeName(SQLType: short): string;
1053	>	class function TSQLDataItem.GetSQLTypeName(SQLType: short): AnsiString;
1054		begin
1055		Result := 'Unknown';
1056		case SQLType of
#	Line 1239 | Line 1281 | begin
1281		end;
1282
1283
1284	<	function TSQLDataItem.GetAsString: String;
1284	>	function TSQLDataItem.GetAsString: AnsiString;
1285		var
1286	<	sz: PChar;
1286	>	sz: PByte;
1287		str_len: Integer;
1288		rs: RawByteString;
1289		begin
#	Line 1266 | Line 1308 | begin
1308		str_len := DecodeInteger(SQLData, 2);
1309		Inc(sz, 2);
1310		end;
1311	<	SetString(rs, sz, str_len);
1311	>	SetString(rs, PAnsiChar(sz), str_len);
1312		SetCodePage(rs,GetCodePage,false);
1313	<	Result := Trim(rs);
1313	>	if (SQLType = SQL_TEXT) and (GetCharSetID <> 1) then
1314	>	Result := TrimRight(rs)
1315	>	else
1316	>	Result := rs
1317		end;
1318		SQL_TYPE_DATE:
1319		case GetSQLDialect of
#	Line 1278 | Line 1323 | begin
1323		SQL_TYPE_TIME :
1324		result := TimeToStr(AsDateTime);
1325		SQL_TIMESTAMP:
1326	<	result := FormatDateTime(FormatSettings.ShortDateFormat + ' ' +
1327	<	FormatSettings.LongTimeFormat+'.zzz',AsDateTime);
1326	>	{$IF declared(DefaultFormatSettings)}
1327	>	with DefaultFormatSettings do
1328	>	{$ELSE}
1329	>	{$IF declared(FormatSettings)}
1330	>	with FormatSettings do
1331	>	{$IFEND}
1332	>	{$IFEND}
1333	>	result := FormatDateTime(ShortDateFormat + ' ' +
1334	>	LongTimeFormat+'.zzz',AsDateTime);
1335		SQL_SHORT, SQL_LONG:
1336		if Scale = 0 then
1337		result := IntToStr(AsLong)
#	Line 1366 | Line 1418 | begin
1418		//ignore unless overridden
1419		end;
1420
1421	<	procedure TSQLDataItem.SetName(aValue: string);
1421	>	procedure TSQLDataItem.SetName(aValue: AnsiString);
1422		begin
1423		//ignore unless overridden
1424		end;
#	Line 1451 | Line 1503 | begin
1503
1504		Changing;
1505		SQLType := SQL_TIMESTAMP;
1506	<	DataLength := SizeOf(TISC_QUAD);
1506	>	DataLength := SizeOf(ISC_TIME) + sizeof(ISC_DATE);
1507		with FirebirdClientAPI do
1508		SQLEncodeDateTime(Value,SQLData);
1509		Changed;
#	Line 1542 | Line 1594 | begin
1594		Changed;
1595		end;
1596
1597	<	procedure TSQLDataItem.SetAsString(Value: String);
1597	>	procedure TSQLDataItem.SetAsString(Value: AnsiString);
1598		begin
1599		InternalSetAsString(Value);
1600		end;
#	Line 1607 | Line 1659 | begin
1659		IBError(ibxeStatementNotPrepared, [nil]);
1660		end;
1661
1662	<	function TColumnMetaData.SQLData: PChar;
1662	>	function TColumnMetaData.SQLData: PByte;
1663		begin
1664		Result := FIBXSQLVAR.SQLData;
1665		end;
#	Line 1660 | Line 1712 | begin
1712		result := FIBXSQLVAR.SQLSubtype;
1713		end;
1714
1715	<	function TColumnMetaData.getRelationName: string;
1715	>	function TColumnMetaData.getRelationName: AnsiString;
1716		begin
1717		CheckActive;
1718		result :=  FIBXSQLVAR.RelationName;
1719		end;
1720
1721	<	function TColumnMetaData.getOwnerName: string;
1721	>	function TColumnMetaData.getOwnerName: AnsiString;
1722		begin
1723		CheckActive;
1724		result :=  FIBXSQLVAR.OwnerName;
1725		end;
1726
1727	<	function TColumnMetaData.getSQLName: string;
1727	>	function TColumnMetaData.getSQLName: AnsiString;
1728		begin
1729		CheckActive;
1730		result :=  FIBXSQLVAR.FieldName;
1731		end;
1732
1733	<	function TColumnMetaData.getAliasName: string;
1733	>	function TColumnMetaData.getAliasName: AnsiString;
1734		begin
1735		CheckActive;
1736		result := FIBXSQLVAR.AliasName;
1737		end;
1738
1739	<	function TColumnMetaData.GetName: string;
1739	>	function TColumnMetaData.GetName: AnsiString;
1740		begin
1741		CheckActive;
1742		Result := FIBXSQLVAR. Name;
#	Line 1769 | Line 1821 | begin
1821		result := FIBXSQLVAR.GetAsBlob(AsQuad,BPB);
1822		end;
1823
1824	<	function TIBSQLData.GetAsString: String;
1824	>	function TIBSQLData.GetAsString: AnsiString;
1825		begin
1826		CheckActive;
1827		Result := '';
#	Line 1777 | Line 1829 | begin
1829		if not IsNull then
1830		case SQLType of
1831		SQL_ARRAY:
1832	<	result := '(Array)'; {do not localize}
1832	>	result := SArray;
1833		SQL_BLOB:
1834	<	Result := Trim(FIBXSQLVAR.GetAsBlob(AsQuad,nil).GetAsString);
1834	>	Result := FIBXSQLVAR.GetAsBlob(AsQuad,nil).GetAsString;
1835		else
1836		Result := inherited GetAsString;
1837		end;
#	Line 1787 | Line 1839 | end;
1839
1840		{ TSQLParam }
1841
1842	<	procedure TSQLParam.InternalSetAsString(Value: String);
1842	>	procedure TSQLParam.InternalSetAsString(Value: AnsiString);
1843		var b: IBlob;
1844		begin
1845		CheckActive;
#	Line 1795 | Line 1847 | begin
1847		IsNull := False;
1848		case SQLTYPE of
1849		SQL_BOOLEAN:
1850	<	if CompareText(Value,STrue) = 0 then
1850	>	if AnsiCompareText(Value,STrue) = 0 then
1851		AsBoolean := true
1852		else
1853	<	if CompareText(Value,SFalse) = 0 then
1853	>	if AnsiCompareText(Value,SFalse) = 0 then
1854		AsBoolean := false
1855		else
1856		IBError(ibxeInvalidDataConversion,[nil]);
#	Line 1891 | Line 1943 | begin
1943		Result := inherited GetAsPointer;
1944		end;
1945
1946	<	procedure TSQLParam.SetName(Value: string);
1946	>	procedure TSQLParam.SetName(Value: AnsiString);
1947		begin
1948		CheckActive;
1949		FIBXSQLVAR.Name := Value;
#	Line 2197 | Line 2249 | begin
2249		end;
2250		end;
2251
2252	<	procedure TSQLParam.SetAsString(AValue: String);
2252	>	procedure TSQLParam.SetAsString(AValue: AnsiString);
2253		var i: integer;
2254		OldSQLVar: TSQLVarData;
2255		begin
#	Line 2310 | Line 2362 | begin
2362		inherited Destroy;
2363		end;
2364
2365	<	function TMetaData.GetUniqueRelationName: string;
2365	>	function TMetaData.GetUniqueRelationName: AnsiString;
2366		begin
2367		CheckActive;
2368		Result := FMetaData.UniqueRelationName;
#	Line 2338 | Line 2390 | begin
2390		end;
2391		end;
2392
2393	<	function TMetaData.ByName(Idx: String): IColumnMetaData;
2393	>	function TMetaData.ByName(Idx: AnsiString): IColumnMetaData;
2394		var aIBXSQLVAR: TSQLVarData;
2395		begin
2396		CheckActive;
#	Line 2398 | Line 2450 | begin
2450		end;
2451		end;
2452
2453	<	function TSQLParams.ByName(Idx: String): ISQLParam;
2453	>	function TSQLParams.ByName(Idx: AnsiString): ISQLParam;
2454		var aIBXSQLVAR: TSQLVarData;
2455		begin
2456		CheckActive;
#	Line 2466 | Line 2518 | begin
2518		Result := FResults.Count;
2519		end;
2520
2521	<	function TResults.ByName(Idx: String): ISQLData;
2521	>	function TResults.ByName(Idx: AnsiString): ISQLData;
2522		var col: TSQLVarData;
2523		begin
2524		Result := nil;
#	Line 2498 | Line 2550 | begin
2550		end;
2551
2552		procedure TResults.GetData(index: integer; var IsNull: boolean; var len: short;
2553	<	var data: PChar);
2553	>	var data: PByte);
2554		begin
2555		CheckActive;
2556		FResults.GetData(index,IsNull, len,data);
#	Line 2514 | Line 2566 | begin
2566		RetainInterfaces := aValue;
2567		end;
2568
2517	–
2569		end.
2570

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines