ViewVC Help

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

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

Comparing ibx/trunk/runtime/IBDatabase.pas (file contents):
Revision 33 by tony, Sat Jul 18 12:30:52 2015 UTC vs.
Revision 143 by tony, Fri Feb 23 12:11:21 2018 UTC

#	Line 27 | Line 27
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                                                 }
30	>	{    Associates Ltd 2011 - 2018                                               }
31		{                                                                        }
32		{************************************************************************}
33
#	Line 35 | Line 35 | unit IBDatabase;
35
36		{$Mode Delphi}
37
38	+	{$codepage UTF8}
39	+
40		interface
41
42		uses
#	Line 43 | Line 45 | uses
45		{$ELSE}
46		unix,
47		{$ENDIF}
48	<	SysUtils, Classes, FPTimer, IBHeader, IBExternals, DB,
47	<	IB, CustApp;
48	>	SysUtils, Classes, FPTimer, IBExternals, DB, IB, CustApp, IBTypes;
49
50		const
51		DPBPrefix = 'isc_dpb_';
#	Line 115 | Line 116 | const
116		'set_db_readonly',
117		'set_db_sql_dialect',
118		'gfix_attach',
119	<	'gstat_attach'
120	<	);
119	>	'gstat_attach',
120	>	'set_db_charset',
121	>	'gsec_attach',
122	>	'address_path' ,
123	>	'process_id',
124	>	'no_db_triggers',
125	>	'trusted_auth',
126	>	'process_name',
127	>	'trusted_role',
128	>	'org_filename',
129	>	'utf8_ilename',
130	>	'ext_call_depth',
131	>	'auth_block',
132	>	'client_version',
133	>	'remote_protocol',
134	>	'host_name',
135	>	'os_user',
136	>	'specific_auth_data',
137	>	'auth_plugin_list',
138	>	'auth_plugin_name',
139	>	'config',
140	>	'nolinger',
141	>	'reset_icu',
142	>	'map_attach'
143	>	);
144
145		TPBPrefix = 'isc_tpb_';
146		TPBConstantNames: array[1..isc_tpb_last_tpb_constant] of string = (
#	Line 139 | Line 163 | const
163		'rec_version',
164		'no_rec_version',
165		'restart_requests',
166	<	'no_auto_undo'
166	>	'no_auto_undo',
167	>	'lock_timeout'
168		);
169
170		type
#	Line 155 | Line 180 | type
180		{ TIBDatabase }
181		TIBDataBase = class(TCustomConnection)
182		private
183	+	FAttachment: IAttachment;
184	+	FCreateDatabase: boolean;
185	+	FCreateIfNotExists: boolean;
186		FAllowStreamedConnected: boolean;
187		FHiddenPassword: string;
188	<	FIBLoaded: Boolean;
188	>	FOnCreateDatabase: TNotifyEvent;
189		FOnLogin: TIBDatabaseLoginEvent;
190		FSQLHourGlass: Boolean;
191		FTraceFlags: TTraceFlags;
164	–	FDBSQLDialect: Integer;
192		FSQLDialect: Integer;
193		FOnDialectDowngradeWarning: TNotifyEvent;
167	–	FCanTimeout: Boolean;
194		FSQLObjects: TList;
195		FTransactions: TList;
196		FDBName: TIBFileName;
197		FDBParams: TStrings;
198		FDBParamsChanged: Boolean;
173	–	FDPB: PChar;
174	–	FDPBLength: Short;
175	–	FHandle: TISC_DB_HANDLE;
176	–	FHandleIsShared: Boolean;
199		FOnIdleTimer: TNotifyEvent;
200		FDefaultTransaction: TIBTransaction;
201		FInternalTransaction: TIBTransaction;
180	–	FStreamedConnected: Boolean;
202		FTimer: TFPTimer;
203		FUserNames: TStringList;
204		FDataSets: TList;
205		FLoginCalled: boolean;
206	<	FCharSetSizes: array of integer;
206	>	FUseDefaultSystemCodePage: boolean;
207		procedure EnsureInactive;
208	+	function GetAuthenticationMethod: string;
209		function GetDBSQLDialect: Integer;
210	<	function GetSQLDialect: Integer;
210	>	function GetDefaultCharSetID: integer;
211	>	function GetDefaultCharSetName: AnsiString;
212	>	function GetDefaultCodePage: TSystemCodePage;
213	>	function GetRemoteProtocol: string;
214		procedure SetSQLDialect(const Value: Integer);
215		procedure ValidateClientSQLDialect;
216		procedure DBParamsChange(Sender: TObject);
217		procedure DBParamsChanging(Sender: TObject);
218		function GetSQLObject(Index: Integer): TIBBase;
219		function GetSQLObjectCount: Integer;
195	–	function GetDBParamByDPB(const Idx: Integer): String;
220		function GetIdleTimer: Integer;
221		function GetTransaction(Index: Integer): TIBTransaction;
222		function GetTransactionCount: Integer;
223	<	function Login: Boolean;
200	<	procedure LoadCharSetInfo;
223	>	function Login(var aDatabaseName: string): Boolean;
224		procedure SetDatabaseName(const Value: TIBFileName);
225		procedure SetDBParamByDPB(const Idx: Integer; Value: String);
226		procedure SetDBParams(Value: TStrings);
#	Line 228 | Line 251 | type
251		procedure CloseDataSets;
252		procedure CheckActive;
253		procedure CheckInactive;
254	<	procedure CreateDatabase;
254	>	procedure CreateDatabase; overload;
255	>	procedure CreateDatabase(createDatabaseSQL: string); overload;
256		procedure DropDatabase;
257		procedure ForceClose;
258		procedure GetFieldNames(const TableName: string; List: TStrings);
#	Line 236 | Line 260 | type
260		function IndexOfDBConst(st: String): Integer;
261		function TestConnected: Boolean;
262		procedure CheckDatabaseName;
239	–	function Call(ErrCode: ISC_STATUS; RaiseError: Boolean): ISC_STATUS;
263		function AddTransaction(TR: TIBTransaction): Integer;
264		function FindTransaction(TR: TIBTransaction): Integer;
265		function FindDefaultTransaction(): TIBTransaction;
266		procedure RemoveTransaction(Idx: Integer);
267		procedure RemoveTransactions;
245	–	procedure SetHandle(Value: TISC_DB_HANDLE);
268
269	<	property Handle: TISC_DB_HANDLE read FHandle;
269	>	property Attachment: IAttachment read FAttachment;
270	>	property DBSQLDialect : Integer read GetDBSQLDialect;
271		property IsReadOnly: Boolean read GetIsReadOnly;
249	–	property DBParamByDPB[const Idx: Integer]: String read GetDBParamByDPB
250	–	write SetDBParamByDPB;
272		property SQLObjectCount: Integer read GetSQLObjectCount;
273		property SQLObjects[Index: Integer]: TIBBase read GetSQLObject;
253	–	property HandleIsShared: Boolean read FHandleIsShared;
274		property TransactionCount: Integer read GetTransactionCount;
275		property Transactions[Index: Integer]: TIBTransaction read GetTransaction;
276		property InternalTransaction: TIBTransaction read FInternalTransaction;
277	+	property DefaultCharSetName: AnsiString read GetDefaultCharSetName;
278	+	property DefaultCharSetID: integer read GetDefaultCharSetID;
279	+	property DefaultCodePage: TSystemCodePage read GetDefaultCodePage;
280	+	property AuthenticationMethod: string read GetAuthenticationMethod;
281	+	property RemoteProtocol: string read GetRemoteProtocol;
282
283		published
284		property Connected;
285	+	property CreateIfNotExists: boolean read FCreateIfNotExists write FCreateIfNotExists;
286		property AllowStreamedConnected: boolean read FAllowStreamedConnected
287		write FAllowStreamedConnected;
288		property DatabaseName: TIBFileName read FDBName write SetDatabaseName;
#	Line 265 | Line 291 | type
291		property DefaultTransaction: TIBTransaction read FDefaultTransaction
292		write SetDefaultTransaction;
293		property IdleTimer: Integer read GetIdleTimer write SetIdleTimer;
294	<	property SQLDialect : Integer read GetSQLDialect write SetSQLDialect default 3;
294	>	property SQLDialect : Integer read FSQLDialect write SetSQLDialect default 3;
295		property SQLHourGlass: Boolean read FSQLHourGlass write FSQLHourGlass default true;
270	–	property DBSQLDialect : Integer read FDBSQLDialect;
296		property TraceFlags: TTraceFlags read FTraceFlags write FTraceFlags;
297	+	property UseDefaultSystemCodePage: boolean read FUseDefaultSystemCodePage
298	+	write FUseDefaultSystemCodePage;
299		property AfterConnect;
300		property AfterDisconnect;
301		property BeforeConnect;
302		property BeforeDisconnect;
303	+	property OnCreateDatabase: TNotifyEvent read FOnCreateDatabase write FOnCreateDatabase;
304		property OnLogin: TIBDatabaseLoginEvent read FOnLogin write FOnLogin;
305		property OnIdleTimer: TNotifyEvent read FOnIdleTimer write FOnIdleTimer;
306		property OnDialectDowngradeWarning: TNotifyEvent read FOnDialectDowngradeWarning write FOnDialectDowngradeWarning;
307		end;
308
309	<	{ TIBTransaction }
309	>	TDefaultEndAction = TARollback..TACommit;
310
311	<	TTransactionAction         = (TARollback, TACommit, TARollbackRetaining, TACommitRetaining);
311	>	{ TIBTransaction }
312
313		TIBTransaction = class(TComponent)
314		private
315	+	FTransactionIntf: ITransaction;
316		FAfterDelete: TNotifyEvent;
317		FAfterEdit: TNotifyEvent;
318		FAfterExecQuery: TNotifyEvent;
#	Line 291 | Line 320 | type
320		FAfterPost: TNotifyEvent;
321		FAfterTransactionEnd: TNotifyEvent;
322		FBeforeTransactionEnd: TNotifyEvent;
294	–	FIBLoaded: Boolean;
295	–	FCanTimeout         : Boolean;
323		FDatabases          : TList;
324		FOnStartTransaction: TNotifyEvent;
325		FSQLObjects         : TList;
326		FDefaultDatabase    : TIBDatabase;
300	–	FHandle             : TISC_TR_HANDLE;
301	–	FHandleIsShared     : Boolean;
327		FOnIdleTimer          : TNotifyEvent;
328		FStreamedActive     : Boolean;
329	<	FTPB                : PChar;
305	<	FTPBLength          : Short;
329	>	FTPB                : ITPB;
330		FTimer              : TFPTimer;
331	<	FDefaultAction      : TTransactionAction;
331	>	FDefaultAction      : TDefaultEndAction;
332		FTRParams           : TStrings;
333		FTRParamsChanged    : Boolean;
334		FInEndTransaction   : boolean;
#	Line 327 | Line 351 | type
351		function GetIdleTimer: Integer;
352		procedure BeforeDatabaseDisconnect(DB: TIBDatabase);
353		procedure SetActive(Value: Boolean);
330	–	procedure SetDefaultAction(Value: TTransactionAction);
354		procedure SetDefaultDatabase(Value: TIBDatabase);
355		procedure SetIdleTimer(Value: Integer);
356		procedure SetTRParams(Value: TStrings);
#	Line 340 | Line 363 | type
363
364		protected
365		procedure Loaded; override;
343	–	procedure SetHandle(Value: TISC_TR_HANDLE);
366		procedure Notification( AComponent: TComponent; Operation: TOperation); override;
367
368		public
369		constructor Create(AOwner: TComponent); override;
370		destructor Destroy; override;
349	–	function Call(ErrCode: ISC_STATUS; RaiseError: Boolean): ISC_STATUS;
371		procedure Commit;
372		procedure CommitRetaining;
373		procedure Rollback;
#	Line 367 | Line 388 | type
388		property Databases[Index: Integer]: TIBDatabase read GetDatabase;
389		property SQLObjectCount: Integer read GetSQLObjectCount;
390		property SQLObjects[Index: Integer]: TIBBase read GetSQLObject;
370	–	property Handle: TISC_TR_HANDLE read FHandle;
371	–	property HandleIsShared: Boolean read FHandleIsShared;
391		property InTransaction: Boolean read GetInTransaction;
392	<	property TPB: PChar read FTPB;
393	<	property TPBLength: Short read FTPBLength;
392	>	property TransactionIntf: ITransaction read FTransactionIntf;
393	>	property TPB: ITPB read FTPB;
394		published
395		property Active: Boolean read GetInTransaction write SetActive;
396		property DefaultDatabase: TIBDatabase read FDefaultDatabase
397		write SetDefaultDatabase;
398		property IdleTimer: Integer read GetIdleTimer write SetIdleTimer default 0;
399	<	property DefaultAction: TTransactionAction read FDefaultAction write SetDefaultAction default taCommit;
399	>	property DefaultAction: TDefaultEndAction read FDefaultAction write FDefaultAction default taCommit;
400		property Params: TStrings read FTRParams write SetTRParams;
401		property OnIdleTimer: TNotifyEvent read FOnIdleTimer write FOnIdleTimer;
402		property BeforeTransactionEnd: TNotifyEvent read FBeforeTransactionEnd
#	Line 428 | Line 447 | type
447		procedure DoBeforeTransactionEnd(Action: TTransactionAction); virtual;
448		procedure DoAfterTransactionEnd; virtual;
449		procedure DoTransactionFree; virtual;
431	–	function GetDBHandle: PISC_DB_HANDLE; virtual;
432	–	function GetTRHandle: PISC_TR_HANDLE; virtual;
450		procedure SetDatabase(Value: TIBDatabase); virtual;
451		procedure SetTransaction(Value: TIBTransaction); virtual;
452		public
#	Line 442 | Line 459 | type
459		procedure DoAfterDelete(Sender: TObject); virtual;
460		procedure DoAfterInsert(Sender: TObject); virtual;
461		procedure DoAfterPost(Sender: TObject); virtual;
445	–	function GetCharSetSize(CharSetID: integer): integer;
462		procedure HandleException(Sender: TObject);
463		procedure SetCursor;
464		procedure RestoreCursor;
#	Line 461 | Line 477 | type
477		property OnTransactionFree: TNotifyEvent read FOnTransactionFree write FOnTransactionFree;
478		property Database: TIBDatabase read FDatabase
479		write SetDatabase;
464	–	property DBHandle: PISC_DB_HANDLE read GetDBHandle;
480		property Owner: TObject read FOwner;
466	–	property TRHandle: PISC_TR_HANDLE read GetTRHandle;
481		property Transaction: TIBTransaction read FTransaction
482		write SetTransaction;
483		end;
484
485	<	procedure GenerateDPB(sl: TStrings; var DPB: string; var DPBLength: Short);
486	<	procedure GenerateTPB(sl: TStrings; var TPB: string; var TPBLength: Short);
485	>	function GenerateDPB(sl: TStrings): IDPB;
486	>	function GenerateTPB(sl: TStrings): ITPB;
487
488
489		implementation
490
491	<	uses IBIntf, IBSQLMonitor, IBCustomDataSet, IBDatabaseInfo, IBSQL, IBUtils,
492	<	typInfo;
491	>	uses  IBSQLMonitor, IBCustomDataSet, IBDatabaseInfo, IBSQL, IBUtils,
492	>	typInfo, FBMessages, IBErrorCodes {$IFDEF WINDOWS}, Windirs {$ENDIF};
493
494		{ TIBDatabase }
495
496	<	constructor TIBDataBase.Create(AOwner: TComponent);
483	<	{$ifdef WINDOWS}
484	<	var acp: uint;
485	<	{$endif}
496	>	constructor TIBDataBase.Create(AOwner: TComponent);
497		begin
498		inherited Create(AOwner);
488	–	FIBLoaded := False;
489	–	CheckIBLoaded;
490	–	FIBLoaded := True;
499		LoginPrompt := True;
500		FSQLObjects := TList.Create;
501		FTransactions := TList.Create;
#	Line 498 | Line 506 | begin
506		(AOwner is TCustomApplication) and
507		TCustomApplication(AOWner).ConsoleApplication then
508		LoginPrompt := false;
501	–	{$ifdef UNIX}
502	–	if csDesigning in ComponentState then
503	–	FDBParams.Add('lc_ctype=UTF8');
504	–	{$else}
505	–	{$ifdef WINDOWS}
506	–	if csDesigning in ComponentState then
507	–	begin
508	–	acp := GetACP;
509	–	if (acp >= 1250) and (acp <= 1254) then
510	–	FDBParams.Values['lc_ctype'] := Format('WIN%d',[acp]);
511	–	end;
512	–	{$endif}
513	–	{$endif}
509		FDBParamsChanged := True;
510		TStringList(FDBParams).OnChange := DBParamsChange;
511		TStringList(FDBParams).OnChanging := DBParamsChanging;
517	–	FDPB := nil;
518	–	FHandle := nil;
512		FUserNames := nil;
513		FInternalTransaction := TIBTransaction.Create(self);
514		FInternalTransaction.DefaultDatabase := Self;
#	Line 523 | Line 516 | begin
516		FTimer.Enabled := False;
517		FTimer.Interval := 0;
518		FTimer.OnTimer := TimeoutConnection;
526	–	FDBSQLDialect := 1;
519		FSQLDialect := 3;
520		FTraceFlags := [];
521		FDataSets := TList.Create;
522		CheckStreamConnect;
523		end;
524
525	<	destructor TIBDataBase.Destroy;
525	>	destructor TIBDataBase.Destroy;
526		var
527		i: Integer;
528		begin
529	<	if FIBLoaded then
530	<	begin
531	<	IdleTimer := 0;
532	<	if FHandle <> nil then
533	<	ForceClose;
534	<	for i := 0 to FSQLObjects.Count - 1 do
535	<	if FSQLObjects[i] <> nil then
536	<	SQLObjects[i].DoDatabaseFree;
537	<	RemoveSQLObjects;
538	<	RemoveTransactions;
539	<	FInternalTransaction.Free;
540	<	FreeMem(FDPB);
541	<	FDPB := nil;
550	<	FDBParams.Free;
551	<	FSQLObjects.Free;
552	<	FUserNames.Free;
553	<	FTransactions.Free;
554	<	end;
529	>	IdleTimer := 0;
530	>	if FAttachment <> nil then
531	>	ForceClose;
532	>	for i := 0 to FSQLObjects.Count - 1 do
533	>	if FSQLObjects[i] <> nil then
534	>	SQLObjects[i].DoDatabaseFree;
535	>	RemoveSQLObjects;
536	>	RemoveTransactions;
537	>	FInternalTransaction.Free;
538	>	FDBParams.Free;
539	>	FSQLObjects.Free;
540	>	FUserNames.Free;
541	>	FTransactions.Free;
542		FDataSets.Free;
543		inherited Destroy;
544		end;
545
559	–	function TIBDataBase.Call(ErrCode: ISC_STATUS; RaiseError: Boolean
560	–	): ISC_STATUS;
561	–	begin
562	–	result := ErrCode;
563	–	FCanTimeout := False;
564	–	if RaiseError and (ErrCode > 0) then
565	–	IBDataBaseError;
566	–	end;
567	–
546		procedure TIBDataBase.CheckActive;
547		begin
548		if StreamedConnected and (not Connected) then
549		Loaded;
550	<	if FHandle = nil then
550	>	if FAttachment = nil then
551		IBError(ibxeDatabaseClosed, [nil]);
552		end;
553
#	Line 577 | Line 555 | end;
555		begin
556		if csDesigning in ComponentState then
557		begin
558	<	if FHandle <> nil then
558	>	if FAttachment <> nil then
559		Close;
560		end
561		end;
562
563	+	function TIBDataBase.GetAuthenticationMethod: string;
564	+	begin
565	+	CheckActive;
566	+	Result := Attachment.GetAuthenticationMethod;
567	+	end;
568	+
569		procedure TIBDataBase.CheckInactive;
570		begin
571	<	if FHandle <> nil then
571	>	if FAttachment <> nil then
572		IBError(ibxeDatabaseOpen, [nil]);
573		end;
574
575		procedure TIBDataBase.CheckDatabaseName;
576		begin
577	<	if (FDBName = '') then
577	>	if (Trim(FDBName) = '') then
578		IBError(ibxeDatabaseNameMissing, [nil]);
579		end;
580
#	Line 628 | Line 612 | end;
612		begin
613		if Connected then
614		InternalClose(False);
631	–	FDBSQLDialect := 1;
632	–	SetLength(FCharSetSizes,0);
615		end;
616
617	<	procedure TIBDataBase.CreateDatabase;
636	<	var
637	<	tr_handle: TISC_TR_HANDLE;
617	>	procedure TIBDataBase.CreateDatabase;
618		begin
619		CheckInactive;
620	<	tr_handle := nil;
621	<	Call(
622	<	isc_dsql_execute_immediate(StatusVector, @FHandle, @tr_handle, 0,
623	<	PChar('CREATE DATABASE ''' + FDBName + ''' ' + {do not localize}
624	<	Params.Text), SQLDialect, nil),
625	<	True);
620	>	CheckDatabaseName;
621	>	FCreateDatabase := true;
622	>	Connected := true;
623	>	end;
624	>
625	>	procedure TIBDataBase.CreateDatabase(createDatabaseSQL: string);
626	>	begin
627	>	CheckInactive;
628	>	FAttachment := FirebirdAPI.CreateDatabase(createDatabaseSQL,SQLDialect);
629	>	FDBName := Attachment.GetConnectString;
630	>	if assigned(FOnCreateDatabase) and (FAttachment <> nil) then
631	>	OnCreateDatabase(self);
632		end;
633
634		procedure TIBDataBase.DropDatabase;
635		begin
636		CheckActive;
637	<	Call(isc_drop_database(StatusVector, @FHandle), True);
637	>	FAttachment.DropDatabase;
638	>	FAttachment := nil;
639		end;
640
641		procedure TIBDataBase.DBParamsChange(Sender: TObject);
#	Line 675 | Line 662 | begin
662		end;
663		end;
664
665	<	function TIBDataBase.FindDefaultTransaction: TIBTransaction;
665	>	function TIBDataBase.FindDefaultTransaction(): TIBTransaction;
666		var
667		i: Integer;
668		begin
#	Line 701 | Line 688 | end;
688
689		function TIBDataBase.GetConnected: Boolean;
690		begin
691	<	result := FHandle <> nil;
691	>	result := (FAttachment <> nil) and FAttachment.IsConnected;
692		end;
693
694		function TIBDataBase.GetSQLObject(Index: Integer): TIBBase;
#	Line 718 | Line 705 | begin
705		Inc(result);
706		end;
707
708	<	function TIBDataBase.GetDBParamByDPB( const Idx: Integer): String;
722	<	var
723	<	ConstIdx, EqualsIdx: Integer;
724	<	begin
725	<	if (Idx > 0) and (Idx <= isc_dpb_last_dpb_constant) then
726	<	begin
727	<	ConstIdx := IndexOfDBConst(DPBConstantNames[Idx]);
728	<	if ConstIdx = -1 then
729	<	result := ''
730	<	else
731	<	begin
732	<	result := Params[ConstIdx];
733	<	EqualsIdx := Pos('=', result); {mbcs ok}
734	<	if EqualsIdx = 0 then
735	<	result := ''
736	<	else
737	<	result := Copy(result, EqualsIdx + 1, Length(result));
738	<	end;
739	<	end
740	<	else
741	<	result := '';
742	<	end;
743	<
744	<	function TIBDataBase.GetIdleTimer: Integer;
708	>	function TIBDataBase.GetIdleTimer: Integer;
709		begin
710		result := FTimer.Interval;
711		end;
#	Line 806 | Line 770 | begin
770		end;
771		end;
772
773	<	if (not HandleIsShared) and
774	<	(Call(isc_detach_database(StatusVector, @FHandle), False) > 0) and
811	<	(not Force) then
812	<	IBDataBaseError
813	<	else
814	<	begin
815	<	FHandle := nil;
816	<	FHandleIsShared := False;
817	<	end;
773	>	FAttachment.Disconnect(Force);
774	>	FAttachment := nil;
775
776		if not (csDesigning in ComponentState) then
777		MonitorHook.DBDisconnect(Self);
#	Line 824 | Line 781 | begin
781		SQLObjects[i].DoAfterDatabaseDisconnect;
782		end;
783
827	–	procedure TIBDataBase.LoadCharSetInfo;
828	–	var Query: TIBSQL;
829	–	i: integer;
830	–	begin
831	–	if not FInternalTransaction.Active then
832	–	FInternalTransaction.StartTransaction;
833	–	Query := TIBSQL.Create(self);
834	–	try
835	–	Query.Database := Self;
836	–	Query.Transaction := FInternalTransaction;
837	–	Query.SQL.Text := 'Select RDB$CHARACTER_SET_ID, RDB$BYTES_PER_CHARACTER ' +
838	–	'From RDB$CHARACTER_SETS Order by 1 DESC'; {do not localize}
839	–	Query.Prepare;
840	–	Query.ExecQuery;
841	–	if not Query.EOF then
842	–	begin
843	–	SetLength(FCharSetSizes,Query.FieldByName('RDB$CHARACTER_SET_ID').AsInteger + 1);
844	–	for i := 0 to Length(FCharSetSizes) - 1 do FCharSetSizes[i] := 1;
845	–	repeat
846	–	FCharSetSizes[Query.FieldByName('RDB$CHARACTER_SET_ID').AsInteger] :=
847	–	Query.FieldByName('RDB$BYTES_PER_CHARACTER').AsInteger;
848	–	Query.Next;
849	–	until Query.EOF;
850	–	end;
851	–	finally
852	–	Query.free;
853	–	FInternalTransaction.Commit;
854	–	end;
855	–	end;
856	–
784		procedure TIBDataBase.CheckStreamConnect;
785		var
786		i: integer;
#	Line 876 | Line 803 | begin
803		(FDefaultTransaction.FStreamedActive) and
804		(not FDefaultTransaction.InTransaction) then
805		FDefaultTransaction.StartTransaction;
806	<	FStreamedConnected := False;
806	>	StreamedConnected := False;
807		end;
808		except
809		if csDesigning in ComponentState then
#	Line 917 | Line 844 | begin
844		end;
845		end;
846
847	<	function TIBDataBase.Login: Boolean;
847	>	function TIBDataBase.Login(var aDatabaseName: string): Boolean;
848		var
849		IndexOfUser, IndexOfPassword: Integer;
850		Username, Password, OldPassword: String;
#	Line 953 | Line 880 | begin
880		LoginParams.Assign(Params);
881		FOnLogin(Self, LoginParams);
882		Params.Assign (LoginParams);
883	+	aDatabaseName := FDBName;
884		HidePassword;
885		finally
886		LoginParams.Free;
#	Line 974 | Line 902 | begin
902		Length(Params[IndexOfPassword]));
903		OldPassword := password;
904		end;
905	<	result := IBGUIInterface.LoginDialogEx(DatabaseName, Username, Password, False);
905	>
906	>	result := IBGUIInterface.LoginDialogEx(aDatabaseName, Username, Password, False);
907		if result then
908		begin
909	<	if IndexOfUser = -1 then
910	<	Params.Add(DPBConstantNames[isc_dpb_user_name] + '=' + Username)
911	<	else
912	<	Params[IndexOfUser] := DPBConstantNames[isc_dpb_user_name] +
909	>	if Username <> '' then
910	>	begin
911	>	if IndexOfUser = -1 then
912	>	Params.Add(DPBConstantNames[isc_dpb_user_name] + '=' + Username)
913	>	else
914	>	Params[IndexOfUser] := DPBConstantNames[isc_dpb_user_name] +
915		'=' + Username;
916	+	end
917	+	else
918	+	if IndexOfUser <> -1 then
919	+	Params.Delete(IndexOfUser);
920		if (Password = OldPassword) then
921		FHiddenPassword := ''
922		else
#	Line 1000 | Line 935 | begin
935		end;
936		end;
937
938	<	procedure TIBDataBase.DoConnect;
938	>	procedure TIBDataBase.DoConnect;
939	>
940	>	function ExpandDBName(aDBName: string): string;
941	>	const
942	>	TmpPrefix = '$TEMP$';
943	>	DataPrefix = '$DATADIR$';
944	>	var
945	>	LocalDirName: string;
946	>	begin
947	>	if Pos(TmpPrefix,aDBName) = 1 then
948	>	begin
949	>	system.Delete(aDBName,1,Length(TmpPrefix));
950	>	Result := GetTempDir + aDBName
951	>	end
952	>	else
953	>	if Pos(DataPrefix,aDBName) = 1 then
954	>	begin
955	>	system.Delete(aDBName,1,Length(DataPrefix));
956	>	if Sysutils.VendorName <> '' then
957	>	LocalDirName :=  Sysutils.VendorName
958	>	else
959	>	LocalDirName :=  'IBX';
960	>	{$IFDEF UNIX}
961	>	LocalDirName := GetUserDir + '.' + LocalDirName;
962	>	{$ENDIF}
963	>	{$IFDEF WINDOWS}
964	>	LocalDirName := GetWindowsSpecialDir(CSIDL_LOCAL_APPDATA) + LocalDirName;
965	>	{$ENDIF}
966	>	CreateDir(LocalDirName);
967	>	Result := LocalDirName + DirectorySeparator + aDBName;
968	>	end
969	>	else
970	>	Result := aDBName;
971	>	end;
972	>
973		var
1005	–	DPB: String;
974		TempDBParams: TStrings;
975		I: integer;
976		aDBName: string;
977	+	Status: IStatus;
978	+	CharSetID: integer;
979	+	CharSetName: AnsiString;
980	+	DPB: IDPB;
981	+	PW: IDPBItem;
982		begin
983	+	DPB := nil;
984		CheckInactive;
985		CheckDatabaseName;
986		if (not LoginPrompt) and (FHiddenPassword <> '') then
#	Line 1015 | Line 989 | begin
989		FDBParamsChanged := True;
990		end;
991		{ Use builtin login prompt if requested }
992	<	if (LoginPrompt or (csDesigning in ComponentState)) and not Login then
992	>	aDBName := ExpandDBName(FDBName);
993	>
994	>	if (LoginPrompt or (csDesigning in ComponentState)) and not Login(aDBName) then
995		IBError(ibxeOperationCancelled, [nil]);
996
997		TempDBParams := TStringList.Create;
998		try
999		TempDBParams.Assign(FDBParams);
1000	<	aDBName := FDBName;
1001	<	{Opportuning to override defaults}
1000	>	{$ifdef UNIX}
1001	>	{See below for WINDOWS UseDefaultSystemCodePage}
1002	>	if UseDefaultSystemCodePage then
1003	>	TempDBParams.Values['lc_ctype'] :='UTF8';
1004	>	{$endif}
1005	>	{Opportunity to override defaults}
1006		for i := 0 to FSQLObjects.Count - 1 do
1007		begin
1008		if FSQLObjects[i] <> nil then
1009		SQLObjects[i].DoBeforeDatabaseConnect(TempDBParams,aDBName);
1010		end;
1011
1012	<	{ Generate a new DPB if necessary }
1013	<	if (FDBParamsChanged or (TempDBParams.Text <> FDBParams.Text)) then
1014	<	begin
1015	<	FDBParamsChanged := False;
1016	<	if (not LoginPrompt and not (csDesigning in ComponentState)) or (FHiddenPassword = '') then
1017	<	GenerateDPB(TempDBParams, DPB, FDPBLength)
1012	>	repeat
1013	>	{ Generate a new DPB if necessary }
1014	>	if (DPB = nil) or FDBParamsChanged or (TempDBParams.Text <> FDBParams.Text) then
1015	>	begin
1016	>	FDBParamsChanged := False;
1017	>	if (not LoginPrompt and not (csDesigning in ComponentState)) or (FHiddenPassword = '') then
1018	>	DPB := GenerateDPB(TempDBParams)
1019	>	else
1020	>	begin
1021	>	TempDBParams.Values['password'] := FHiddenPassword;
1022	>	DPB := GenerateDPB(TempDBParams);
1023	>	end;
1024	>	end;
1025	>
1026	>	if FCreateDatabase then
1027	>	begin
1028	>	FCreateDatabase := false;
1029	>	DPB.Add(isc_dpb_set_db_SQL_dialect).AsByte := SQLDialect; {create with this SQL Dialect}
1030	>	FAttachment := FirebirdAPI.CreateDatabase(aDBName,DPB, false);
1031	>	if FAttachment = nil then
1032	>	DPB := nil;
1033	>	if assigned(FOnCreateDatabase) and (FAttachment <> nil) then
1034	>	OnCreateDatabase(self);
1035	>	end
1036		else
1037	+	FAttachment := FirebirdAPI.OpenDatabase(aDBName,DPB,false);
1038	+
1039	+	if FAttachment = nil then
1040	+	begin
1041	+	Status := FirebirdAPI.GetStatus;
1042	+	{$IFDEF UNIX}
1043	+	if GetProtocol(aDBName) = Local then
1044	+	begin
1045	+	if ((Status.GetSQLCode = -901) and (Status.GetIBErrorCode = isc_random)) {Access permissions on firebird temp}
1046	+	or
1047	+	((Status.GetSQLCode = -902) and (Status.GetIBErrorCode = isc_sys_request)) {Security DB Problem}
1048	+	or
1049	+	((Status.GetSQLCode = -902) and (Status.GetIBErrorCode = isc_psw_attach)) {Security DB Problem}
1050	+	or
1051	+	((Status.GetSQLCode = -904) and (Status.GetIBErrorCode = isc_lock_dir_access)) {Lock File Problem}
1052	+	then
1053	+	begin
1054	+	aDBName := 'localhost:' + aDBName;
1055	+	Continue;
1056	+	end
1057	+	end;
1058	+	{$ENDIF}
1059	+	if ((Status.GetSQLCode = -902) and (Status.GetIBErrorCode = isc_io_error)) {Database not found}
1060	+	and CreateIfNotExists and not (csDesigning in ComponentState) then
1061	+	FCreateDatabase := true
1062	+	else
1063	+	raise EIBInterBaseError.Create(Status);
1064	+	end;
1065	+
1066	+	if UseDefaultSystemCodePage and (FAttachment <> nil) then
1067	+	{Only now can we check the codepage in use by the Attachment.
1068	+	If not that required then re-open with required LCLType.}
1069		begin
1070	<	TempDBParams.Add('password=' + FHiddenPassword);
1071	<	GenerateDPB(TempDBParams, DPB, FDPBLength);
1070	>	{$ifdef WINDOWS}
1071	>	if Attachment.CodePage2CharSetID(GetACP,CharSetID) then
1072	>	{$else}
1073	>	if Attachment.CodePage2CharSetID(DefaultSystemCodePage,CharSetID) then
1074	>	{$endif}
1075	>	begin
1076	>	CharSetName := Attachment.GetCharsetName(CharSetID);
1077	>	if CharSetName <> AnsiUpperCase(TempDBParams.Values['lc_ctype']) then
1078	>	begin
1079	>	TempDBParams.Values['lc_ctype'] := CharSetName;
1080	>	FDBParamsChanged := True;
1081	>	FAttachment := nil;
1082	>	end
1083	>	end
1084		end;
1085	<	IBAlloc(FDPB, 0, FDPBLength);
1086	<	Move(DPB[1], FDPB[0], FDPBLength);
1087	<	end;
1085	>
1086	>	until FAttachment <> nil;
1087	>
1088		finally
1089		TempDBParams.Free;
1090		end;
1091	<	if Call(isc_attach_database(StatusVector, Length(aDBName),
1092	<	PChar(aDBName), @FHandle,
1093	<	FDPBLength, FDPB), False) > 0 then
1052	<	begin
1053	<	FHandle := nil;
1054	<	IBDataBaseError;
1055	<	end;
1091	>	PW := Attachment.getDPB.Find(isc_dpb_password);
1092	>	if PW <> nil then PW.AsString := 'xxxxxxxx'; {Hide password}
1093	>
1094		if not (csDesigning in ComponentState) then
1095		FDBName := aDBName; {Synchronise at run time}
1058	–	FDBSQLDialect := GetDBSQLDialect;
1096		ValidateClientSQLDialect;
1097		for i := 0 to FSQLObjects.Count - 1 do
1098		begin
#	Line 1064 | Line 1101 | begin
1101		end;
1102		if not (csDesigning in ComponentState) then
1103		MonitorHook.DBConnect(Self);
1067	–	LoadCharSetInfo;
1104		end;
1105
1106		procedure TIBDataBase.RemoveSQLObject(Idx: Integer);
#	Line 1167 | Line 1203 | begin
1203		FDefaultTransaction := Value;
1204		end;
1205
1170	–	procedure TIBDataBase.SetHandle(Value: TISC_DB_HANDLE);
1171	–	begin
1172	–	if HandleIsShared then
1173	–	Close
1174	–	else
1175	–	CheckInactive;
1176	–	FHandle := Value;
1177	–	FHandleIsShared := (Value <> nil);
1178	–	end;
1179	–
1206		procedure TIBDataBase.SetIdleTimer(Value: Integer);
1207		begin
1208		if Value < 0 then
#	Line 1221 | Line 1247 | end;
1247		begin
1248		if Connected then
1249		begin
1250	<	if FCanTimeout then
1250	>	if not FAttachment.HasActivity then
1251		begin
1252		ForceClose;
1253		if Assigned(FOnIdleTimer) then
1254		FOnIdleTimer(Self);
1255		end
1230	–	else
1231	–	FCanTimeout := True;
1256		end;
1257		end;
1258
#	Line 1250 | Line 1274 | begin
1274		DatabaseInfo.Free;
1275		end;
1276
1253	–	function TIBDataBase.GetSQLDialect: Integer;
1254	–	begin
1255	–	Result := FSQLDialect;
1256	–	end;
1257	–
1277
1278		procedure TIBDataBase.SetSQLDialect( const Value: Integer);
1279		begin
1280		if (Value < 1) then IBError(ibxeSQLDialectInvalid, [nil]);
1281	<	if ((FHandle = nil) or (Value <= FDBSQLDialect))  then
1281	>	if (Attachment = nil) or (Value <= DBSQLDialect)  then
1282		FSQLDialect := Value
1283		else
1284		IBError(ibxeSQLDialectInvalid, [nil]);
1285		end;
1286
1287		function TIBDataBase.GetDBSQLDialect: Integer;
1269	–	var
1270	–	DatabaseInfo: TIBDatabaseInfo;
1288		begin
1289	<	DatabaseInfo := TIBDatabaseInfo.Create(self);
1290	<	DatabaseInfo.Database := self;
1291	<	result := DatabaseInfo.DBSQLDialect;
1292	<	DatabaseInfo.Free;
1289	>	CheckActive;
1290	>	Result := Attachment.GetSQLDialect;
1291	>	end;
1292	>
1293	>	function TIBDataBase.GetDefaultCharSetID: integer;
1294	>	begin
1295	>	if (Attachment <> nil) and Attachment.HasDefaultCharSet then
1296	>	Result := Attachment.GetDefaultCharSetID
1297	>	else
1298	>	Result := 0;
1299	>	end;
1300	>
1301	>	function TIBDataBase.GetDefaultCharSetName: AnsiString;
1302	>	begin
1303	>	if Attachment <> nil then
1304	>	Result := Attachment.GetCharsetName(DefaultCharSetID)
1305	>	else
1306	>	Result := '';
1307	>	end;
1308	>
1309	>	function TIBDataBase.GetDefaultCodePage: TSystemCodePage;
1310	>	begin
1311	>	if Attachment <> nil then
1312	>	Attachment.CharSetID2CodePage(DefaultCharSetID,Result)
1313	>	else
1314	>	Result := CP_NONE;
1315	>	end;
1316	>
1317	>	function TIBDataBase.GetRemoteProtocol: string;
1318	>	begin
1319	>	CheckActive;
1320	>	Result := Attachment.GetRemoteProtocol;
1321		end;
1322
1323		procedure TIBDataBase.ValidateClientSQLDialect;
1324		begin
1325	<	if (FDBSQLDialect < FSQLDialect) then
1325	>	if (DBSQLDialect < FSQLDialect) then
1326		begin
1327	<	FSQLDialect := FDBSQLDialect;
1327	>	FSQLDialect := DBSQLDialect;
1328		if Assigned (FOnDialectDowngradeWarning) then
1329		FOnDialectDowngradeWarning(self);
1330		end;
#	Line 1365 | Line 1410 | begin
1410		Query.Database := Self;
1411		Query.Transaction := FInternalTransaction;
1412		Query.SQL.Text := 'Select R.RDB$FIELD_NAME ' + {do not localize}
1413	<	'from RDB$RELATION_FIELDS R, RDB$FIELDS F ' + {do not localize}
1413	>	'from RDB$RELATION_FIELDS R ' + {do not localize}
1414		'where R.RDB$RELATION_NAME = ' + {do not localize}
1415	<	'''' +
1416	<	FormatIdentifierValue(SQLDialect, TableName) +
1372	<	''' ' +
1373	<	'and R.RDB$FIELD_SOURCE = F.RDB$FIELD_NAME '; {do not localize}
1415	>	'''' + ExtractIdentifier(DBSQLDialect, TableName) +
1416	>	''' and Exists(Select * From RDB$FIELDS F Where R.RDB$FIELD_SOURCE = F.RDB$FIELD_NAME)' ; {do not localize}
1417		Query.Prepare;
1418		Query.ExecQuery;
1419		with List do
#	Line 1378 | Line 1421 | begin
1421		BeginUpdate;
1422		try
1423		Clear;
1424	<	while (not Query.EOF) and (Query.Next <> nil) do
1425	<	List.Add(TrimRight(Query.Current.ByName('RDB$FIELD_NAME').AsString)); {do not localize}
1424	>	while (not Query.EOF) and Query.Next  do
1425	>	List.Add(TrimRight(Query.FieldByName('RDB$FIELD_NAME').AsString)); {do not localize}
1426		finally
1427		EndUpdate;
1428		end;
#	Line 1418 | Line 1461 | begin
1461		BeginUpdate;
1462		try
1463		Clear;
1464	<	while (not Query.EOF) and (Query.Next <> nil) do
1465	<	List.Add(TrimRight(Query.Current[0].AsString));
1464	>	while (not Query.EOF) and Query.Next  do
1465	>	List.Add(TrimRight(Query.Fields[0].AsString));
1466		finally
1467		EndUpdate;
1468		end;
#	Line 1436 | Line 1479 | end;
1479		constructor TIBTransaction.Create(AOwner: TComponent);
1480		begin
1481		inherited Create(AOwner);
1439	–	FIBLoaded := False;
1440	–	CheckIBLoaded;
1441	–	FIBLoaded := True;
1442	–	CheckIBLoaded;
1482		FDatabases := TList.Create;
1483		FSQLObjects := TList.Create;
1445	–	FHandle := nil;
1484		FTPB := nil;
1447	–	FTPBLength := 0;
1485		FTRParams := TStringList.Create;
1486		FTRParamsChanged := True;
1487		TStringList(FTRParams).OnChange := TRParamsChange;
#	Line 1460 | Line 1497 | destructor TIBTransaction.Destroy;
1497		var
1498		i: Integer;
1499		begin
1500	<	if FIBLoaded then
1501	<	begin
1502	<	if InTransaction then
1503	<	EndTransaction(FDefaultAction, True);
1504	<	for i := 0 to FSQLObjects.Count - 1 do
1505	<	if FSQLObjects[i] <> nil then
1506	<	SQLObjects[i].DoTransactionFree;
1507	<	RemoveSQLObjects;
1508	<	RemoveDatabases;
1509	<	FreeMem(FTPB);
1510	<	FTPB := nil;
1474	<	FTRParams.Free;
1475	<	FSQLObjects.Free;
1476	<	FDatabases.Free;
1477	<	end;
1500	>	if InTransaction then
1501	>	EndTransaction(FDefaultAction, True);
1502	>	for i := 0 to FSQLObjects.Count - 1 do
1503	>	if FSQLObjects[i] <> nil then
1504	>	SQLObjects[i].DoTransactionFree;
1505	>	RemoveSQLObjects;
1506	>	RemoveDatabases;
1507	>	FTPB := nil;
1508	>	FTRParams.Free;
1509	>	FSQLObjects.Free;
1510	>	FDatabases.Free;
1511		inherited Destroy;
1512		end;
1513
1481	–	function TIBTransaction.Call(ErrCode: ISC_STATUS;
1482	–	RaiseError: Boolean): ISC_STATUS;
1483	–	var
1484	–	i: Integer;
1485	–	begin
1486	–	result := ErrCode;
1487	–	for i := 0 to FDatabases.Count - 1 do if FDatabases[i] <> nil then
1488	–	Databases[i].FCanTimeout := False;
1489	–	FCanTimeout := False;
1490	–	if RaiseError and (result > 0) then
1491	–	IBDataBaseError;
1492	–	end;
1493	–
1514		procedure TIBTransaction.CheckDatabasesInList;
1515		begin
1516		if GetDatabaseCount = 0 then
#	Line 1501 | Line 1521 | procedure TIBTransaction.CheckInTransact
1521		begin
1522		if FStreamedActive and (not InTransaction) then
1523		Loaded;
1524	<	if (FHandle = nil) then
1524	>	if (TransactionIntf = nil) then
1525		IBError(ibxeNotInTransaction, [nil]);
1526		end;
1527
#	Line 1557 | Line 1577 | procedure TIBTransaction.EnsureNotInTran
1577		begin
1578		if csDesigning in ComponentState then
1579		begin
1580	<	if FHandle <> nil then
1580	>	if TransactionIntf <> nil then
1581		Rollback;
1582		end;
1583		end;
1584
1585		procedure TIBTransaction.CheckNotInTransaction;
1586		begin
1587	<	if (FHandle <> nil) then
1587	>	if (TransactionIntf <> nil) and  TransactionIntf.InTransaction then
1588		IBError(ibxeInTransaction, [nil]);
1589		end;
1590
#	Line 1573 | Line 1593 | var
1593		i: Integer;
1594		NilFound: Boolean;
1595		begin
1596	+	EnsureNotInTransaction;
1597	+	CheckNotInTransaction;
1598	+	FTransactionIntf := nil;
1599	+
1600		i := FindDatabase(db);
1601		if i <> -1 then
1602		begin
#	Line 1623 | Line 1647 | end;
1647		procedure TIBTransaction.EndTransaction(Action: TTransactionAction;
1648		Force: Boolean);
1649		var
1626	–	status: ISC_STATUS;
1650		i: Integer;
1651		begin
1652		CheckInTransaction;
#	Line 1634 | Line 1657 | begin
1657		case Action of
1658		TARollback, TACommit:
1659		begin
1660	<	if (HandleIsShared) and
1661	<	(Action <> FDefaultAction) and
1662	<	(not Force) then
1663	<	IBError(ibxeCantEndSharedTransaction, [nil]);
1664	<	DoBeforeTransactionEnd;
1660	>	try
1661	>	DoBeforeTransactionEnd;
1662	>	except on E: EIBInterBaseError do
1663	>	begin
1664	>	if not Force then
1665	>	raise;
1666	>	end;
1667	>	end;
1668	>
1669		for i := 0 to FSQLObjects.Count - 1 do if FSQLObjects[i] <> nil then
1670	+	try
1671		SQLObjects[i].DoBeforeTransactionEnd(Action);
1672	+	except on E: EIBInterBaseError do
1673	+	begin
1674	+	if not Force then
1675	+	raise;
1676	+	end;
1677	+	end;
1678	+
1679		if InTransaction then
1680		begin
1681	<	if HandleIsShared then
1682	<	begin
1648	<	FHandle := nil;
1649	<	FHandleIsShared := False;
1650	<	status := 0;
1651	<	end
1681	>	if (Action = TARollback) then
1682	>	FTransactionIntf.Rollback(Force)
1683		else
1684	<	if (Action = TARollback) then
1685	<	status := Call(isc_rollback_transaction(StatusVector, @FHandle), False)
1686	<	else
1687	<	status := Call(isc_commit_transaction(StatusVector, @FHandle), False);
1688	<	if ((Force) and (status > 0)) then
1689	<	status := Call(isc_rollback_transaction(StatusVector, @FHandle), False);
1690	<	if Force then
1691	<	FHandle := nil
1692	<	else
1693	<	if (status > 0) then
1694	<	IBDataBaseError;
1695	<	for i := 0 to FSQLObjects.Count - 1 do if FSQLObjects[i] <> nil then
1696	<	SQLObjects[i].DoAfterTransactionEnd;
1697	<	DoAfterTransactionEnd;
1684	>	try
1685	>	FTransactionIntf.Commit;
1686	>	except on E: EIBInterBaseError do
1687	>	begin
1688	>	if Force then
1689	>	FTransactionIntf.Rollback(Force)
1690	>	else
1691	>	raise;
1692	>	end;
1693	>	end;
1694	>
1695	>	for i := 0 to FSQLObjects.Count - 1 do if FSQLObjects[i] <> nil then
1696	>	try
1697	>	SQLObjects[i].DoAfterTransactionEnd;
1698	>	except on E: EIBInterBaseError do
1699	>	begin
1700	>	if not Force then
1701	>	raise;
1702	>	end;
1703	>	end;
1704	>	try
1705	>	DoAfterTransactionEnd;
1706	>	except on E: EIBInterBaseError do
1707	>	begin
1708	>	if not Force then
1709	>	raise;
1710	>	end;
1711	>	end;
1712		end;
1713		end;
1714		TACommitRetaining:
1715	<	Call(isc_commit_retaining(StatusVector, @FHandle), True);
1715	>	FTransactionIntf.CommitRetaining;
1716	>
1717		TARollbackRetaining:
1718	<	Call(isc_rollback_retaining(StatusVector, @FHandle), True);
1718	>	FTransactionIntf.RollbackRetaining;
1719		end;
1720		if not (csDesigning in ComponentState) then
1721		begin
#	Line 1721 | Line 1767 | end;
1767
1768		function TIBTransaction.GetInTransaction: Boolean;
1769		begin
1770	<	result := (FHandle <> nil);
1770	>	result := (TransactionIntf <> nil) and TransactionIntf.InTransaction;
1771		end;
1772
1773		function TIBTransaction.FindDatabase(db: TIBDatabase): Integer;
#	Line 1777 | Line 1823 | procedure TIBTransaction.BeforeDatabaseD
1823		begin
1824		if InTransaction then
1825		EndTransaction(FDefaultAction, True);
1826	+	FTransactionIntf := nil;
1827		end;
1828
1829		procedure TIBTransaction.RemoveDatabase(Idx: Integer);
#	Line 1785 | Line 1832 | var
1832		begin
1833		if ((Idx >= 0) and (FDatabases[Idx] <> nil)) then
1834		begin
1835	+	EnsureNotInTransaction;
1836	+	CheckNotInTransaction;
1837	+	FTransactionIntf := nil;
1838	+
1839		DB := Databases[Idx];
1840		FDatabases[Idx] := nil;
1841		DB.RemoveTransaction(DB.FindTransaction(Self));
#	Line 1797 | Line 1848 | procedure TIBTransaction.RemoveDatabases
1848		var
1849		i: Integer;
1850		begin
1851	+	EnsureNotInTransaction;
1852	+	CheckNotInTransaction;
1853	+	FTransactionIntf := nil;
1854	+
1855		for i := 0 to FDatabases.Count - 1 do if FDatabases[i] <> nil then
1856		RemoveDatabase(i);
1857		end;
#	Line 1843 | Line 1898 | begin
1898		Rollback;
1899		end;
1900
1846	–	procedure TIBTransaction.SetDefaultAction(Value: TTransactionAction);
1847	–	begin
1848	–	(*  if (Value = taRollbackRetaining) and (GetIBClientVersion < 6) then
1849	–	IBError(ibxeIB60feature, [nil]);*)
1850	–	FDefaultAction := Value;
1851	–	end;
1852	–
1901		procedure TIBTransaction.SetDefaultDatabase(Value: TIBDatabase);
1902		var
1903		i: integer;
#	Line 1872 | Line 1920 | begin
1920		FDefaultDatabase := Value;
1921		end;
1922
1875	–	procedure TIBTransaction.SetHandle(Value: TISC_TR_HANDLE);
1876	–	begin
1877	–	if (HandleIsShared) then
1878	–	EndTransaction(DefaultAction, True)
1879	–	else
1880	–	CheckNotInTransaction;
1881	–	FHandle := Value;
1882	–	FHandleIsShared := (Value <> nil);
1883	–	end;
1884	–
1923		procedure TIBTransaction.Notification( AComponent: TComponent;
1924		Operation: TOperation);
1925		var
#	Line 1923 | Line 1961 | end;
1961
1962		procedure TIBTransaction.StartTransaction;
1963		var
1926	–	pteb: PISC_TEB_ARRAY;
1927	–	TPB: String;
1964		i: Integer;
1965	+	Attachments: array of IAttachment;
1966	+	ValidDatabaseCount: integer;
1967		begin
1968		CheckNotInTransaction;
1969		CheckDatabasesInList;
1970	+	if TransactionIntf <> nil then
1971	+	begin
1972	+	TransactionIntf.Start(DefaultAction);
1973	+	Exit;
1974	+	end;
1975	+
1976		for i := 0 to FDatabases.Count - 1 do
1977		if  FDatabases[i] <> nil then
1978		begin
1979		with TIBDatabase(FDatabases[i]) do
1980		if not Connected then
1981	<	if FStreamedConnected then
1981	>	if StreamedConnected then
1982		begin
1983		Open;
1984	<	FStreamedConnected := False;
1984	>	StreamedConnected := False;
1985		end
1986		else
1987		IBError(ibxeDatabaseClosed, [nil]);
#	Line 1945 | Line 1989 | begin
1989		if FTRParamsChanged then
1990		begin
1991		FTRParamsChanged := False;
1992	<	GenerateTPB(FTRParams, TPB, FTPBLength);
1949	<	if FTPBLength > 0 then
1950	<	begin
1951	<	IBAlloc(FTPB, 0, FTPBLength);
1952	<	Move(TPB[1], FTPB[0], FTPBLength);
1953	<	end;
1992	>	FTPB :=  GenerateTPB(FTRParams);
1993		end;
1994
1995	<	pteb := nil;
1996	<	IBAlloc(pteb, 0, DatabaseCount * SizeOf(TISC_TEB));
1997	<	try
1998	<	for i := 0 to DatabaseCount - 1 do if Databases[i] <> nil then
1999	<	begin
2000	<	pteb^[i].db_handle := @(Databases[i].Handle);
2001	<	pteb^[i].tpb_length := FTPBLength;
2002	<	pteb^[i].tpb_address := FTPB;
2003	<	end;
2004	<	if Call(isc_start_multiple(StatusVector, @FHandle,
2005	<	DatabaseCount, PISC_TEB(pteb)), False) > 0 then
2006	<	begin
2007	<	FHandle := nil;
2008	<	IBDataBaseError;
1970	<	end;
1971	<	if not (csDesigning in ComponentState) then
1972	<	MonitorHook.TRStart(Self);
1973	<	finally
1974	<	FreeMem(pteb);
1995	>	ValidDatabaseCount := 0;
1996	>	for i := 0 to DatabaseCount - 1 do
1997	>	if Databases[i] <> nil then Inc(ValidDatabaseCount);
1998	>
1999	>	if ValidDatabaseCount = 1 then
2000	>	FTransactionIntf := Databases[0].Attachment.StartTransaction(FTPB,DefaultAction)
2001	>	else
2002	>	begin
2003	>	SetLength(Attachments,ValidDatabaseCount);
2004	>	for i := 0 to DatabaseCount - 1 do
2005	>	if Databases[i] <> nil then
2006	>	Attachments[i] := Databases[i].Attachment;
2007	>
2008	>	FTransactionIntf := FirebirdAPI.StartTransaction(Attachments,FTPB,DefaultAction);
2009		end;
2010	+
2011	+	if not (csDesigning in ComponentState) then
2012	+	MonitorHook.TRStart(Self);
2013		DoOnStartTransaction;
2014		end;
2015
#	Line 1980 | Line 2017 | procedure TIBTransaction.TimeoutTransact
2017		begin
2018		if InTransaction then
2019		begin
2020	<	if FCanTimeout then
2020	>	if not TransactionIntf.HasActivity then
2021		begin
2022		EndTransaction(FDefaultAction, True);
2023		if Assigned(FOnIdleTimer) then
2024		FOnIdleTimer(Self);
2025		end
1989	–	else
1990	–	FCanTimeout := True;
2026		end;
2027		end;
2028
#	Line 2000 | Line 2035 | procedure TIBTransaction.TRParamsChangin
2035		begin
2036		EnsureNotInTransaction;
2037		CheckNotInTransaction;
2038	+	FTransactionIntf := nil;
2039		end;
2040
2041		{ TIBBase }
#	Line 2015 | Line 2051 | begin
2051		inherited Destroy;
2052		end;
2053
2018	–	function TIBBase.GetCharSetSize(CharSetID: integer): integer;
2019	–	begin
2020	–	if (CharSetID >= 0) and (CharSetID < Length(Database.FCharSetSizes)) then
2021	–	Result := Database.FCharSetSizes[CharSetID]
2022	–	else
2023	–	Result := 1; {Unknown character set}
2024	–	end;
2025	–
2054		procedure TIBBase.HandleException(Sender: TObject);
2055		begin
2056		if assigned(Database) then
#	Line 2061 | Line 2089 | begin
2089		FTransaction.CheckInTransaction;
2090		end;
2091
2064	–	function TIBBase.GetDBHandle: PISC_DB_HANDLE;
2065	–	begin
2066	–	CheckDatabase;
2067	–	result := @FDatabase.Handle;
2068	–	end;
2069	–
2070	–	function TIBBase.GetTRHandle: PISC_TR_HANDLE;
2071	–	begin
2072	–	CheckTransaction;
2073	–	result := @FTransaction.Handle;
2074	–	end;
2075	–
2092		procedure TIBBase.DoBeforeDatabaseConnect(DBParams: TStrings; var DBName: string
2093		);
2094		begin
#	Line 2187 | Line 2203 | end;
2203		parameter buffer, and return it and its length
2204		in DPB and DPBLength, respectively. }
2205
2206	<	procedure GenerateDPB(sl: TStrings; var DPB: string; var DPBLength: Short);
2206	>	function GenerateDPB(sl: TStrings): IDPB;
2207		var
2208	<	i, j, pval: Integer;
2208	>	i, j: Integer;
2209		DPBVal: UShort;
2210		ParamName, ParamValue: string;
2211		begin
2212	<	{ The DPB is initially empty, with the exception that
2197	<	the DPB version must be the first byte of the string. }
2198	<	DPBLength := 1;
2199	<	DPB := Char(isc_dpb_version1);
2212	>	Result := FirebirdAPI.AllocateDPB;
2213
2214		{Iterate through the textual database parameters, constructing
2215		a DPB on-the-fly }
#	Line 2230 | Line 2243 | begin
2243		case DPBVal of
2244		isc_dpb_user_name, isc_dpb_password, isc_dpb_password_enc,
2245		isc_dpb_sys_user_name, isc_dpb_license, isc_dpb_encrypt_key,
2246	<	isc_dpb_lc_messages, isc_dpb_lc_ctype,
2246	>	isc_dpb_lc_messages, isc_dpb_lc_ctype, isc_dpb_page_size,
2247		isc_dpb_sql_role_name, isc_dpb_sql_dialect:
2248		begin
2249		if DPBVal = isc_dpb_sql_dialect then
2250		ParamValue[1] := Char(Ord(ParamValue[1]) - 48);
2251	<	DPB := DPB +
2239	<	Char(DPBVal) +
2240	<	Char(Length(ParamValue)) +
2241	<	ParamValue;
2242	<	Inc(DPBLength, 2 + Length(ParamValue));
2251	>	Result.Add(DPBVal).SetAsString(ParamValue);
2252		end;
2253	+
2254		isc_dpb_num_buffers, isc_dpb_dbkey_scope, isc_dpb_force_write,
2255		isc_dpb_no_reserve, isc_dpb_damaged, isc_dpb_verify:
2256	<	begin
2257	<	DPB := DPB +
2248	<	Char(DPBVal) +
2249	<	#1 +
2250	<	Char(StrToInt(ParamValue));
2251	<	Inc(DPBLength, 3);
2252	<	end;
2256	>	Result.Add(DPBVal).SetAsByte(byte(ParamValue[1]));
2257	>
2258		isc_dpb_sweep:
2259	<	begin
2260	<	DPB := DPB +
2256	<	Char(DPBVal) +
2257	<	#1 +
2258	<	Char(isc_dpb_records);
2259	<	Inc(DPBLength, 3);
2260	<	end;
2259	>	Result.Add(DPBVal).SetAsByte(isc_dpb_records);
2260	>
2261		isc_dpb_sweep_interval:
2262	<	begin
2263	<	pval := StrToInt(ParamValue);
2264	<	DPB := DPB +
2265	<	Char(DPBVal) +
2266	<	#4 +
2267	<	PChar(@pval)[0] +
2268	<	PChar(@pval)[1] +
2269	<	PChar(@pval)[2] +
2270	<	PChar(@pval)[3];
2271	<	Inc(DPBLength, 6);
2272	<	end;
2262	>	Result.Add(DPBVal).SetAsInteger(StrToInt(ParamValue));
2263	>
2264		isc_dpb_activate_shadow, isc_dpb_delete_shadow, isc_dpb_begin_log,
2265	<	isc_dpb_quit_log:
2266	<	begin
2276	<	DPB := DPB +
2277	<	Char(DPBVal) +
2278	<	#1 + #0;
2279	<	Inc(DPBLength, 3);
2280	<	end;
2265	>	isc_dpb_map_attach, isc_dpb_quit_log:
2266	>	Result.Add(DPBVal).SetAsByte(0);
2267		else
2268		begin
2269		if (DPBVal > 0) and
#	Line 2295 | Line 2281 | end;
2281		of the transaction parameters, generate a transaction
2282		parameter buffer, and return it and its length in
2283		TPB and TPBLength, respectively. }
2284	<	procedure GenerateTPB(sl: TStrings; var TPB: string; var TPBLength: Short);
2284	>	function GenerateTPB(sl: TStrings): ITPB;
2285		var
2286	<	i, j, TPBVal, ParamLength: Integer;
2286	>	i, j, TPBVal: Integer;
2287		ParamName, ParamValue: string;
2288		begin
2289	<	TPB := '';
2304	<	if (sl.Count = 0) then
2305	<	TPBLength := 0
2306	<	else
2307	<	begin
2308	<	TPBLength := sl.Count + 1;
2309	<	TPB := TPB + Char(isc_tpb_version3);
2310	<	end;
2289	>	Result := FirebirdAPI.AllocateTPB;
2290		for i := 0 to sl.Count - 1 do
2291		begin
2292		if (Trim(sl[i]) =  '') then
2314	–	begin
2315	–	Dec(TPBLength);
2293		Continue;
2294	<	end;
2294	>
2295		if (Pos('=', sl[i]) = 0) then {mbcs ok}
2296		ParamName := LowerCase(sl[i]) {mbcs ok}
2297		else
#	Line 2338 | Line 2315 | begin
2315		isc_tpb_concurrency, isc_tpb_shared, isc_tpb_wait, isc_tpb_nowait,
2316		isc_tpb_read, isc_tpb_write, isc_tpb_ignore_limbo,
2317		isc_tpb_read_committed, isc_tpb_rec_version, isc_tpb_no_rec_version:
2318	<	TPB := TPB + Char(TPBVal);
2318	>	Result.Add(TPBVal);
2319	>
2320		isc_tpb_lock_read, isc_tpb_lock_write:
2321	<	begin
2322	<	TPB := TPB + Char(TPBVal);
2345	<	{ Now set the string parameter }
2346	<	ParamLength := Length(ParamValue);
2347	<	Inc(TPBLength, ParamLength + 1);
2348	<	TPB := TPB + Char(ParamLength) + ParamValue;
2349	<	end;
2321	>	Result.Add(TPBVal).SetAsString(ParamValue);
2322	>
2323		else
2324		begin
2325		if (TPBVal > 0) and

Diff Legend

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