ViewVC Help

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

root/public/ibx/trunk/runtime/IBTable.pas

Comparing ibx/trunk/runtime/IBTable.pas (file contents):
Revision 5 by tony, Fri Feb 18 16:26:16 2011 UTC vs.
Revision 143 by tony, Fri Feb 23 12:11:21 2018 UTC

#	Line 24 | Line 24
24		{       Corporation. All Rights Reserved.                                }
25		{    Contributor(s): Jeff Overcash                                       }
26		{                                                                        }
27	+	{    IBX For Lazarus (Firebird Express)                                  }
28	+	{    Contributor: Tony Whyman, MWA Software http://www.mwasoftware.co.uk }
29	+	{    Portions created by MWA Software are copyright McCallum Whyman      }
30	+	{    Associates Ltd 2011 - 2018                                               }
31	+	{                                                                        }
32		{************************************************************************}
33
34		unit IBTable;
35
36		{$Mode Delphi}
37
38	+	{$codepage UTF8}
39	+
40		interface
41
42		uses SysUtils, Classes, DB, IB,  IBCustomDataSet,
43	<	IBHeader, IBSQL, IBUtils;
43	>	IBSQL, IBUtils;
44
45		type
46
#	Line 52 | Line 59 | type
59		FMasterLink: TMasterDataLink;
60		FMasterFieldsList: TStringList;
61		FDetailFieldsList: TStringList;
55	–	FStoreDefs: Boolean;
62		FIndexDefs: TIndexDefs;
63		FDefaultIndex: Boolean;
64		FReadOnly: Boolean;
#	Line 64 | Line 70 | type
70		FSwitchingIndex: Boolean;
71		FPrimaryIndexFields: string;
72		FTableTypes: TIBTableTypes;
73	+	FStoreDefs: boolean;
74		WhereAllRefreshSQL: TStrings;
75		WhereDBKeyRefreshSQL: TStrings;
76		WherePrimaryRefreshSQL: TStrings;
#	Line 90 | Line 97 | type
97		function GetExists: Boolean;
98		procedure SetIndexDefs(Value: TIndexDefs);
99		procedure ExtractLinkFields;
93	–	function FieldDefsStored: Boolean;
100		function IndexDefsStored: Boolean;
101		function GetMasterFields: string;
102		procedure SetMasterFields(const Value: string);
#	Line 142 | Line 148 | type
148		property TableNames: TStrings read GetTableNames;
149
150		published
151	+	property AutoCommit;
152		property Active;
153		property BufferChunks;
154		property CachedUpdates;
155	<	property Constraints stored ConstraintsStored;
155	>	property DataSetCloseAction;
156	>	//    property Constraints stored ConstraintsStored;
157		property DefaultIndex: Boolean read FDefaultIndex write FDefaultIndex default True;
150	–	property FieldDefs stored FieldDefsStored;
158		property Filter;
159		property Filtered;
160	+	property GeneratorField;
161		property IndexDefs: TIndexDefs read FIndexDefs write SetIndexDefs stored IndexDefsStored;
162		property IndexFieldNames: string read GetIndexFieldNames write SetIndexFieldNames;
163		property IndexName: string read GetIndexName write SetIndexName;
#	Line 173 | Line 181 | type
181
182		implementation
183
184	+	uses FBMessages;
185	+
186		{ TIBTable }
187
188		constructor TIBTable.Create(AOwner: TComponent);
#	Line 229 | Line 239 | begin
239		GenerateUpdateSQL;
240		FRegenerateSQL := False;
241		end;
242	+	{  writeln(SelectSQL.Text);
243	+	writeln(InsertSQL.Text);
244	+	writeln(DeleteSQL.Text);
245	+	writeln(ModifySQL.Text); }
246		SetParams;
247		inherited InternalOpen;
248		end;
#	Line 290 | Line 304 | end;
304
305		procedure TIBTable.InitFieldDefs;
306		var
307	<	sqlscale: Integer;
307	>	DidActivate: Boolean;
308		Query: TIBSQL;
309		begin
310		if FTableName = '' then IBError(ibxeNoTableName, [nil]);
311	<	if (InternalPrepared) then InternalInitFieldDefs else
311	>	if (InternalPrepared) then
312	>	InternalInitFieldDefs
313	>	else
314		begin
315	<	Database.InternalTransaction.StartTransaction;
315	>	{Get the field defs from a simple query on the table}
316	>	ActivateConnection;
317		Query := TIBSQL.Create(self);
318		try
319	<	Query.GoToFirstRecordOnExecute := False;
320	<	Query.Database := DataBase;
321	<	Query.Transaction := Database.InternalTransaction;
322	<	Query.SQL.Text := 'Select R.RDB$FIELD_NAME, R.RDB$FIELD_POSITION, ' + {do not localize}
323	<	'F.RDB$COMPUTED_BLR, F.RDB$DEFAULT_VALUE, ' + {do not localize}
324	<	'F.RDB$NULL_FLAG, ' + {do not localize}
325	<	'F.RDB$FIELD_LENGTH, F.RDB$FIELD_SCALE, ' + {do not localize}
309	<	'F.RDB$FIELD_TYPE, F.RDB$FIELD_SUB_TYPE, ' + {do not localize}
310	<	'F.RDB$EXTERNAL_LENGTH, F.RDB$EXTERNAL_SCALE, F.RDB$EXTERNAL_TYPE ' + {do not localize}
311	<	'from RDB$RELATION_FIELDS R, RDB$FIELDS F ' + {do not localize}
312	<	'where R.RDB$RELATION_NAME = ' + {do not localize}
313	<	'''' +
314	<	FormatIdentifierValue(Database.SQLDialect,
315	<	QuoteIdentifier(DataBase.SQLDialect, FTableName)) +
316	<	''' ' +
317	<	'and R.RDB$FIELD_SOURCE = F.RDB$FIELD_NAME '+ {do not localize}
318	<	'order by R.RDB$FIELD_POSITION'; {do not localize}
319	<
320	<	Query.Prepare;
321	<	Query.ExecQuery;
322	<	FieldDefs.BeginUpdate;
323	<	FieldDefs.Clear;
324	<	while (not Query.EOF) and (Query.Next <> nil) do
325	<	begin
326	<	with FieldDefs.AddFieldDef do
327	<	begin
328	<	(*           FieldNo := Query.Current.ByName('RDB$FIELD_POSITION').AsInteger; {do not localize}*)
329	<	Name := TrimRight(Query.Current.ByName('RDB$FIELD_NAME').AsString); {do not localize}
330	<	case Query.Current.ByName('RDB$FIELD_TYPE').AsInteger of {do not localize}
331	<	blr_varying, blr_text:
332	<	begin
333	<	DataType := ftString;
334	<	Size := Query.Current.ByName('RDB$FIELD_LENGTH').AsInteger; {do not localize}
335	<	end;
336	<	blr_float, blr_double, blr_d_float: DataType := ftFloat;
337	<	blr_short:
338	<	begin
339	<	sqlscale := Query.Current.ByName('RDB$FIELD_SCALE').AsInteger; {do not localize}
340	<	if (sqlscale = 0) then
341	<	DataType := ftSmallInt
342	<	else
343	<	begin
344	<	DataType := ftBCD;
345	<	Precision := 4;
346	<	end;
347	<	end;
348	<	blr_long:
349	<	begin
350	<	sqlscale := Query.Current.ByName('RDB$FIELD_SCALE').AsInteger; {do not localize}
351	<	if (sqlscale = 0) then
352	<	DataType := ftInteger
353	<	else if (sqlscale >= (-4)) then
354	<	begin
355	<	DataType := ftBCD;
356	<	Precision := 9;
357	<	end
358	<	else
359	<	DataType := ftFloat;
360	<	end;
361	<	blr_int64:
362	<	begin
363	<	sqlscale := Query.Current.ByName('RDB$FIELD_SCALE').AsInteger; {do not localize}
364	<	if (sqlscale = 0) then
365	<	DataType := ftLargeInt
366	<	else if (sqlscale >= (-4)) then
367	<	begin
368	<	DataType := ftBCD;
369	<	Precision := 18;
370	<	end
371	<	else
372	<	DataType := ftFloat;
373	<	end;
374	<	blr_timestamp: DataType := ftDateTime;
375	<	blr_sql_time: DataType := ftTime;
376	<	blr_sql_date: DataType := ftDate;
377	<	blr_blob:
378	<	if (Query.Current.ByName('RDB$FIELD_SUB_TYPE').AsInteger = 1) then {do not localize}
379	<	DataType := ftMemo
380	<	else
381	<	DataType := ftBlob;
382	<	blr_quad:
319	>	Query.Database := DataBase;
320	>	Query.Transaction := Database.InternalTransaction;
321	>	DidActivate := false;
322	>	Query.SQL.Text := 'Select * from ' + QuoteIdentifier(DataBase.SQLDialect, FTableName);
323	>	with Query.Transaction do
324	>	begin
325	>	if not InTransaction then
326		begin
327	<	DataType := ftUnknown;
328	<	Size := sizeof (TISC_QUAD);
327	>	StartTransaction;
328	>	DidActivate := true
329		end;
330	<	else
331	<	DataType := ftUnknown;
332	<	end;
333	<	if not (Query.Current.ByName('RDB$COMPUTED_BLR').IsNull) then {do not localize}
334	<	begin
392	<	Attributes := [faReadOnly];
393	<	InternalCalcField := True
394	<	end
395	<	else
396	<	InternalCalcField := False;
397	<	if ((not InternalCalcField) and
398	<	Query.Current.ByName('RDB$DEFAULT_VALUE').IsNull and {do not localize}
399	<	(Query.Current.ByName('RDB$NULL_FLAG').AsInteger = 1) )then {do not localize}
400	<	begin
401	<	Attributes := [faRequired];
402	<	Required := True;
403	<	end;
404	<	end;
405	<	end;
406	<	FieldDefs.EndUpdate;
330	>	end;
331	>	Query.Prepare;
332	>	FieldDefsFromQuery(Query);
333	>	if DidActivate then
334	>	Query.Transaction.Rollback;
335		finally
336	<	Query.free;
409	<	Database.InternalTransaction.Commit;
336	>	Query.Free;
337		end;
338		end;
339		end;
#	Line 501 | Line 428 | var
428		Query.SQL.Text := 'Select ''foo'' from RDB$RELATION_CONSTRAINTS ' +
429		'where RDB$RELATION_NAME = ' +
430		'''' +
431	<	FormatIdentifierValue(Database.SQLDialect,
431	>	ExtractIdentifier(Database.SQLDialect,
432		QuoteIdentifier(DataBase.SQLDialect, FTableName)) +
433		''' ' +
434		' AND RDB$CONSTRAINT_NAME = ' +
435		'''' +
436	<	FormatIdentifierValue(Database.SQLDialect,
436	>	ExtractIdentifier(Database.SQLDialect,
437		QuoteIdentifier(DataBase.SQLDialect, Name)) +
438		''' ' +
439		'AND RDB$CONSTRAINT_TYPE = ''PRIMARY KEY''';
#	Line 538 | Line 465 | var
465		Query.SQL.Text := 'Select RDB$CONSTRAINT_NAME from RDB$RELATION_CONSTRAINTS ' +
466		'where RDB$RELATION_NAME = ' +
467		'''' +
468	<	FormatIdentifierValue(Database.SQLDialect,
468	>	ExtractIdentifier(Database.SQLDialect,
469		QuoteIdentifier(DataBase.SQLDialect, FTableName)) +
470		''' ' +
471		'AND RDB$INDEX_NAME = ' +
472		'''' +
473	<	FormatIdentifierValue(Database.SQLDialect,
473	>	ExtractIdentifier(Database.SQLDialect,
474		QuoteIdentifier(DataBase.SQLDialect, Name)) +
475		''' ' +
476		'AND RDB$CONSTRAINT_TYPE = ''PRIMARY KEY''';
#	Line 555 | Line 482 | var
482		Query.SQL.Text := 'Alter Table ' +  {do not localize}
483		QuoteIdentifier(DataBase.SQLDialect, FTableName) +
484		' Drop Constraint ' +
485	<	QuoteIdentifier(DataBase.SQLDialect, Query.Current.ByName('RDB$CONSTRAINT_NAME').AsString);
485	>	QuoteIdentifier(DataBase.SQLDialect, Query.FieldByName('RDB$CONSTRAINT_NAME').AsString);
486		Query.Prepare;
487		Query.ExecQuery;
488		IndexDefs.Updated := False;
#	Line 640 | Line 567 | var
567		Opts: TIndexOptions;
568		Flds: string;
569		Query, SubQuery: TIBSQL;
570	+	fn: string;
571	+	aField: TFieldDef;
572		begin
573		if not (csReading in ComponentState) then begin
574		if not Active and not FSwitchingIndex  then
#	Line 657 | Line 586 | begin
586		'I.RDB$SEGMENT_COUNT, S.RDB$FIELD_NAME from RDB$INDICES I, ' + {do not localize}
587		'RDB$INDEX_SEGMENTS S where I.RDB$INDEX_NAME = S.RDB$INDEX_NAME '+ {do not localize}
588		'and I.RDB$RELATION_NAME = ' + '''' + {do not localize}
589	<	FormatIdentifierValue(Database.SQLDialect,
589	>	ExtractIdentifier(Database.SQLDialect,
590		QuoteIdentifier(DataBase.SQLDialect, FTableName)) + '''';
591		Query.Prepare;
592		Query.ExecQuery;
593	<	while (not Query.EOF) and (Query.Next <> nil) do
593	>	while (not Query.EOF) and Query.Next do
594		begin
595		with IndexDefs.AddIndexDef do
596		begin
597	<	Name := TrimRight(Query.Current.ByName('RDB$INDEX_NAME').AsString); {do not localize}
597	>	Name := TrimRight(Query.FieldByName('RDB$INDEX_NAME').AsString); {do not localize}
598		Opts := [];
599		if Pos ('RDB$PRIMARY', Name) = 1 then Include(Opts, ixPrimary); {do not localize} {mbcs ok}
600	<	if Query.Current.ByName('RDB$UNIQUE_FLAG').AsInteger = 1 then Include(Opts, ixUnique); {do not localize}
601	<	if Query.Current.ByName('RDB$INDEX_TYPE').AsInteger = 2  then Include(Opts, ixDescending); {do not localize}
600	>	if Query.FieldByName('RDB$UNIQUE_FLAG').AsInteger = 1 then Include(Opts, ixUnique); {do not localize}
601	>	if Query.FieldByName('RDB$INDEX_TYPE').AsInteger = 2  then Include(Opts, ixDescending); {do not localize}
602		Options := Opts;
603	<	if (Query.Current.ByName('RDB$SEGMENT_COUNT').AsInteger = 1) then {do not localize}
604	<	Fields := Trim(Query.Current.ByName('RDB$FIELD_NAME').AsString) {do not localize}
603	>	if (Query.FieldByName('RDB$SEGMENT_COUNT').AsInteger = 1) then {do not localize}
604	>	begin
605	>	fn := Trim(Query.FieldByName('RDB$FIELD_NAME').AsString); {do not localize}
606	>	aField := GetFieldDefFromAlias(fn);
607	>	if assigned(aField) then
608	>	Fields := aField.Name
609	>	else
610	>	Fields := fn;
611	>	end
612		else begin
613		SubQuery := TIBSQL.Create(self);
614		try
#	Line 682 | Line 618 | begin
618		SubQuery.SQL.Text :=
619		'Select RDB$FIELD_NAME from RDB$INDEX_SEGMENTS where RDB$INDEX_NAME = ' + {do not localize}
620		'''' +
621	<	FormatIdentifierValue(Database.SQLDialect,
621	>	ExtractIdentifier(Database.SQLDialect,
622		QuoteIdentifier(DataBase.SQLDialect, Name)) +
623		'''' + 'ORDER BY RDB$FIELD_POSITION'; {do not localize}
624		SubQuery.Prepare;
625		SubQuery.ExecQuery;
626		Flds := '';
627	<	while (not SubQuery.EOF) and (SubQuery.Next <> nil) do
627	>	while (not SubQuery.EOF) and SubQuery.Next do
628		begin
629	+	fn := TrimRight(SubQuery.FieldByName('RDB$FIELD_NAME').AsString); {do not localize}
630	+	aField := GetFieldDefFromAlias(fn);
631	+	if assigned(aField) then
632	+	fn := aField.Name;
633		if (Flds = '') then
634	<	Flds := TrimRight(SubQuery.Current.ByName('RDB$FIELD_NAME').AsString) {do not localize}
634	>	Flds := fn
635		else begin
636		Query.Next;
637	<	Flds := Flds + ';' + TrimRight(SubQuery.Current[0].AsString);
637	>	Flds := Flds + ';' + fn;
638		end;
639		end;
640		Fields := Flds;
#	Line 729 | Line 669 | begin
669		Query.SQL.Text :=
670		'Select USER from RDB$RELATIONS where RDB$RELATION_NAME = ' + {do not localize}
671		'''' +
672	<	FormatIdentifierValue(Database.SQLDialect,
672	>	ExtractIdentifier(Database.SQLDialect,
673		QuoteIdentifier(DataBase.SQLDialect, FTableName)) + '''';
674		Query.Prepare;
675		Query.ExecQuery;
#	Line 778 | Line 718 | var
718		FieldList := FieldList +
719		QuoteIdentifier(DataBase.SQLDialect, Name) +
720		' CHAR(' + IntToStr(Size) + ')'; {do not localize}
721	<	ftBoolean, ftSmallint, ftWord:
721	>	ftBoolean:
722	>	FieldList := FieldList +
723	>	QuoteIdentifier(DataBase.SQLDialect, Name) +
724	>	' BOOLEAN'; {do not localize}
725	>	ftSmallint, ftWord:
726		FieldList := FieldList +
727		QuoteIdentifier(DataBase.SQLDialect, Name) +
728		' SMALLINT'; {do not localize}
#	Line 972 | Line 916 | begin
916		Query.SQL.Text := 'Select RDB$SYSTEM_FLAG, RDB$DBKEY_LENGTH ' + {do not localize}
917		'from RDB$RELATIONS where RDB$RELATION_NAME = ' + {do not localize}
918		'''' +
919	<	FormatIdentifierValue(Database.SQLDialect,
919	>	ExtractIdentifier(Database.SQLDialect,
920		QuoteIdentifier(DataBase.SQLDialect, FTableName)) + '''';
921		Query.Prepare;
922		Query.ExecQuery;
923	<	if (Query.Current[0].AsInteger <> 0) or
924	<	(Query.Current[1].AsInteger <> 8) then
923	>	if (Query.Fields[0].AsInteger <> 0) or
924	>	(Query.Fields[1].AsInteger <> 8) then
925		Result := False
926		else
927		Result := True;
#	Line 987 | Line 931 | begin
931		end;
932		end;
933
990	–	function TIBTable.FieldDefsStored: Boolean;
991	–	begin
992	–	Result := StoreDefs and (FieldDefs.Count > 0);
993	–	end;
994	–
934		function TIBTable.IndexDefsStored: Boolean;
935		begin
936		Result := StoreDefs and (IndexDefs.Count > 0);
#	Line 1260 | Line 1199 | begin
1199		' where RDB$VIEW_BLR is NULL and RDB$SYSTEM_FLAG = 0'; {do not localize}
1200		Query.Prepare;
1201		Query.ExecQuery;
1202	<	while (not Query.EOF) and (Query.Next <> nil) do
1203	<	FNameList.Add (TrimRight(Query.Current[0].AsString));
1202	>	while (not Query.EOF) and Query.Next  do
1203	>	FNameList.Add (TrimRight(Query.Fields[0].AsString));
1204		finally
1205		Query.Free;
1206		Database.InternalTransaction.Commit;
#	Line 1294 | Line 1233 | var
1233		SQL: TStrings;
1234		OrderByStr: string;
1235		bWhereClausePresent: Boolean;
1236	+	fn: string;
1237	+	aField: TFieldDef;
1238		begin
1239		bWhereClausePresent := False;
1240		Database.CheckActive;
#	Line 1329 | Line 1270 | begin
1270		begin
1271		if i > 0 then
1272		SQL.Text := SQL.Text + 'AND ';
1273	+	aField := FieldDefs.Find(FDetailFieldsList.Strings[i]);
1274	+	if assigned(aField) then
1275	+	fn := GetDBAliasName(aField.FieldNo)
1276	+	else
1277	+	fn := FDetailFieldsList.Strings[i]; {something wrong if we get here - but should word}
1278		SQL.Text := SQL.Text +
1279	<	QuoteIdentifier(DataBase.SQLDialect, FDetailFieldsList.Strings[i]) +
1334	<	' = :' +
1335	<	QuoteIdentifier(DataBase.SQLDialect, FMasterFieldsList.Strings[i]);
1279	>	QuoteIdentifier(DataBase.SQLDialect, fn) + ' = :' + FMasterFieldsList.Strings[i];
1280		end;
1281		end;
1282		if OrderByStr <> '' then
#	Line 1351 | Line 1295 | end;
1295		procedure TIBTable.GenerateUpdateSQL;
1296		var
1297		InsertFieldList, InsertParamList, UpdateFieldList: string;
1298	<	WherePrimaryFieldList, WhereAllFieldList: string;
1298	>	WherePrimaryFieldList, WhereAllFieldList,
1299	>	InsertReturningFieldList, UpdateReturningFieldList: string;
1300
1301		procedure GenerateFieldLists;
1302		var
1303		I: Integer;
1304	+	AllowReturningClause: boolean;
1305		begin
1306	+	{Is database Firebird 2.1 or later?}
1307	+	AllowReturningClause := (DatabaseInfo.ODSMajorVersion > 11) or
1308	+	((DatabaseInfo.ODSMajorVersion = 11) and (DatabaseInfo.ODSMinorVersion >= 1));
1309		for I := 0 to FieldDefs.Count - 1 do begin
1310	<	with FieldDefs[I] do begin
1310	>	with TIBFieldDef(FieldDefs[I]) do begin
1311	>	if AllowReturningClause then
1312	>	begin
1313	>	if (faReadOnly in Attributes) or IdentityColumn then
1314	>	begin
1315	>	if InsertReturningFieldList <> '' then
1316	>	InsertReturningFieldList := InsertReturningFieldList + ', ' +
1317	>	QuoteIdentifier(DataBase.SQLDialect, GetDBAliasName(FieldNo))
1318	>	else
1319	>	InsertReturningFieldList := ' RETURNING ' +
1320	>	QuoteIdentifier(DataBase.SQLDialect, GetDBAliasName(FieldNo))
1321	>	end;
1322	>	if (faReadOnly in Attributes)  then
1323	>	begin
1324	>	if UpdateReturningFieldList <> '' then
1325	>	UpdateReturningFieldList := UpdateReturningFieldList + ', ' +
1326	>	QuoteIdentifier(DataBase.SQLDialect, GetDBAliasName(FieldNo))
1327	>	else
1328	>	UpdateReturningFieldList := ' RETURNING ' +
1329	>	QuoteIdentifier(DataBase.SQLDialect, GetDBAliasName(FieldNo))
1330	>	end;
1331	>	end;
1332		if not (InternalCalcField or (faReadOnly in Attributes) or
1333	<	(DataType = ftUnknown)) then
1333	>	(DataType = ftUnknown)) then
1334		begin
1335	<	if ( InsertFieldList <> '' ) then begin
1336	<	InsertFieldList := InsertFieldList + ', ';
1337	<	InsertParamList := InsertParamList + ', ';
1335	>	if not IdentityColumn then
1336	>	begin
1337	>	if ( InsertFieldList <> '' ) then begin
1338	>	InsertFieldList := InsertFieldList + ', ';
1339	>	InsertParamList := InsertParamList + ', ';
1340	>	end;
1341	>	InsertFieldList := InsertFieldList +
1342	>	QuoteIdentifier(DataBase.SQLDialect, GetDBAliasName(FieldNo));
1343	>	InsertParamList := InsertParamList + ':' +  Name;
1344	>	end;
1345	>	if (UpdateFieldList <> '') then begin
1346		UpdateFieldList := UpdateFieldList + ', ';
1347		if (DataType <> ftBlob) and (DataType <>ftMemo) then
1348		WhereAllFieldList := WhereAllFieldList + ' AND ';
1349		end;
1372	–	InsertFieldList := InsertFieldList +
1373	–	QuoteIdentifier(DataBase.SQLDialect, Name);
1374	–	InsertParamList := InsertParamList + ':' +
1375	–	QuoteIdentifier(DataBase.SQLDialect, Name);
1350		UpdateFieldList := UpdateFieldList +
1351	<	QuoteIdentifier(DataBase.SQLDialect, Name) +
1352	<	' = :' +
1379	<	QuoteIdentifier(DataBase.SQLDialect, Name);
1351	>	QuoteIdentifier(DataBase.SQLDialect, GetDBAliasName(FieldNo)) +
1352	>	' = :' + Name;
1353		if (DataType <> ftBlob) and (DataType <>ftMemo) then
1354		WhereAllFieldList := WhereAllFieldList +
1355	<	QuoteIdentifier(DataBase.SQLDialect, Name) + ' = :' +
1383	<	QuoteIdentifier(DataBase.SQLDialect, Name);{do not localize}
1355	>	QuoteIdentifier(DataBase.SQLDialect, GetDBAliasName(FieldNo)) + ' = :' +  Name;
1356		end;
1357		end;
1358		end;
#	Line 1389 | Line 1361 | var
1361		procedure GenerateWherePrimaryFieldList;
1362		var
1363		i: Integer;
1364	<	tmp: String;
1364	>	tmp, fn: String;
1365	>	aField: TFieldDef;
1366		begin
1367		i := 1;
1368		while i <= Length(FPrimaryIndexFields) do
1369		begin
1370		tmp := ExtractFieldName(FPrimaryIndexFields, i);
1371	+	aField := FieldDefs.Find(tmp);
1372	+	if assigned(aField) then
1373	+	fn := GetDBAliasName(aField.FieldNo)
1374	+	else
1375	+	fn := tmp; {something wrong if we get here - but will work in most cases}
1376		tmp :=
1377	<	QuoteIdentifier(DataBase.SQLDialect, tmp) +  ' = :' +
1377	>	QuoteIdentifier(DataBase.SQLDialect, fn) +  ' = :' +
1378		QuoteIdentifier(DataBase.SQLDialect, tmp);{do not localize}
1379		if WherePrimaryFieldList <> '' then
1380		WherePrimaryFieldList :=
#	Line 1418 | Line 1396 | begin
1396		InsertSQL.Text := 'insert into ' + {do not localize}
1397		QuoteIdentifier(DataBase.SQLDialect, FTableName) +
1398		' (' + InsertFieldList + {do not localize}
1399	<	') values (' + InsertParamList + ')'; {do not localize}
1399	>	') values (' + InsertParamList + ')' + InsertReturningFieldList; {do not localize}
1400		ModifySQL.Text := 'update ' +
1401		QuoteIdentifier(DataBase.SQLDialect, FTableName) +
1402		' set ' + UpdateFieldList + {do not localize}
1403	<	' where RDB$DB_KEY = :IBX_INTERNAL_DBKEY'; {do not localize}
1403	>	' where RDB$DB_KEY = :IBX_INTERNAL_DBKEY' + UpdateReturningFieldList; {do not localize}
1404		WhereAllRefreshSQL.Text := 'select ' +  {do not localize}
1405		QuoteIdentifier(DataBase.SQLDialect, FTableName) + '.*, '
1406		+ 'RDB$DB_KEY as IBX_INTERNAL_DBKEY from ' {do not localize}
1407		+ QuoteIdentifier(DataBase.SQLDialect, FTableName) +
1408	<	' where ' + WhereAllFieldList; {do not localize}
1408	>	' where ' + WhereAllFieldList ; {do not localize}
1409		if FPrimaryIndexFields <> '' then
1410		begin
1411		GenerateWherePrimaryFieldList;

Diff Legend

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