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 1 by tony, Mon Jul 31 16:43:00 2000 UTC vs.
Revision 39 by tony, Tue May 17 08:14:52 2016 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                                                 }
31	+	{                                                                        }
32		{************************************************************************}
33
34		unit IBTable;
35
36	<	interface
36	>	{$Mode Delphi}
37
38	<	uses Windows, SysUtils, Graphics, Classes, Controls, Db, StdVCL,
39	<	IB, IBDatabase, IBCustomDataSet, IBHeader, IBSQL, IBUtils;
38	>	{$IF FPC_FULLVERSION >= 20700 }
39	>	{$codepage UTF8}
40	>	{$ENDIF}
41
42	+	interface
43	+
44	+	uses SysUtils, Classes, DB, IB,  IBCustomDataSet,
45	+	IBSQL, IBUtils;
46	+
47		type
48
49		{ TIBTable }
#	Line 103 | Line 114 | type
114		procedure Reopen;
115
116		protected
106	–	{ IProviderSupport }
107	–	function PSGetDefaultOrder: TIndexDef; override;
108	–	function PSGetKeyFields: string; override;
109	–	function PSGetTableName: string; override;
110	–	function PSGetIndexDefs(IndexTypes: TIndexOptions): TIndexDefs; override;
111	–	procedure PSSetCommandText(const CommandText: string); override;
112	–	procedure PSSetParams(AParams: TParams); override;
117
118		procedure DoOnNewRecord; override;
119		procedure GetIndexParams(const IndexName: string; FieldsIndex: Boolean;
120		var IndexedName: string);
121		function GetCanModify: Boolean; override;
122		procedure UpdateIndexDefs; override;
123	<	procedure DataEvent(Event: TDataEvent; Info: Longint); override;
124	<	procedure DefChanged(Sender: TObject); override;
123	>	procedure DataEvent(Event: TDataEvent; Info: Ptrint); override;
124	>	procedure DefChanged(Sender: TObject); virtual;
125		function GetDataSource: TDataSource; override;
126		procedure InitFieldDefs; override;
127		procedure InternalClose; override;
#	Line 137 | Line 141 | type
141		procedure DeleteIndex(const Name: string);
142		procedure DeleteTable;
143		procedure EmptyTable;
144	<	procedure GetDetailLinkFields(MasterFields, DetailFields: TList); override;
144	>	procedure GetDetailLinkFields(MasterFields, DetailFields: TList); virtual;
145		procedure GetIndexNames(List: TStrings);
146		procedure GotoCurrent(Table: TIBTable);
147		property CurrentDBKey: TIBDBKey read GetCurrentDBKey;
#	Line 147 | Line 151 | type
151		property TableNames: TStrings read GetTableNames;
152
153		published
154	+	property AutoCommit;
155		property Active;
156		property BufferChunks;
157		property CachedUpdates;
158	<	property Constraints stored ConstraintsStored;
158	>	property DataSetCloseAction;
159	>	//    property Constraints stored ConstraintsStored;
160		property DefaultIndex: Boolean read FDefaultIndex write FDefaultIndex default True;
161		property FieldDefs stored FieldDefsStored;
162		property Filter;
#	Line 234 | Line 240 | begin
240		GenerateUpdateSQL;
241		FRegenerateSQL := False;
242		end;
243	+	{  writeln(SelectSQL.Text);
244	+	writeln(InsertSQL.Text);
245	+	writeln(DeleteSQL.Text);
246	+	writeln(ModifySQL.Text); }
247		SetParams;
248		inherited InternalOpen;
249		end;
#	Line 285 | Line 295 | begin
295		QRefresh.SQL.Assign(WherePrimaryRefreshSQL)
296		else
297		QRefresh.SQL.Assign(WhereAllRefreshSQL);
298	<	inherited;
298	>	inherited InternalRefreshRow;
299		end;
300
301		procedure TIBTable.DefChanged(Sender: TObject);
#	Line 295 | Line 305 | end;
305
306		procedure TIBTable.InitFieldDefs;
307		var
308	<	sqlscale: Integer;
308	>	DidActivate: Boolean;
309		Query: TIBSQL;
310		begin
311		if FTableName = '' then IBError(ibxeNoTableName, [nil]);
312	<	if (InternalPrepared) then InternalInitFieldDefs else
312	>	if (InternalPrepared) then
313	>	InternalInitFieldDefs
314	>	else
315		begin
316	<	Database.InternalTransaction.StartTransaction;
316	>	{Get the field defs from a simple query on the table}
317	>	ActivateConnection;
318		Query := TIBSQL.Create(self);
319		try
320	<	Query.GoToFirstRecordOnExecute := False;
321	<	Query.Database := DataBase;
322	<	Query.Transaction := Database.InternalTransaction;
323	<	Query.SQL.Text := 'Select R.RDB$FIELD_NAME, R.RDB$FIELD_POSITION, ' + {do not localize}
324	<	'F.RDB$COMPUTED_BLR, F.RDB$DEFAULT_VALUE, ' + {do not localize}
325	<	'F.RDB$NULL_FLAG, ' + {do not localize}
326	<	'F.RDB$FIELD_LENGTH, F.RDB$FIELD_SCALE, ' + {do not localize}
327	<	'F.RDB$FIELD_TYPE, F.RDB$FIELD_SUB_TYPE, ' + {do not localize}
328	<	'F.RDB$EXTERNAL_LENGTH, F.RDB$EXTERNAL_SCALE, F.RDB$EXTERNAL_TYPE ' + {do not localize}
329	<	'from RDB$RELATION_FIELDS R, RDB$FIELDS F ' + {do not localize}
317	<	'where R.RDB$RELATION_NAME = ' + {do not localize}
318	<	'''' +
319	<	FormatIdentifierValue(Database.SQLDialect, FTableName) +
320	<	''' ' +
321	<	'and R.RDB$FIELD_SOURCE = F.RDB$FIELD_NAME '+ {do not localize}
322	<	'order by R.RDB$FIELD_POSITION'; {do not localize}
323	<
324	<	Query.Prepare;
325	<	Query.ExecQuery;
326	<	FieldDefs.BeginUpdate;
327	<	FieldDefs.Clear;
328	<	while (not Query.EOF) and (Query.Next <> nil) do
329	<	begin
330	<	with FieldDefs.AddFieldDef do
331	<	begin
332	<	FieldNo := Query.Current.ByName('RDB$FIELD_POSITION').AsInteger; {do not localize}
333	<	Name := TrimRight(Query.Current.ByName('RDB$FIELD_NAME').AsString); {do not localize}
334	<	case Query.Current.ByName('RDB$FIELD_TYPE').AsInteger of {do not localize}
335	<	blr_varying, blr_text: begin
336	<	DataType := ftString;
337	<	Size := Query.Current.ByName('RDB$FIELD_LENGTH').AsInteger; {do not localize}
338	<	end;
339	<	blr_float, blr_double, blr_d_float: DataType := ftFloat;
340	<	blr_short: begin
341	<	sqlscale := Query.Current.ByName('RDB$FIELD_SCALE').AsInteger; {do not localize}
342	<	if (sqlscale = 0) then
343	<	DataType := ftSmallInt
344	<	else begin
345	<	DataType := ftBCD;
346	<	Precision := 4;
347	<	end;
348	<	end;
349	<	blr_long: 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 begin
354	<	DataType := ftBCD;
355	<	Precision := 9;
356	<	end else
357	<	DataType := ftFloat;
358	<	end;
359	<	blr_int64: begin
360	<	sqlscale := Query.Current.ByName('RDB$FIELD_SCALE').AsInteger; {do not localize}
361	<	if (sqlscale = 0) then
362	<	DataType := ftLargeInt
363	<	else if (sqlscale >= (-4)) then begin
364	<	DataType := ftBCD;
365	<	Precision := 18;
366	<	end else
367	<	DataType := ftFloat;
320	>	Query.Database := DataBase;
321	>	Query.Transaction := Database.InternalTransaction;
322	>	DidActivate := false;
323	>	Query.SQL.Text := 'Select * from ' + QuoteIdentifier(DataBase.SQLDialect, FTableName);
324	>	with Query.Transaction do
325	>	begin
326	>	if not InTransaction then
327	>	begin
328	>	StartTransaction;
329	>	DidActivate := true
330		end;
331	<	blr_timestamp: DataType := ftDateTime;
332	<	blr_sql_time: DataType := ftTime;
333	<	blr_sql_date: DataType := ftDate;
334	<	blr_blob:
335	<	if (Query.Current.ByName('RDB$FIELD_SUB_TYPE').AsInteger = 1) then {do not localize}
374	<	DataType := ftMemo
375	<	else
376	<	DataType := ftBlob;
377	<	blr_quad: begin
378	<	DataType := ftUnknown;
379	<	Size := sizeof (TISC_QUAD);
380	<	end;
381	<	else
382	<	DataType := ftUnknown;
383	<	end;
384	<	if not (Query.Current.ByName('RDB$COMPUTED_BLR').IsNull) then {do not localize}
385	<	begin
386	<	Attributes := [faReadOnly];
387	<	InternalCalcField := True
388	<	end
389	<	else
390	<	InternalCalcField := False;
391	<	if ((not InternalCalcField) and
392	<	Query.Current.ByName('RDB$DEFAULT_VALUE').IsNull and {do not localize}
393	<	(Query.Current.ByName('RDB$NULL_FLAG').AsInteger = 1) )then begin {do not localize}
394	<	Attributes := [faRequired];
395	<	Required := True;
396	<	end;
397	<	end;
398	<	end;
399	<	FieldDefs.EndUpdate;
331	>	end;
332	>	Query.Prepare;
333	>	if DidActivate then
334	>	Query.Transaction.Rollback;
335	>	FieldDefsFromQuery(Query);
336		finally
337	<	Query.free;
402	<	Database.InternalTransaction.Commit;
337	>	Query.Free;
338		end;
339		end;
340		end;
#	Line 425 | Line 360 | begin
360		if (ixPrimary in Options) then
361		begin
362		Query.SQL.Text := 'Alter Table ' + {do not localize}
363	<	FormatIdentifier(Database.SQLDialect, FTableName) +
363	>	QuoteIdentifier(Database.SQLDialect, FTableName) +
364		' Add CONSTRAINT ' +   {do not localize}
365	<	FormatIdentifier(Database.SQLDialect, Name)
365	>	QuoteIdentifier(Database.SQLDialect, Name)
366		+ ' Primary Key (' + {do not localize}
367		FormatFieldsList(Fields) +
368		')';
369		end
370		else if ([ixUnique, ixDescending] * Options = [ixUnique, ixDescending]) then
371		Query.SQL.Text := 'Create unique Descending Index ' + {do not localize}
372	<	FormatIdentifier(Database.SQLDialect, Name) +
372	>	QuoteIdentifier(Database.SQLDialect, Name) +
373		' on ' + {do not localize}
374	<	FormatIdentifier(Database.SQLDialect, FTableName) +
374	>	QuoteIdentifier(Database.SQLDialect, FTableName) +
375		' (' + FieldList + ')'
376		else if (ixUnique in Options) then
377		Query.SQL.Text := 'Create unique Index ' + {do not localize}
378	<	FormatIdentifier(Database.SQLDialect, Name) +
378	>	QuoteIdentifier(Database.SQLDialect, Name) +
379		' on ' + {do not localize}
380	<	FormatIdentifier(Database.SQLDialect, FTableName) +
380	>	QuoteIdentifier(Database.SQLDialect, FTableName) +
381		' (' + FieldList + ')'
382		else if (ixDescending in Options) then
383		Query.SQL.Text := 'Create Descending Index ' + {do not localize}
384	<	FormatIdentifier(Database.SQLDialect, Name) +
384	>	QuoteIdentifier(Database.SQLDialect, Name) +
385		' on ' + {do not localize}
386	<	FormatIdentifier(Database.SQLDialect, FTableName) +
386	>	QuoteIdentifier(Database.SQLDialect, FTableName) +
387		' (' + FieldList + ')'
388		else
389		Query.SQL.Text := 'Create Index ' + {do not localize}
390	<	FormatIdentifier(Database.SQLDialect, Name) +
390	>	QuoteIdentifier(Database.SQLDialect, Name) +
391		' on ' + {do not localize}
392	<	FormatIdentifier(Database.SQLDialect, FTableName) +
392	>	QuoteIdentifier(Database.SQLDialect, FTableName) +
393		' (' + FieldList + ')';
394		Query.Prepare;
395		Query.ExecQuery;
#	Line 475 | Line 410 | var
410		Query.Database := DataBase;
411		Query.Transaction := Transaction;
412		Query.SQL.Text := 'Drop index ' +  {do not localize}
413	<	FormatIdentifier(Database.SQLDialect, Name);
413	>	QuoteIdentifier(Database.SQLDialect, Name);
414		Query.Prepare;
415		Query.ExecQuery;
416		IndexDefs.Updated := False;
#	Line 494 | Line 429 | var
429		Query.SQL.Text := 'Select ''foo'' from RDB$RELATION_CONSTRAINTS ' +
430		'where RDB$RELATION_NAME = ' +
431		'''' +
432	<	FormatIdentifierValue(Database.SQLDialect, FTableName) +
432	>	FormatIdentifierValue(Database.SQLDialect,
433	>	QuoteIdentifier(DataBase.SQLDialect, FTableName)) +
434		''' ' +
435		' AND RDB$CONSTRAINT_NAME = ' +
436		'''' +
437	<	FormatIdentifierValue(Database.SQLDialect, Name) +
437	>	FormatIdentifierValue(Database.SQLDialect,
438	>	QuoteIdentifier(DataBase.SQLDialect, Name)) +
439		''' ' +
440		'AND RDB$CONSTRAINT_TYPE = ''PRIMARY KEY''';
441		Query.Prepare;
#	Line 507 | Line 444 | var
444		begin
445		Query.Close;
446		Query.SQL.Text := 'Alter Table ' +  {do not localize}
447	<	FormatIdentifier(Database.SQLDialect, FTableName) +
447	>	QuoteIdentifier(DataBase.SQLDialect, FTableName) +
448		' Drop Constraint ' +
449	<	FormatIdentifier(Database.SQLDialect, Name);
449	>	QuoteIdentifier(DataBase.SQLDialect, Name);
450		Query.Prepare;
451		Query.ExecQuery;
452		IndexDefs.Updated := False;
#	Line 529 | Line 466 | var
466		Query.SQL.Text := 'Select RDB$CONSTRAINT_NAME from RDB$RELATION_CONSTRAINTS ' +
467		'where RDB$RELATION_NAME = ' +
468		'''' +
469	<	FormatIdentifierValue(Database.SQLDialect, FTableName) +
469	>	FormatIdentifierValue(Database.SQLDialect,
470	>	QuoteIdentifier(DataBase.SQLDialect, FTableName)) +
471		''' ' +
472		'AND RDB$INDEX_NAME = ' +
473		'''' +
474	<	FormatIdentifierValue(Database.SQLDialect, Name) +
474	>	FormatIdentifierValue(Database.SQLDialect,
475	>	QuoteIdentifier(DataBase.SQLDialect, Name)) +
476		''' ' +
477		'AND RDB$CONSTRAINT_TYPE = ''PRIMARY KEY''';
478		Query.Prepare;
#	Line 542 | Line 481 | var
481		begin
482		Query.Close;
483		Query.SQL.Text := 'Alter Table ' +  {do not localize}
484	<	FormatIdentifier(Database.SQLDialect, FTableName) +
484	>	QuoteIdentifier(DataBase.SQLDialect, FTableName) +
485		' Drop Constraint ' +
486	<	FormatIdentifier(Database.SQLDialect, Query.Current.ByName('RDB$CONSTRAINT_NAME').AsString);
486	>	QuoteIdentifier(DataBase.SQLDialect, Query.Current.ByName('RDB$CONSTRAINT_NAME').AsString);
487		Query.Prepare;
488		Query.ExecQuery;
489		IndexDefs.Updated := False;
#	Line 629 | Line 568 | var
568		Opts: TIndexOptions;
569		Flds: string;
570		Query, SubQuery: TIBSQL;
571	+	fn: string;
572	+	aField: TFieldDef;
573		begin
574		if not (csReading in ComponentState) then begin
575		if not Active and not FSwitchingIndex  then
#	Line 646 | Line 587 | begin
587		'I.RDB$SEGMENT_COUNT, S.RDB$FIELD_NAME from RDB$INDICES I, ' + {do not localize}
588		'RDB$INDEX_SEGMENTS S where I.RDB$INDEX_NAME = S.RDB$INDEX_NAME '+ {do not localize}
589		'and I.RDB$RELATION_NAME = ' + '''' + {do not localize}
590	<	FormatIdentifierValue(Database.SQLDialect, FTableName) + '''';
590	>	FormatIdentifierValue(Database.SQLDialect,
591	>	QuoteIdentifier(DataBase.SQLDialect, FTableName)) + '''';
592		Query.Prepare;
593		Query.ExecQuery;
594		while (not Query.EOF) and (Query.Next <> nil) do
#	Line 660 | Line 602 | begin
602		if Query.Current.ByName('RDB$INDEX_TYPE').AsInteger = 2  then Include(Opts, ixDescending); {do not localize}
603		Options := Opts;
604		if (Query.Current.ByName('RDB$SEGMENT_COUNT').AsInteger = 1) then {do not localize}
605	<	Fields := Trim(Query.Current.ByName('RDB$FIELD_NAME').AsString) {do not localize}
605	>	begin
606	>	fn := Trim(Query.Current.ByName('RDB$FIELD_NAME').AsString); {do not localize}
607	>	aField := GetFieldDefFromAlias(fn);
608	>	if assigned(aField) then
609	>	Fields := aField.Name
610	>	else
611	>	Fields := fn;
612	>	end
613		else begin
614		SubQuery := TIBSQL.Create(self);
615		try
#	Line 670 | Line 619 | begin
619		SubQuery.SQL.Text :=
620		'Select RDB$FIELD_NAME from RDB$INDEX_SEGMENTS where RDB$INDEX_NAME = ' + {do not localize}
621		'''' +
622	<	FormatIdentifierValue(Database.SQLDialect, Name) +
622	>	FormatIdentifierValue(Database.SQLDialect,
623	>	QuoteIdentifier(DataBase.SQLDialect, Name)) +
624		'''' + 'ORDER BY RDB$FIELD_POSITION'; {do not localize}
625		SubQuery.Prepare;
626		SubQuery.ExecQuery;
627		Flds := '';
628		while (not SubQuery.EOF) and (SubQuery.Next <> nil) do
629		begin
630	+	fn := TrimRight(SubQuery.Current.ByName('RDB$FIELD_NAME').AsString); {do not localize}
631	+	aField := GetFieldDefFromAlias(fn);
632	+	if assigned(aField) then
633	+	fn := aField.Name;
634		if (Flds = '') then
635	<	Flds := TrimRight(SubQuery.Current.ByName('RDB$FIELD_NAME').AsString) {do not localize}
635	>	Flds := fn
636		else begin
637		Query.Next;
638	<	Flds := Flds + ';' + TrimRight(SubQuery.Current[0].AsString);
638	>	Flds := Flds + ';' + fn;
639		end;
640		end;
641		Fields := Flds;
#	Line 716 | Line 670 | begin
670		Query.SQL.Text :=
671		'Select USER from RDB$RELATIONS where RDB$RELATION_NAME = ' + {do not localize}
672		'''' +
673	<	FormatIdentifierValue(Database.SQLDialect, FTableName) + '''';
673	>	FormatIdentifierValue(Database.SQLDialect,
674	>	QuoteIdentifier(DataBase.SQLDialect, FTableName)) + '''';
675		Query.Prepare;
676		Query.ExecQuery;
677		Result := not Query.EOF;
#	Line 758 | Line 713 | var
713		case DataType of
714		ftString:
715		FieldList := FieldList +
716	<	FormatIdentifier(Database.SQLDialect, Name) +
716	>	QuoteIdentifier(DataBase.SQLDialect, Name) +
717		' VARCHAR(' + IntToStr(Size) + ')'; {do not localize}
718		ftFixedChar:
719		FieldList := FieldList +
720	<	FormatIdentifier(Database.SQLDialect, Name) +
720	>	QuoteIdentifier(DataBase.SQLDialect, Name) +
721		' CHAR(' + IntToStr(Size) + ')'; {do not localize}
722	<	ftBoolean, ftSmallint, ftWord:
722	>	ftBoolean:
723		FieldList := FieldList +
724	<	FormatIdentifier(Database.SQLDialect, Name) +
724	>	QuoteIdentifier(DataBase.SQLDialect, Name) +
725	>	' BOOLEAN'; {do not localize}
726	>	ftSmallint, ftWord:
727	>	FieldList := FieldList +
728	>	QuoteIdentifier(DataBase.SQLDialect, Name) +
729		' SMALLINT'; {do not localize}
730		ftInteger:
731		FieldList := FieldList +
732	<	FormatIdentifier(Database.SQLDialect, Name) +
732	>	QuoteIdentifier(DataBase.SQLDialect, Name) +
733		' INTEGER'; {do not localize}
734		ftFloat, ftCurrency:
735		FieldList := FieldList +
736	<	FormatIdentifier(Database.SQLDialect, Name) +
736	>	QuoteIdentifier(DataBase.SQLDialect, Name) +
737		' DOUBLE PRECISION'; {do not localize}
738		ftBCD: begin
739		if (Database.SQLDialect = 1) then begin
#	Line 785 | Line 744 | var
744		end;
745		if (Precision <= 4 ) then
746		FieldList := FieldList +
747	<	FormatIdentifier(Database.SQLDialect, Name) +
747	>	QuoteIdentifier(DataBase.SQLDialect, Name) +
748		' Numeric(18, 4)' {do not localize}
749		else
750		FieldList := FieldList +
751	<	FormatIdentifier(Database.SQLDialect, Name) +
751	>	QuoteIdentifier(DataBase.SQLDialect, Name) +
752		' Numeric(' + IntToStr(Precision) + ', 4)'; {do not localize}
753		end;
754		ftDate:
755		FieldList := FieldList +
756	<	FormatIdentifier(Database.SQLDialect, Name) +
756	>	QuoteIdentifier(DataBase.SQLDialect, Name) +
757		' DATE'; {do not localize}
758		ftTime:
759		FieldList := FieldList +
760	<	FormatIdentifier(Database.SQLDialect, Name) +
760	>	QuoteIdentifier(DataBase.SQLDialect, Name) +
761		' TIME'; {do not localize}
762		ftDateTime:
763		if (Database.SQLDialect = 1) then
764		FieldList := FieldList +
765	<	FormatIdentifier(Database.SQLDialect, Name) +
765	>	QuoteIdentifier(DataBase.SQLDialect, Name) +
766		' DATE' {do not localize}
767		else
768		FieldList := FieldList +
769	<	FormatIdentifier(Database.SQLDialect, Name) +
769	>	QuoteIdentifier(DataBase.SQLDialect, Name) +
770		' TIMESTAMP'; {do not localize}
771		ftLargeInt:
772		if (Database.SQLDialect = 1) then
773		IBError(ibxeFieldUnsupportedType,[nil])
774		else
775		FieldList := FieldList +
776	<	FormatIdentifier(Database.SQLDialect, Name) +
776	>	QuoteIdentifier(DataBase.SQLDialect, Name) +
777		' Numeric(18, 0)'; {do not localize}
778		ftBlob, ftMemo:
779		FieldList := FieldList +
780	<	FormatIdentifier(Database.SQLDialect, Name) +
780	>	QuoteIdentifier(DataBase.SQLDialect, Name) +
781		' BLOB SUB_TYPE 1'; {do not localize}
782		ftBytes, ftVarBytes, ftGraphic..ftTypedBinary:
783		FieldList := FieldList +
784	<	FormatIdentifier(Database.SQLDialect, Name) +
784	>	QuoteIdentifier(DataBase.SQLDialect, Name) +
785		' BLOB SUB_TYPE 0'; {do not localize}
786		ftUnknown, ftADT, ftArray, ftReference, ftDataSet,
787		ftCursor, ftWideString, ftAutoInc:
#	Line 848 | Line 807 | var
807		Query.Database := Database;
808		Query.transaction := Transaction;
809		Query.SQL.Text := 'Create Table ' +
810	<	FormatIdentifier(Database.SQLDialect, FTableName) +
810	>	QuoteIdentifier(DataBase.SQLDialect, FTableName) +
811		' (' + FieldList; {do not localize}
812		for I := 0 to IndexDefs.Count - 1 do
813		with IndexDefs[I] do
814		if ixPrimary in Options then
815		begin
816		Query.SQL.Text := Query.SQL.Text + ', CONSTRAINT ' +
817	<	FormatIdentifier(Database.SQLDialect, Name) +
817	>	QuoteIdentifier(DataBase.SQLDialect, Name) +
818		' Primary Key (' +
819		FormatFieldsList(Fields) +
820		')';
#	Line 895 | Line 854 | begin
854		Query.Database := DataBase;
855		Query.Transaction := Transaction;
856		Query.SQL.Text := 'drop table ' +  {do not localize}
857	<	FormatIdentifier(Database.SQLDialect, FTableName);
857	>	QuoteIdentifier(DataBase.SQLDialect, FTableName);
858		Query.Prepare;
859		Query.ExecQuery;
860		finally
#	Line 914 | Line 873 | begin
873		Query.Database := DataBase;
874		Query.Transaction := Transaction;
875		Query.SQL.Text := 'delete from ' + {do not localize}
876	<	FormatIdentifier(Database.SQLDialect, FTableName);
876	>	QuoteIdentifier(DataBase.SQLDialect, FTableName);
877		Query.Prepare;
878		Query.ExecQuery;
879		if Active then
#	Line 927 | Line 886 | begin
886		end;
887		end;
888
889	<	procedure TIBTable.DataEvent(Event: TDataEvent; Info: Longint);
889	>	procedure TIBTable.DataEvent(Event: TDataEvent; Info: Ptrint);
890		begin
891		if Event = dePropertyChange then begin
892		IndexDefs.Updated := False;
#	Line 958 | Line 917 | begin
917		Query.SQL.Text := 'Select RDB$SYSTEM_FLAG, RDB$DBKEY_LENGTH ' + {do not localize}
918		'from RDB$RELATIONS where RDB$RELATION_NAME = ' + {do not localize}
919		'''' +
920	<	FormatIdentifierValue(Database.SQLDialect, FTableName) + '''';
920	>	FormatIdentifierValue(Database.SQLDialect,
921	>	QuoteIdentifier(DataBase.SQLDialect, FTableName)) + '''';
922		Query.Prepare;
923		Query.ExecQuery;
924		if (Query.Current[0].AsInteger <> 0) or
#	Line 1048 | Line 1008 | var
1008		i: Integer;
1009		begin
1010		if Database.SQLDialect = 1 then begin
1011	<	Value := FormatIdentifier(Database.SQLDialect, Value);
1011	>	Value := QuoteIdentifier(Database.SQLDialect, Value);
1012		Result := StringReplace (Value, ';', ', ', [rfReplaceAll]);
1013		end
1014		else begin
#	Line 1058 | Line 1018 | begin
1018		begin
1019		FieldName := ExtractFieldName(Value, i);
1020		if Result = '' then
1021	<	Result := FormatIdentifier(Database.SQLDialect, FieldName)
1021	>	Result := QuoteIdentifier(Database.SQLDialect, FieldName)
1022		else
1023	<	Result := Result + ', ' + FormatIdentifier(Database.SQLDialect, FieldName);
1023	>	Result := Result + ', ' + QuoteIdentifier(Database.SQLDialect, FieldName);
1024		end;
1025		end;
1026		end;
#	Line 1279 | Line 1239 | var
1239		SQL: TStrings;
1240		OrderByStr: string;
1241		bWhereClausePresent: Boolean;
1242	+	fn: string;
1243	+	aField: TFieldDef;
1244		begin
1245		bWhereClausePresent := False;
1246		Database.CheckActive;
#	Line 1293 | Line 1255 | begin
1255		OrderByStr := FormatFieldsList(FPrimaryIndexFields);
1256		SQL := TStringList.Create;
1257		SQL.Text := 'select ' + {do not localize}
1258	<	FormatIdentifier(Database.SQLDialect, FTableName) + '.*, '
1258	>	QuoteIdentifier(DataBase.SQLDialect, FTableName) + '.*, ' {do not localize}
1259		+ 'RDB$DB_KEY as IBX_INTERNAL_DBKEY from ' {do not localize}
1260	<	+ FormatIdentifier(Database.SQLDialect, FTableName);
1260	>	+ QuoteIdentifier(DataBase.SQLDialect, FTableName);
1261		if Filtered and (Filter <> '') then
1262		begin
1263		SQL.Text := SQL.Text + ' where ' + Filter; {do not localize}
#	Line 1314 | Line 1276 | begin
1276		begin
1277		if i > 0 then
1278		SQL.Text := SQL.Text + 'AND ';
1279	+	aField := FieldDefs.Find(FDetailFieldsList.Strings[i]);
1280	+	if assigned(aField) then
1281	+	fn := GetDBAliasName(aField.FieldNo)
1282	+	else
1283	+	fn := FDetailFieldsList.Strings[i]; {something wrong if we get here - but should word}
1284		SQL.Text := SQL.Text +
1285	<	FormatIdentifier(Database.SQLDialect, FDetailFieldsList.Strings[i]) +
1319	<	' = :' +
1320	<	FormatIdentifier(Database.SQLDialect, FMasterFieldsList.Strings[i]);
1285	>	QuoteIdentifier(DataBase.SQLDialect, fn) + ' = :' + FMasterFieldsList.Strings[i];
1286		end;
1287		end;
1288		if OrderByStr <> '' then
1289		SQL.Text := SQL.Text + ' order by ' + OrderByStr; {do not localize}
1290		SelectSQL.Assign(SQL);
1291		RefreshSQL.Text := 'select ' + {do not localize}
1292	<	FormatIdentifier(Database.SQLDialect, FTableName) + '.*, '
1292	>	QuoteIdentifier(DataBase.SQLDialect, FTableName) + '.*, ' {do not localize}
1293		+ 'RDB$DB_KEY as IBX_INTERNAL_DBKEY from ' {do not localize}
1294	<	+ FormatIdentifier(Database.SQLDialect, FTableName) +
1294	>	+ QuoteIdentifier(DataBase.SQLDialect, FTableName) +
1295		' where RDB$DB_KEY = :IBX_INTERNAL_DBKEY'; {do not localize}
1296		WhereDBKeyRefreshSQL.Assign(RefreshSQL);
1297		InternalPrepare;
#	Line 1355 | Line 1320 | var
1320		WhereAllFieldList := WhereAllFieldList + ' AND ';
1321		end;
1322		InsertFieldList := InsertFieldList +
1323	<	FormatIdentifier(Database.SQLDialect, Name);
1324	<	InsertParamList := InsertParamList + ':' +
1360	<	FormatIdentifier(Database.SQLDialect, Name);
1323	>	QuoteIdentifier(DataBase.SQLDialect, GetDBAliasName(FieldNo));
1324	>	InsertParamList := InsertParamList + ':' +  Name;
1325		UpdateFieldList := UpdateFieldList +
1326	<	FormatIdentifier(Database.SQLDialect, Name) +
1327	<	' = :' +
1364	<	FormatIdentifier(Database.SQLDialect, Name);
1326	>	QuoteIdentifier(DataBase.SQLDialect, GetDBAliasName(FieldNo)) +
1327	>	' = :' + Name;
1328		if (DataType <> ftBlob) and (DataType <>ftMemo) then
1329		WhereAllFieldList := WhereAllFieldList +
1330	<	FormatIdentifier(Database.SQLDialect, Name) + ' = :' +
1368	<	FormatIdentifier(Database.SQLDialect, Name);{do not localize}
1330	>	QuoteIdentifier(DataBase.SQLDialect, GetDBAliasName(FieldNo)) + ' = :' +  Name;
1331		end;
1332		end;
1333		end;
#	Line 1374 | Line 1336 | var
1336		procedure GenerateWherePrimaryFieldList;
1337		var
1338		i: Integer;
1339	<	tmp: String;
1339	>	tmp, fn: String;
1340	>	aField: TFieldDef;
1341		begin
1342		i := 1;
1343		while i <= Length(FPrimaryIndexFields) do
1344		begin
1345		tmp := ExtractFieldName(FPrimaryIndexFields, i);
1346	+	aField := FieldDefs.Find(tmp);
1347	+	if assigned(aField) then
1348	+	fn := GetDBAliasName(aField.FieldNo)
1349	+	else
1350	+	fn := tmp; {something wrong if we get here - but will work in most cases}
1351		tmp :=
1352	<	FormatIdentifier(Database.SQLDialect, tmp) +  ' = :' +
1353	<	FormatIdentifier(Database.SQLDialect, tmp);{do not localize}
1352	>	QuoteIdentifier(DataBase.SQLDialect, fn) +  ' = :' +
1353	>	QuoteIdentifier(DataBase.SQLDialect, tmp);{do not localize}
1354		if WherePrimaryFieldList <> '' then
1355		WherePrimaryFieldList :=
1356		WherePrimaryFieldList + ' AND ' + tmp
#	Line 1397 | Line 1365 | begin
1365		else
1366		begin
1367		DeleteSQL.Text := 'delete from ' + {do not localize}
1368	<	FormatIdentifier(Database.SQLDialect, FTableName) +
1368	>	QuoteIdentifier(DataBase.SQLDialect, FTableName) +
1369		' where RDB$DB_KEY = ' + ':IBX_INTERNAL_DBKEY'; {do not localize}
1370		GenerateFieldLists;
1371		InsertSQL.Text := 'insert into ' + {do not localize}
1372	<	FormatIdentifier(Database.SQLDialect, FTableName) +
1372	>	QuoteIdentifier(DataBase.SQLDialect, FTableName) +
1373		' (' + InsertFieldList + {do not localize}
1374		') values (' + InsertParamList + ')'; {do not localize}
1375		ModifySQL.Text := 'update ' +
1376	<	FormatIdentifier(Database.SQLDialect, FTableName) +
1376	>	QuoteIdentifier(DataBase.SQLDialect, FTableName) +
1377		' set ' + UpdateFieldList + {do not localize}
1378		' where RDB$DB_KEY = :IBX_INTERNAL_DBKEY'; {do not localize}
1379		WhereAllRefreshSQL.Text := 'select ' +  {do not localize}
1380	<	FormatIdentifier(Database.SQLDialect, FTableName) + '.*, '
1380	>	QuoteIdentifier(DataBase.SQLDialect, FTableName) + '.*, '
1381		+ 'RDB$DB_KEY as IBX_INTERNAL_DBKEY from ' {do not localize}
1382	<	+ FormatIdentifier(Database.SQLDialect, FTableName) +
1382	>	+ QuoteIdentifier(DataBase.SQLDialect, FTableName) +
1383		' where ' + WhereAllFieldList; {do not localize}
1384		if FPrimaryIndexFields <> '' then
1385		begin
1386		GenerateWherePrimaryFieldList;
1387		WherePrimaryRefreshSQL.Text := 'select ' + {do not localize}
1388	<	FormatIdentifier(Database.SQLDialect, FTableName) + '.*, ' {do not localize}
1388	>	QuoteIdentifier(DataBase.SQLDialect, FTableName) + '.*, ' {do not localize}
1389		+ 'RDB$DB_KEY as IBX_INTERNAL_DBKEY from ' {do not localize}
1390	<	+ FormatIdentifier(Database.SQLDialect, FTableName) +
1390	>	+ QuoteIdentifier(DataBase.SQLDialect, FTableName) +
1391		' where ' + WherePrimaryFieldList; {do not localize}
1392		end;
1393		try
#	Line 1499 | Line 1467 | begin
1467		begin
1468		SetState(dsInactive);
1469		CloseCursor;
1470	<	OpenCursor;
1470	>	OpenCursor(false);
1471		SetState(dsBrowse);
1472		end;
1473		finally
#	Line 1507 | Line 1475 | begin
1475		end;
1476		end;
1477
1510	–	{ TIBTable IProviderSupport }
1511	–
1512	–	function TIBTable.PSGetDefaultOrder: TIndexDef;
1513	–
1514	–	function GetIdx(IdxType: TIndexOption): TIndexDef;
1515	–	var
1516	–	i: Integer;
1517	–	begin
1518	–	Result := nil;
1519	–	for i := 0 to IndexDefs.Count - 1 do
1520	–	if IdxType in IndexDefs[i].Options then
1521	–	try
1522	–	Result := IndexDefs[i];
1523	–	GetFieldList(nil, Result.Fields);
1524	–	break;
1525	–	except
1526	–	Result := nil;
1527	–	end;
1528	–	end;
1529	–
1530	–	var
1531	–	DefIdx: TIndexDef;
1532	–	begin
1533	–	DefIdx := nil;
1534	–	IndexDefs.Update;
1535	–	try
1536	–	if IndexName <> '' then
1537	–	DefIdx := IndexDefs.Find(IndexName)
1538	–	else if IndexFieldNames <> '' then
1539	–	DefIdx := IndexDefs.FindIndexForFields(IndexFieldNames);
1540	–	if Assigned(DefIdx) then
1541	–	GetFieldList(nil, DefIdx.Fields);
1542	–	except
1543	–	DefIdx := nil;
1544	–	end;
1545	–	if not Assigned(DefIdx) then
1546	–	DefIdx := GetIdx(ixPrimary);
1547	–	if not Assigned(DefIdx) then
1548	–	DefIdx := GetIdx(ixUnique);
1549	–	if Assigned(DefIdx) then
1550	–	begin
1551	–	Result := TIndexDef.Create(nil);
1552	–	Result.Assign(DefIdx);
1553	–	end else
1554	–	Result := nil;
1555	–	end;
1556	–
1557	–	function TIBTable.PSGetIndexDefs(IndexTypes: TIndexOptions): TIndexDefs;
1558	–	begin
1559	–	Result := GetIndexDefs(IndexDefs, IndexTypes);
1560	–	end;
1561	–
1562	–	function TIBTable.PSGeTTableName: string;
1563	–	begin
1564	–	Result := FTableName;
1565	–	end;
1566	–
1567	–	procedure TIBTable.PSSetParams(AParams: TParams);
1568	–	begin
1569	–	if AParams.Count > 0 then
1570	–	Open;
1571	–	PSReset;
1572	–	end;
1573	–
1574	–	procedure TIBTable.PSSetCommandText(const CommandText: string);
1575	–	begin
1576	–	if CommandText <> '' then
1577	–	TableName := CommandText;
1578	–	end;
1579	–
1580	–	function TIBTable.PSGetKeyFields: string;
1581	–	var
1582	–	i, Idx: Integer;
1583	–	IndexFound: Boolean;
1584	–	begin
1585	–	Result := inherited PSGetKeyFields;
1586	–	if Result = '' then
1587	–	begin
1588	–	if not Exists then Exit;
1589	–	IndexFound := False;
1590	–	IndexDefs.Update;
1591	–	FieldDefs.Update;
1592	–	for i := 0 to IndexDefs.Count - 1 do
1593	–	if ixUnique in IndexDefs[I].Options then
1594	–	begin
1595	–	Idx := 1;
1596	–	Result := IndexDefs[I].Fields;
1597	–	IndexFound := False;
1598	–	while Idx <= Length(Result) do
1599	–	begin
1600	–	IndexFound := FindField(ExtractFieldName(Result, Idx)) <> nil;
1601	–	if not IndexFound then Break;
1602	–	end;
1603	–	if IndexFound then Break;
1604	–	end;
1605	–	if not IndexFound then
1606	–	Result := '';
1607	–	end;
1608	–	end;
1609	–
1478		end.

Diff Legend

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