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 43 by tony, Thu Sep 22 17:10:15 2016 UTC vs.
Revision 80 by tony, Mon Jan 1 11:31:07 2018 UTC

#	Line 35 | Line 35 | unit IBDatabase;
35
36		{$Mode Delphi}
37
38	–	{$IF FPC_FULLVERSION >= 20700 }
38		{$codepage UTF8}
40	–	{$DEFINE HAS_ANSISTRING_CODEPAGE}
41	–	{$ENDIF}
39
40		interface
41
#	Line 48 | Line 45 | uses
45		{$ELSE}
46		unix,
47		{$ENDIF}
48	<	SysUtils, Classes, FPTimer, IBHeader, IBExternals, DB,
52	<	IB, CustApp;
48	>	SysUtils, Classes, FPTimer, IBExternals, DB, IB, CustApp, IBTypes;
49
50		const
51		DPBPrefix = 'isc_dpb_';
#	Line 120 | Line 116 | const
116		'set_db_readonly',
117		'set_db_sql_dialect',
118		'gfix_attach',
119	<	'gstat_attach'
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		);
132
133		TPBPrefix = 'isc_tpb_';
#	Line 144 | Line 151 | const
151		'rec_version',
152		'no_rec_version',
153		'restart_requests',
154	<	'no_auto_undo'
154	>	'no_auto_undo',
155	>	'lock_timeout'
156		);
157
158		type
#	Line 160 | Line 168 | type
168		{ TIBDatabase }
169		TIBDataBase = class(TCustomConnection)
170		private
171	+	FAttachment: IAttachment;
172	+	FCreateDatabase: boolean;
173	+	FCreateIfNotExists: boolean;
174	+	FDefaultCharSetID: integer;
175	+	FDefaultCharSetName: RawByteString;
176	+	FDefaultCodePage: TSystemCodePage;
177	+	FDPB: IDPB;
178		FAllowStreamedConnected: boolean;
179		FHiddenPassword: string;
180	<	FIBLoaded: Boolean;
180	>	FOnCreateDatabase: TNotifyEvent;
181		FOnLogin: TIBDatabaseLoginEvent;
182		FSQLHourGlass: Boolean;
183		FTraceFlags: TTraceFlags;
184		FDBSQLDialect: Integer;
185		FSQLDialect: Integer;
186		FOnDialectDowngradeWarning: TNotifyEvent;
172	–	FCanTimeout: Boolean;
187		FSQLObjects: TList;
188		FTransactions: TList;
189		FDBName: TIBFileName;
190		FDBParams: TStrings;
191		FDBParamsChanged: Boolean;
178	–	FDPB: PChar;
179	–	FDPBLength: Short;
180	–	FHandle: TISC_DB_HANDLE;
181	–	FHandleIsShared: Boolean;
192		FOnIdleTimer: TNotifyEvent;
193		FDefaultTransaction: TIBTransaction;
194		FInternalTransaction: TIBTransaction;
185	–	FStreamedConnected: Boolean;
195		FTimer: TFPTimer;
196		FUserNames: TStringList;
197		FDataSets: TList;
198		FLoginCalled: boolean;
190	–	FDefaultCharSetName: RawByteString;
191	–	FDefaultCharSetID: integer;
192	–	{$IFDEF HAS_ANSISTRING_CODEPAGE}
193	–	FDefaultCodePage: TSystemCodePage;
194	–	{$ENDIF}
199		FUseDefaultSystemCodePage: boolean;
200		procedure EnsureInactive;
201		function GetDBSQLDialect: Integer;
#	Line 202 | Line 206 | type
206		procedure DBParamsChanging(Sender: TObject);
207		function GetSQLObject(Index: Integer): TIBBase;
208		function GetSQLObjectCount: Integer;
205	–	function GetDBParamByDPB(const Idx: Integer): String;
209		function GetIdleTimer: Integer;
210		function GetTransaction(Index: Integer): TIBTransaction;
211		function GetTransactionCount: Integer;
#	Line 237 | Line 240 | type
240		procedure CloseDataSets;
241		procedure CheckActive;
242		procedure CheckInactive;
243	<	procedure CreateDatabase;
243	>	procedure CreateDatabase; overload;
244	>	procedure CreateDatabase(createDatabaseSQL: string); overload;
245		procedure DropDatabase;
246		procedure ForceClose;
247		procedure GetFieldNames(const TableName: string; List: TStrings);
#	Line 245 | Line 249 | type
249		function IndexOfDBConst(st: String): Integer;
250		function TestConnected: Boolean;
251		procedure CheckDatabaseName;
248	–	function Call(ErrCode: ISC_STATUS; RaiseError: Boolean): ISC_STATUS;
252		function AddTransaction(TR: TIBTransaction): Integer;
253		function FindTransaction(TR: TIBTransaction): Integer;
254		function FindDefaultTransaction(): TIBTransaction;
255		procedure RemoveTransaction(Idx: Integer);
256		procedure RemoveTransactions;
254	–	procedure SetHandle(Value: TISC_DB_HANDLE);
257
258	<	property Handle: TISC_DB_HANDLE read FHandle;
258	>	property Attachment: IAttachment read FAttachment;
259	>	property DBSQLDialect : Integer read FDBSQLDialect;
260		property IsReadOnly: Boolean read GetIsReadOnly;
258	–	property DBParamByDPB[const Idx: Integer]: String read GetDBParamByDPB
259	–	write SetDBParamByDPB;
261		property SQLObjectCount: Integer read GetSQLObjectCount;
262		property SQLObjects[Index: Integer]: TIBBase read GetSQLObject;
262	–	property HandleIsShared: Boolean read FHandleIsShared;
263		property TransactionCount: Integer read GetTransactionCount;
264		property Transactions[Index: Integer]: TIBTransaction read GetTransaction;
265		property InternalTransaction: TIBTransaction read FInternalTransaction;
266		property DefaultCharSetName: RawByteString read FDefaultCharSetName;
267		property DefaultCharSetID: integer read FDefaultCharSetID;
268	–	{$IFDEF HAS_ANSISTRING_CODEPAGE}
268		property DefaultCodePage: TSystemCodePage read FDefaultCodePage;
270	–	{$ENDIF}
269
270		published
271		property Connected;
272	+	property CreateIfNotExists: boolean read FCreateIfNotExists write FCreateIfNotExists;
273		property AllowStreamedConnected: boolean read FAllowStreamedConnected
274		write FAllowStreamedConnected;
275		property DatabaseName: TIBFileName read FDBName write SetDatabaseName;
#	Line 281 | Line 280 | type
280		property IdleTimer: Integer read GetIdleTimer write SetIdleTimer;
281		property SQLDialect : Integer read GetSQLDialect write SetSQLDialect default 3;
282		property SQLHourGlass: Boolean read FSQLHourGlass write FSQLHourGlass default true;
284	–	property DBSQLDialect : Integer read FDBSQLDialect;
283		property TraceFlags: TTraceFlags read FTraceFlags write FTraceFlags;
284		property UseDefaultSystemCodePage: boolean read FUseDefaultSystemCodePage
285		write FUseDefaultSystemCodePage;
#	Line 289 | Line 287 | type
287		property AfterDisconnect;
288		property BeforeConnect;
289		property BeforeDisconnect;
290	+	property OnCreateDatabase: TNotifyEvent read FOnCreateDatabase write FOnCreateDatabase;
291		property OnLogin: TIBDatabaseLoginEvent read FOnLogin write FOnLogin;
292		property OnIdleTimer: TNotifyEvent read FOnIdleTimer write FOnIdleTimer;
293		property OnDialectDowngradeWarning: TNotifyEvent read FOnDialectDowngradeWarning write FOnDialectDowngradeWarning;
294		end;
295
296	<	{ TIBTransaction }
296	>	TDefaultEndAction = TARollback..TACommit;
297
298	<	TTransactionAction         = (TARollback, TACommit, TARollbackRetaining, TACommitRetaining);
298	>	{ TIBTransaction }
299
300		TIBTransaction = class(TComponent)
301		private
302	+	FTransactionIntf: ITransaction;
303		FAfterDelete: TNotifyEvent;
304		FAfterEdit: TNotifyEvent;
305		FAfterExecQuery: TNotifyEvent;
#	Line 307 | Line 307 | type
307		FAfterPost: TNotifyEvent;
308		FAfterTransactionEnd: TNotifyEvent;
309		FBeforeTransactionEnd: TNotifyEvent;
310	–	FIBLoaded: Boolean;
311	–	FCanTimeout         : Boolean;
310		FDatabases          : TList;
311		FOnStartTransaction: TNotifyEvent;
312		FSQLObjects         : TList;
313		FDefaultDatabase    : TIBDatabase;
316	–	FHandle             : TISC_TR_HANDLE;
317	–	FHandleIsShared     : Boolean;
314		FOnIdleTimer          : TNotifyEvent;
315		FStreamedActive     : Boolean;
316	<	FTPB                : PChar;
321	<	FTPBLength          : Short;
316	>	FTPB                : ITPB;
317		FTimer              : TFPTimer;
318	<	FDefaultAction      : TTransactionAction;
318	>	FDefaultAction      : TDefaultEndAction;
319		FTRParams           : TStrings;
320		FTRParamsChanged    : Boolean;
321		FInEndTransaction   : boolean;
#	Line 343 | Line 338 | type
338		function GetIdleTimer: Integer;
339		procedure BeforeDatabaseDisconnect(DB: TIBDatabase);
340		procedure SetActive(Value: Boolean);
346	–	procedure SetDefaultAction(Value: TTransactionAction);
341		procedure SetDefaultDatabase(Value: TIBDatabase);
342		procedure SetIdleTimer(Value: Integer);
343		procedure SetTRParams(Value: TStrings);
#	Line 356 | Line 350 | type
350
351		protected
352		procedure Loaded; override;
359	–	procedure SetHandle(Value: TISC_TR_HANDLE);
353		procedure Notification( AComponent: TComponent; Operation: TOperation); override;
354
355		public
356		constructor Create(AOwner: TComponent); override;
357		destructor Destroy; override;
365	–	function Call(ErrCode: ISC_STATUS; RaiseError: Boolean): ISC_STATUS;
358		procedure Commit;
359		procedure CommitRetaining;
360		procedure Rollback;
#	Line 383 | Line 375 | type
375		property Databases[Index: Integer]: TIBDatabase read GetDatabase;
376		property SQLObjectCount: Integer read GetSQLObjectCount;
377		property SQLObjects[Index: Integer]: TIBBase read GetSQLObject;
386	–	property Handle: TISC_TR_HANDLE read FHandle;
387	–	property HandleIsShared: Boolean read FHandleIsShared;
378		property InTransaction: Boolean read GetInTransaction;
379	<	property TPB: PChar read FTPB;
380	<	property TPBLength: Short read FTPBLength;
379	>	property TransactionIntf: ITransaction read FTransactionIntf;
380	>	property TPB: ITPB read FTPB;
381		published
382		property Active: Boolean read GetInTransaction write SetActive;
383		property DefaultDatabase: TIBDatabase read FDefaultDatabase
384		write SetDefaultDatabase;
385		property IdleTimer: Integer read GetIdleTimer write SetIdleTimer default 0;
386	<	property DefaultAction: TTransactionAction read FDefaultAction write SetDefaultAction default taCommit;
386	>	property DefaultAction: TDefaultEndAction read FDefaultAction write FDefaultAction default taCommit;
387		property Params: TStrings read FTRParams write SetTRParams;
388		property OnIdleTimer: TNotifyEvent read FOnIdleTimer write FOnIdleTimer;
389		property BeforeTransactionEnd: TNotifyEvent read FBeforeTransactionEnd
#	Line 444 | Line 434 | type
434		procedure DoBeforeTransactionEnd(Action: TTransactionAction); virtual;
435		procedure DoAfterTransactionEnd; virtual;
436		procedure DoTransactionFree; virtual;
447	–	function GetDBHandle: PISC_DB_HANDLE; virtual;
448	–	function GetTRHandle: PISC_TR_HANDLE; virtual;
437		procedure SetDatabase(Value: TIBDatabase); virtual;
438		procedure SetTransaction(Value: TIBTransaction); virtual;
439		public
#	Line 458 | Line 446 | type
446		procedure DoAfterDelete(Sender: TObject); virtual;
447		procedure DoAfterInsert(Sender: TObject); virtual;
448		procedure DoAfterPost(Sender: TObject); virtual;
461	–	function GetDefaultCharSetName: RawByteString;
462	–	function GetDefaultCharSetID: cardinal;
449		procedure HandleException(Sender: TObject);
450		procedure SetCursor;
451		procedure RestoreCursor;
#	Line 478 | Line 464 | type
464		property OnTransactionFree: TNotifyEvent read FOnTransactionFree write FOnTransactionFree;
465		property Database: TIBDatabase read FDatabase
466		write SetDatabase;
481	–	property DBHandle: PISC_DB_HANDLE read GetDBHandle;
467		property Owner: TObject read FOwner;
483	–	property TRHandle: PISC_TR_HANDLE read GetTRHandle;
468		property Transaction: TIBTransaction read FTransaction
469		write SetTransaction;
470		end;
471
472	<	procedure GenerateDPB(sl: TStrings; var DPB: string; var DPBLength: Short);
473	<	procedure GenerateTPB(sl: TStrings; var TPB: string; var TPBLength: Short);
472	>	function GenerateDPB(sl: TStrings): IDPB;
473	>	function GenerateTPB(sl: TStrings): ITPB;
474
475
476		implementation
477
478	<	uses IBIntf, IBSQLMonitor, IBCustomDataSet, IBDatabaseInfo, IBSQL, IBUtils,
479	<	typInfo, IBCodePage;
478	>	uses  IBSQLMonitor, IBCustomDataSet, IBDatabaseInfo, IBSQL, IBUtils,
479	>	typInfo, FBMessages, IBErrorCodes, RegExpr;
480
481		{ TIBDatabase }
482
483		constructor TIBDataBase.Create(AOwner: TComponent);
484		begin
485		inherited Create(AOwner);
502	–	FIBLoaded := False;
503	–	CheckIBLoaded;
504	–	FIBLoaded := True;
486		LoginPrompt := True;
487		FSQLObjects := TList.Create;
488		FTransactions := TList.Create;
#	Line 512 | Line 493 | begin
493		(AOwner is TCustomApplication) and
494		TCustomApplication(AOWner).ConsoleApplication then
495		LoginPrompt := false;
515	–	{$IFDEF HAS_ANSISTRING_CODEPAGE}
516	–	FDefaultCodePage := CP_NONE;
517	–	{$ENDIF}
496		FDBParamsChanged := True;
497		TStringList(FDBParams).OnChange := DBParamsChange;
498		TStringList(FDBParams).OnChanging := DBParamsChanging;
499		FDPB := nil;
522	–	FHandle := nil;
500		FUserNames := nil;
501		FInternalTransaction := TIBTransaction.Create(self);
502		FInternalTransaction.DefaultDatabase := Self;
#	Line 534 | Line 511 | begin
511		CheckStreamConnect;
512		end;
513
514	<	destructor TIBDataBase.Destroy;
514	>	destructor TIBDataBase.Destroy;
515		var
516		i: Integer;
517		begin
518	<	if FIBLoaded then
519	<	begin
520	<	IdleTimer := 0;
521	<	if FHandle <> nil then
522	<	ForceClose;
523	<	for i := 0 to FSQLObjects.Count - 1 do
524	<	if FSQLObjects[i] <> nil then
525	<	SQLObjects[i].DoDatabaseFree;
526	<	RemoveSQLObjects;
527	<	RemoveTransactions;
528	<	FInternalTransaction.Free;
529	<	FreeMem(FDPB);
530	<	FDPB := nil;
531	<	FDBParams.Free;
555	<	FSQLObjects.Free;
556	<	FUserNames.Free;
557	<	FTransactions.Free;
558	<	end;
518	>	IdleTimer := 0;
519	>	if FAttachment <> nil then
520	>	ForceClose;
521	>	for i := 0 to FSQLObjects.Count - 1 do
522	>	if FSQLObjects[i] <> nil then
523	>	SQLObjects[i].DoDatabaseFree;
524	>	RemoveSQLObjects;
525	>	RemoveTransactions;
526	>	FInternalTransaction.Free;
527	>	FDPB := nil;
528	>	FDBParams.Free;
529	>	FSQLObjects.Free;
530	>	FUserNames.Free;
531	>	FTransactions.Free;
532		FDataSets.Free;
533		inherited Destroy;
534		end;
535
563	–	function TIBDataBase.Call(ErrCode: ISC_STATUS; RaiseError: Boolean
564	–	): ISC_STATUS;
565	–	begin
566	–	result := ErrCode;
567	–	FCanTimeout := False;
568	–	if RaiseError and (ErrCode > 0) then
569	–	IBDataBaseError;
570	–	end;
571	–
536		procedure TIBDataBase.CheckActive;
537		begin
538		if StreamedConnected and (not Connected) then
539		Loaded;
540	<	if FHandle = nil then
540	>	if FAttachment = nil then
541		IBError(ibxeDatabaseClosed, [nil]);
542		end;
543
#	Line 581 | Line 545 | end;
545		begin
546		if csDesigning in ComponentState then
547		begin
548	<	if FHandle <> nil then
548	>	if FAttachment <> nil then
549		Close;
550		end
551		end;
552
553		procedure TIBDataBase.CheckInactive;
554		begin
555	<	if FHandle <> nil then
555	>	if FAttachment <> nil then
556		IBError(ibxeDatabaseOpen, [nil]);
557		end;
558
#	Line 635 | Line 599 | begin
599		FDBSQLDialect := 1;
600		FDefaultCharSetName := '';
601		FDefaultCharSetID := 0;
638	–	{$IFDEF HAS_ANSISTRING_CODEPAGE}
602		FDefaultCodePage := CP_NONE;
640	–	{$ENDIF}
603		end;
604
605	<	procedure TIBDataBase.CreateDatabase;
644	<	var
645	<	tr_handle: TISC_TR_HANDLE;
605	>	procedure TIBDataBase.CreateDatabase;
606		begin
607		CheckInactive;
608	<	tr_handle := nil;
609	<	Call(
610	<	isc_dsql_execute_immediate(StatusVector, @FHandle, @tr_handle, 0,
611	<	PChar('CREATE DATABASE ''' + FDBName + ''' ' + {do not localize}
612	<	Params.Text), SQLDialect, nil),
613	<	True);
608	>	CheckDatabaseName;
609	>	FCreateDatabase := true;
610	>	Connected := true;
611	>	end;
612	>
613	>	procedure TIBDataBase.CreateDatabase(createDatabaseSQL: string);
614	>	var RegexObj: TRegExpr;
615	>	begin
616	>	CheckInactive;
617	>	FAttachment := FirebirdAPI.CreateDatabase(createDatabaseSQL,FSQLDialect);
618	>	RegexObj := TRegExpr.Create;
619	>	try
620	>	{extact database file spec}
621	>	RegexObj.ModifierG := false; {turn off greedy matches}
622	>	RegexObj.Expression := '^ *CREATE +(DATABASE|SCHEMA) +''(.*)''';
623	>	if RegexObj.Exec(AnsiUpperCase(createDatabaseSQL)) then
624	>	FDBName := system.copy(createDatabaseSQL,RegexObj.MatchPos[2],RegexObj.MatchLen[2]);
625	>	finally
626	>	RegexObj.Free;
627	>	end;
628	>	if assigned(FOnCreateDatabase) and (FAttachment <> nil) then
629	>	OnCreateDatabase(self);
630		end;
631
632		procedure TIBDataBase.DropDatabase;
633		begin
634		CheckActive;
635	<	Call(isc_drop_database(StatusVector, @FHandle), True);
635	>	FAttachment.DropDatabase;
636	>	FAttachment := nil;
637		end;
638
639		procedure TIBDataBase.DBParamsChange(Sender: TObject);
#	Line 709 | Line 686 | end;
686
687		function TIBDataBase.GetConnected: Boolean;
688		begin
689	<	result := FHandle <> nil;
689	>	result := (FAttachment <> nil) and FAttachment.IsConnected;
690		end;
691
692		function TIBDataBase.GetSQLObject(Index: Integer): TIBBase;
#	Line 726 | Line 703 | begin
703		Inc(result);
704		end;
705
706	<	function TIBDataBase.GetDBParamByDPB( const Idx: Integer): String;
730	<	var
731	<	ConstIdx, EqualsIdx: Integer;
732	<	begin
733	<	if (Idx > 0) and (Idx <= isc_dpb_last_dpb_constant) then
734	<	begin
735	<	ConstIdx := IndexOfDBConst(DPBConstantNames[Idx]);
736	<	if ConstIdx = -1 then
737	<	result := ''
738	<	else
739	<	begin
740	<	result := Params[ConstIdx];
741	<	EqualsIdx := Pos('=', result); {mbcs ok}
742	<	if EqualsIdx = 0 then
743	<	result := ''
744	<	else
745	<	result := Copy(result, EqualsIdx + 1, Length(result));
746	<	end;
747	<	end
748	<	else
749	<	result := '';
750	<	end;
751	<
752	<	function TIBDataBase.GetIdleTimer: Integer;
706	>	function TIBDataBase.GetIdleTimer: Integer;
707		begin
708		result := FTimer.Interval;
709		end;
#	Line 814 | Line 768 | begin
768		end;
769		end;
770
771	<	if (not HandleIsShared) and
772	<	(Call(isc_detach_database(StatusVector, @FHandle), False) > 0) and
819	<	(not Force) then
820	<	IBDataBaseError
821	<	else
822	<	begin
823	<	FHandle := nil;
824	<	FHandleIsShared := False;
825	<	end;
771	>	FAttachment.Disconnect(Force);
772	>	FAttachment := nil;
773
774		if not (csDesigning in ComponentState) then
775		MonitorHook.DBDisconnect(Self);
#	Line 854 | Line 801 | begin
801		(FDefaultTransaction.FStreamedActive) and
802		(not FDefaultTransaction.InTransaction) then
803		FDefaultTransaction.StartTransaction;
804	<	FStreamedConnected := False;
804	>	StreamedConnected := False;
805		end;
806		except
807		if csDesigning in ComponentState then
#	Line 895 | Line 842 | begin
842		end;
843		end;
844
845	<	function TIBDataBase.Login(var aDatabaseName: string): Boolean;
845	>	function TIBDataBase.Login(var aDatabaseName: string): Boolean;
846		var
847		IndexOfUser, IndexOfPassword: Integer;
848		Username, Password, OldPassword: String;
#	Line 953 | Line 900 | begin
900		Length(Params[IndexOfPassword]));
901		OldPassword := password;
902		end;
903	+
904		result := IBGUIInterface.LoginDialogEx(aDatabaseName, Username, Password, False);
905		if result then
906		begin
907	<	if IndexOfUser = -1 then
908	<	Params.Add(DPBConstantNames[isc_dpb_user_name] + '=' + Username)
909	<	else
910	<	Params[IndexOfUser] := DPBConstantNames[isc_dpb_user_name] +
907	>	if Username <> '' 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] +
913		'=' + Username;
914	+	end
915	+	else
916	+	if IndexOfUser <> -1 then
917	+	Params.Delete(IndexOfUser);
918		if (Password = OldPassword) then
919		FHiddenPassword := ''
920		else
#	Line 981 | Line 935 | end;
935
936		procedure TIBDataBase.DoConnect;
937		var
984	–	DPB: String;
938		TempDBParams: TStrings;
939		I: integer;
940		aDBName: string;
941	<
989	<	{Call error analysis}
990	<	sqlcode: Long;
991	<	IBErrorCode: Long;
992	<	status_vector: PISC_STATUS;
941	>	Status: IStatus;
942		CharSetID: integer;
943		begin
944		CheckInactive;
#	Line 1007 | Line 956 | begin
956		TempDBParams := TStringList.Create;
957		try
958		TempDBParams.Assign(FDBParams);
959	+	{$ifdef UNIX}
960	+	{See below for WINDOWS UseDefaultSystemCodePage}
961		if UseDefaultSystemCodePage then
1011	–	begin
1012	–	{$IFDEF HAS_ANSISTRING_CODEPAGE}
1013	–	{$ifdef WINDOWS}
1014	–	if TFirebirdCharacterSets.CodePage2CharSetID(GetACP,CharSetID) then
1015	–	TempDBParams.Values['lc_ctype'] := TFirebirdCharacterSets.GetCharsetName(CharSetID)
1016	–	else
1017	–	{$else}
1018	–	if TFirebirdCharacterSets.CodePage2CharSetID(DefaultSystemCodePage,CharSetID) then
1019	–	TempDBParams.Values['lc_ctype'] := TFirebirdCharacterSets.GetCharsetName(CharSetID)
1020	–	else
1021	–	{$endif}
1022	–	{$ENDIF}
962		TempDBParams.Values['lc_ctype'] :='UTF8';
963	<	end;
963	>	{$endif}
964		{Opportunity to override defaults}
965		for i := 0 to FSQLObjects.Count - 1 do
966		begin
967		if FSQLObjects[i] <> nil then
968		SQLObjects[i].DoBeforeDatabaseConnect(TempDBParams,aDBName);
969		end;
970	<	FDefaultCharSetName := AnsiUpperCase(TempDBParams.Values['lc_ctype']);
971	<	if FDefaultCharSetName <> '' then
972	<	TFirebirdCharacterSets.CharSetName2CharSetID(FDefaultCharSetName,FDefaultCharSetID);
973	<	{$IFDEF HAS_ANSISTRING_CODEPAGE}
974	<	TFirebirdCharacterSets.CharSetID2CodePage(FDefaultCharSetID,FDefaultCodePage);
975	<	{$ENDIF}
976	<	{ Generate a new DPB if necessary }
977	<	if (FDBParamsChanged or (TempDBParams.Text <> FDBParams.Text)) then
978	<	begin
979	<	FDBParamsChanged := False;
980	<	if (not LoginPrompt and not (csDesigning in ComponentState)) or (FHiddenPassword = '') then
981	<	GenerateDPB(TempDBParams, DPB, FDPBLength)
970	>
971	>	repeat
972	>	{ Generate a new DPB if necessary }
973	>	if (FDPB = nil) or FDBParamsChanged or (TempDBParams.Text <> FDBParams.Text) then
974	>	begin
975	>	FDBParamsChanged := False;
976	>	if (not LoginPrompt and not (csDesigning in ComponentState)) or (FHiddenPassword = '') then
977	>	FDPB := GenerateDPB(TempDBParams)
978	>	else
979	>	begin
980	>	TempDBParams.Values['password'] := FHiddenPassword;
981	>	FDPB := GenerateDPB(TempDBParams);
982	>	end;
983	>	end;
984	>
985	>	if FCreateDatabase then
986	>	begin
987	>	FCreateDatabase := false;
988	>	FAttachment := FirebirdAPI.CreateDatabase(aDBName,FDPB, false);
989	>	if assigned(FOnCreateDatabase) and (FAttachment <> nil) then
990	>	OnCreateDatabase(self);
991	>	end
992		else
993	+	FAttachment := FirebirdAPI.OpenDatabase(aDBName,FDPB,false);
994	+
995	+	if FAttachment = nil then
996		begin
997	<	TempDBParams.Add('password=' + FHiddenPassword);
998	<	GenerateDPB(TempDBParams, DPB, FDPBLength);
997	>	Status := FirebirdAPI.GetStatus;
998	>	{$IFDEF UNIX}
999	>	if Pos(':',aDBName) = 0 then
1000	>	begin
1001	>	if ((Status.GetSQLCode = -901) and (Status.GetIBErrorCode = isc_random)) {Access permissions on firebird temp}
1002	>	or
1003	>	((Status.GetSQLCode = -902) and (Status.GetIBErrorCode = isc_sys_request)) {Security DB Problem}
1004	>	or
1005	>	((Status.GetSQLCode = -902) and (Status.GetIBErrorCode = isc_psw_attach)) {Security DB Problem}
1006	>	or
1007	>	((Status.GetSQLCode = -904) and (Status.GetIBErrorCode = isc_lock_dir_access)) {Lock File Problem}
1008	>	then
1009	>	begin
1010	>	aDBName := 'localhost:' + aDBName;
1011	>	Continue;
1012	>	end
1013	>	end;
1014	>	{$ENDIF}
1015	>	if ((Status.GetSQLCode = -902) and (Status.GetIBErrorCode = isc_io_error)) {Database not found}
1016	>	and CreateIfNotExists and not (csDesigning in ComponentState) then
1017	>	FCreateDatabase := true
1018	>	else
1019	>	raise EIBInterBaseError.Create(Status);
1020		end;
1021	<	IBAlloc(FDPB, 0, FDPBLength);
1022	<	Move(DPB[1], FDPB[0], FDPBLength);
1023	<	end;
1021	>
1022	>	if UseDefaultSystemCodePage and (FAttachment <> nil) then
1023	>	{Only now can we check the codepage in use by the Attachment.
1024	>	If not that required then re-open with required LCLType.}
1025	>	begin
1026	>	{$ifdef WINDOWS}
1027	>	if Attachment.CodePage2CharSetID(GetACP,CharSetID) then
1028	>	{$else}
1029	>	if Attachment.CodePage2CharSetID(DefaultSystemCodePage,CharSetID) then
1030	>	{$endif}
1031	>	begin
1032	>	FDefaultCharSetName := Attachment.GetCharsetName(CharSetID);
1033	>	if FDefaultCharSetName <> AnsiUpperCase(TempDBParams.Values['lc_ctype']) then
1034	>	begin
1035	>	TempDBParams.Values['lc_ctype'] := FDefaultCharSetName;
1036	>	FDBParamsChanged := True;
1037	>	FAttachment := nil;
1038	>	end
1039	>	end
1040	>	end;
1041	>
1042	>	until FAttachment <> nil;
1043	>
1044	>	FDefaultCharSetName := AnsiUpperCase(TempDBParams.Values['lc_ctype']);
1045		finally
1046		TempDBParams.Free;
1047		end;
1048	<	repeat
1049	<	if Call(isc_attach_database(StatusVector, Length(aDBName),
1050	<	PChar(aDBName), @FHandle,
1051	<	FDPBLength, FDPB), False) > 0 then
1058	<	begin
1059	<	{$IFDEF UNIX}
1060	<	if IsEmbeddedServer and (Pos(':',aDBName) = 0) then
1061	<	begin
1062	<	status_vector := StatusVector;
1063	<	IBErrorCode := StatusVectorArray[1];
1064	<	sqlcode := isc_sqlcode(StatusVector);
1065	<
1066	<	if ((sqlcode = -901) and (IBErrorCode = 335544382)) {Access permissions on firebird temp}
1067	<	or
1068	<	((sqlcode = -902) and (IBErrorCode = 335544373)) {Security DB Problem}
1069	<	then
1070	<	begin
1071	<	aDBName := 'localhost:' + aDBName;
1072	<	Continue;
1073	<	end;
1074	<	end;
1075	<	{$ENDIF}
1076	<	FHandle := nil;
1077	<	IBDataBaseError;
1078	<	end;
1079	<	until FHandle <> nil;
1048	>	if FDefaultCharSetName <> '' then
1049	>	Attachment.CharSetName2CharSetID(FDefaultCharSetName,FDefaultCharSetID);
1050	>	Attachment.CharSetID2CodePage(FDefaultCharSetID,FDefaultCodePage);
1051	>
1052		if not (csDesigning in ComponentState) then
1053		FDBName := aDBName; {Synchronise at run time}
1054		FDBSQLDialect := GetDBSQLDialect;
#	Line 1190 | Line 1162 | begin
1162		FDefaultTransaction := Value;
1163		end;
1164
1193	–	procedure TIBDataBase.SetHandle(Value: TISC_DB_HANDLE);
1194	–	begin
1195	–	if HandleIsShared then
1196	–	Close
1197	–	else
1198	–	CheckInactive;
1199	–	FHandle := Value;
1200	–	FHandleIsShared := (Value <> nil);
1201	–	end;
1202	–
1165		procedure TIBDataBase.SetIdleTimer(Value: Integer);
1166		begin
1167		if Value < 0 then
#	Line 1244 | Line 1206 | end;
1206		begin
1207		if Connected then
1208		begin
1209	<	if FCanTimeout then
1209	>	if not FAttachment.HasActivity then
1210		begin
1211		ForceClose;
1212		if Assigned(FOnIdleTimer) then
1213		FOnIdleTimer(Self);
1214		end
1253	–	else
1254	–	FCanTimeout := True;
1215		end;
1216		end;
1217
#	Line 1282 | Line 1242 | end;
1242		procedure TIBDataBase.SetSQLDialect( const Value: Integer);
1243		begin
1244		if (Value < 1) then IBError(ibxeSQLDialectInvalid, [nil]);
1245	<	if ((FHandle = nil) or (Value <= FDBSQLDialect))  then
1245	>	if ((FAttachment = nil) or (Value <= FDBSQLDialect))  then
1246		FSQLDialect := Value
1247		else
1248		IBError(ibxeSQLDialectInvalid, [nil]);
#	Line 1401 | Line 1361 | begin
1361		BeginUpdate;
1362		try
1363		Clear;
1364	<	while (not Query.EOF) and (Query.Next <> nil) do
1365	<	List.Add(TrimRight(Query.Current.ByName('RDB$FIELD_NAME').AsString)); {do not localize}
1364	>	while (not Query.EOF) and Query.Next  do
1365	>	List.Add(TrimRight(Query.FieldByName('RDB$FIELD_NAME').AsString)); {do not localize}
1366		finally
1367		EndUpdate;
1368		end;
#	Line 1441 | Line 1401 | begin
1401		BeginUpdate;
1402		try
1403		Clear;
1404	<	while (not Query.EOF) and (Query.Next <> nil) do
1405	<	List.Add(TrimRight(Query.Current[0].AsString));
1404	>	while (not Query.EOF) and Query.Next  do
1405	>	List.Add(TrimRight(Query.Fields[0].AsString));
1406		finally
1407		EndUpdate;
1408		end;
#	Line 1459 | Line 1419 | end;
1419		constructor TIBTransaction.Create(AOwner: TComponent);
1420		begin
1421		inherited Create(AOwner);
1462	–	FIBLoaded := False;
1463	–	CheckIBLoaded;
1464	–	FIBLoaded := True;
1465	–	CheckIBLoaded;
1422		FDatabases := TList.Create;
1423		FSQLObjects := TList.Create;
1468	–	FHandle := nil;
1424		FTPB := nil;
1470	–	FTPBLength := 0;
1425		FTRParams := TStringList.Create;
1426		FTRParamsChanged := True;
1427		TStringList(FTRParams).OnChange := TRParamsChange;
#	Line 1483 | Line 1437 | destructor TIBTransaction.Destroy;
1437		var
1438		i: Integer;
1439		begin
1440	<	if FIBLoaded then
1441	<	begin
1442	<	if InTransaction then
1443	<	EndTransaction(FDefaultAction, True);
1444	<	for i := 0 to FSQLObjects.Count - 1 do
1445	<	if FSQLObjects[i] <> nil then
1446	<	SQLObjects[i].DoTransactionFree;
1447	<	RemoveSQLObjects;
1448	<	RemoveDatabases;
1449	<	FreeMem(FTPB);
1450	<	FTPB := nil;
1497	<	FTRParams.Free;
1498	<	FSQLObjects.Free;
1499	<	FDatabases.Free;
1500	<	end;
1440	>	if InTransaction then
1441	>	EndTransaction(FDefaultAction, True);
1442	>	for i := 0 to FSQLObjects.Count - 1 do
1443	>	if FSQLObjects[i] <> nil then
1444	>	SQLObjects[i].DoTransactionFree;
1445	>	RemoveSQLObjects;
1446	>	RemoveDatabases;
1447	>	FTPB := nil;
1448	>	FTRParams.Free;
1449	>	FSQLObjects.Free;
1450	>	FDatabases.Free;
1451		inherited Destroy;
1452		end;
1453
1504	–	function TIBTransaction.Call(ErrCode: ISC_STATUS;
1505	–	RaiseError: Boolean): ISC_STATUS;
1506	–	var
1507	–	i: Integer;
1508	–	begin
1509	–	result := ErrCode;
1510	–	for i := 0 to FDatabases.Count - 1 do if FDatabases[i] <> nil then
1511	–	Databases[i].FCanTimeout := False;
1512	–	FCanTimeout := False;
1513	–	if RaiseError and (result > 0) then
1514	–	IBDataBaseError;
1515	–	end;
1516	–
1454		procedure TIBTransaction.CheckDatabasesInList;
1455		begin
1456		if GetDatabaseCount = 0 then
#	Line 1524 | Line 1461 | procedure TIBTransaction.CheckInTransact
1461		begin
1462		if FStreamedActive and (not InTransaction) then
1463		Loaded;
1464	<	if (FHandle = nil) then
1464	>	if (TransactionIntf = nil) then
1465		IBError(ibxeNotInTransaction, [nil]);
1466		end;
1467
#	Line 1580 | Line 1517 | procedure TIBTransaction.EnsureNotInTran
1517		begin
1518		if csDesigning in ComponentState then
1519		begin
1520	<	if FHandle <> nil then
1520	>	if TransactionIntf <> nil then
1521		Rollback;
1522		end;
1523		end;
1524
1525		procedure TIBTransaction.CheckNotInTransaction;
1526		begin
1527	<	if (FHandle <> nil) then
1527	>	if (TransactionIntf <> nil) and  TransactionIntf.InTransaction then
1528		IBError(ibxeInTransaction, [nil]);
1529		end;
1530
#	Line 1596 | Line 1533 | var
1533		i: Integer;
1534		NilFound: Boolean;
1535		begin
1536	+	EnsureNotInTransaction;
1537	+	CheckNotInTransaction;
1538	+	FTransactionIntf := nil;
1539	+
1540		i := FindDatabase(db);
1541		if i <> -1 then
1542		begin
#	Line 1646 | Line 1587 | end;
1587		procedure TIBTransaction.EndTransaction(Action: TTransactionAction;
1588		Force: Boolean);
1589		var
1649	–	status: ISC_STATUS;
1590		i: Integer;
1591		begin
1592		CheckInTransaction;
#	Line 1657 | Line 1597 | begin
1597		case Action of
1598		TARollback, TACommit:
1599		begin
1600	<	if (HandleIsShared) and
1601	<	(Action <> FDefaultAction) and
1602	<	(not Force) then
1603	<	IBError(ibxeCantEndSharedTransaction, [nil]);
1604	<	DoBeforeTransactionEnd;
1600	>	try
1601	>	DoBeforeTransactionEnd;
1602	>	except on E: EIBInterBaseError do
1603	>	begin
1604	>	if not Force then
1605	>	raise;
1606	>	end;
1607	>	end;
1608	>
1609		for i := 0 to FSQLObjects.Count - 1 do if FSQLObjects[i] <> nil then
1610	+	try
1611		SQLObjects[i].DoBeforeTransactionEnd(Action);
1612	+	except on E: EIBInterBaseError do
1613	+	begin
1614	+	if not Force then
1615	+	raise;
1616	+	end;
1617	+	end;
1618	+
1619		if InTransaction then
1620		begin
1621	<	if HandleIsShared then
1622	<	begin
1671	<	FHandle := nil;
1672	<	FHandleIsShared := False;
1673	<	status := 0;
1674	<	end
1675	<	else
1676	<	if (Action = TARollback) then
1677	<	status := Call(isc_rollback_transaction(StatusVector, @FHandle), False)
1678	<	else
1679	<	status := Call(isc_commit_transaction(StatusVector, @FHandle), False);
1680	<	if ((Force) and (status > 0)) then
1681	<	status := Call(isc_rollback_transaction(StatusVector, @FHandle), False);
1682	<	if Force then
1683	<	FHandle := nil
1621	>	if (Action = TARollback) then
1622	>	FTransactionIntf.Rollback(Force)
1623		else
1624	<	if (status > 0) then
1625	<	IBDataBaseError;
1626	<	for i := 0 to FSQLObjects.Count - 1 do if FSQLObjects[i] <> nil then
1627	<	SQLObjects[i].DoAfterTransactionEnd;
1628	<	DoAfterTransactionEnd;
1624	>	try
1625	>	FTransactionIntf.Commit;
1626	>	except on E: EIBInterBaseError do
1627	>	begin
1628	>	if Force then
1629	>	FTransactionIntf.Rollback(Force)
1630	>	else
1631	>	raise;
1632	>	end;
1633	>	end;
1634	>
1635	>	for i := 0 to FSQLObjects.Count - 1 do if FSQLObjects[i] <> nil then
1636	>	try
1637	>	SQLObjects[i].DoAfterTransactionEnd;
1638	>	except on E: EIBInterBaseError do
1639	>	begin
1640	>	if not Force then
1641	>	raise;
1642	>	end;
1643	>	end;
1644	>	try
1645	>	DoAfterTransactionEnd;
1646	>	except on E: EIBInterBaseError do
1647	>	begin
1648	>	if not Force then
1649	>	raise;
1650	>	end;
1651	>	end;
1652		end;
1653		end;
1654		TACommitRetaining:
1655	<	Call(isc_commit_retaining(StatusVector, @FHandle), True);
1655	>	FTransactionIntf.CommitRetaining;
1656	>
1657		TARollbackRetaining:
1658	<	Call(isc_rollback_retaining(StatusVector, @FHandle), True);
1658	>	FTransactionIntf.RollbackRetaining;
1659		end;
1660		if not (csDesigning in ComponentState) then
1661		begin
#	Line 1744 | Line 1707 | end;
1707
1708		function TIBTransaction.GetInTransaction: Boolean;
1709		begin
1710	<	result := (FHandle <> nil);
1710	>	result := (TransactionIntf <> nil) and TransactionIntf.InTransaction;
1711		end;
1712
1713		function TIBTransaction.FindDatabase(db: TIBDatabase): Integer;
#	Line 1800 | Line 1763 | procedure TIBTransaction.BeforeDatabaseD
1763		begin
1764		if InTransaction then
1765		EndTransaction(FDefaultAction, True);
1766	+	FTransactionIntf := nil;
1767		end;
1768
1769		procedure TIBTransaction.RemoveDatabase(Idx: Integer);
#	Line 1808 | Line 1772 | var
1772		begin
1773		if ((Idx >= 0) and (FDatabases[Idx] <> nil)) then
1774		begin
1775	+	EnsureNotInTransaction;
1776	+	CheckNotInTransaction;
1777	+	FTransactionIntf := nil;
1778	+
1779		DB := Databases[Idx];
1780		FDatabases[Idx] := nil;
1781		DB.RemoveTransaction(DB.FindTransaction(Self));
#	Line 1820 | Line 1788 | procedure TIBTransaction.RemoveDatabases
1788		var
1789		i: Integer;
1790		begin
1791	+	EnsureNotInTransaction;
1792	+	CheckNotInTransaction;
1793	+	FTransactionIntf := nil;
1794	+
1795		for i := 0 to FDatabases.Count - 1 do if FDatabases[i] <> nil then
1796		RemoveDatabase(i);
1797		end;
#	Line 1866 | Line 1838 | begin
1838		Rollback;
1839		end;
1840
1869	–	procedure TIBTransaction.SetDefaultAction(Value: TTransactionAction);
1870	–	begin
1871	–	(*  if (Value = taRollbackRetaining) and (GetIBClientVersion < 6) then
1872	–	IBError(ibxeIB60feature, [nil]);*)
1873	–	FDefaultAction := Value;
1874	–	end;
1875	–
1841		procedure TIBTransaction.SetDefaultDatabase(Value: TIBDatabase);
1842		var
1843		i: integer;
#	Line 1895 | Line 1860 | begin
1860		FDefaultDatabase := Value;
1861		end;
1862
1898	–	procedure TIBTransaction.SetHandle(Value: TISC_TR_HANDLE);
1899	–	begin
1900	–	if (HandleIsShared) then
1901	–	EndTransaction(DefaultAction, True)
1902	–	else
1903	–	CheckNotInTransaction;
1904	–	FHandle := Value;
1905	–	FHandleIsShared := (Value <> nil);
1906	–	end;
1907	–
1863		procedure TIBTransaction.Notification( AComponent: TComponent;
1864		Operation: TOperation);
1865		var
#	Line 1946 | Line 1901 | end;
1901
1902		procedure TIBTransaction.StartTransaction;
1903		var
1949	–	pteb: PISC_TEB_ARRAY;
1950	–	TPB: String;
1904		i: Integer;
1905	+	Attachments: array of IAttachment;
1906	+	ValidDatabaseCount: integer;
1907		begin
1908		CheckNotInTransaction;
1909		CheckDatabasesInList;
1910	+	if TransactionIntf <> nil then
1911	+	begin
1912	+	TransactionIntf.Start(DefaultAction);
1913	+	Exit;
1914	+	end;
1915	+
1916		for i := 0 to FDatabases.Count - 1 do
1917		if  FDatabases[i] <> nil then
1918		begin
1919		with TIBDatabase(FDatabases[i]) do
1920		if not Connected then
1921	<	if FStreamedConnected then
1921	>	if StreamedConnected then
1922		begin
1923		Open;
1924	<	FStreamedConnected := False;
1924	>	StreamedConnected := False;
1925		end
1926		else
1927		IBError(ibxeDatabaseClosed, [nil]);
#	Line 1968 | Line 1929 | begin
1929		if FTRParamsChanged then
1930		begin
1931		FTRParamsChanged := False;
1932	<	GenerateTPB(FTRParams, TPB, FTPBLength);
1972	<	if FTPBLength > 0 then
1973	<	begin
1974	<	IBAlloc(FTPB, 0, FTPBLength);
1975	<	Move(TPB[1], FTPB[0], FTPBLength);
1976	<	end;
1932	>	FTPB :=  GenerateTPB(FTRParams);
1933		end;
1934
1935	<	pteb := nil;
1936	<	IBAlloc(pteb, 0, DatabaseCount * SizeOf(TISC_TEB));
1937	<	try
1938	<	for i := 0 to DatabaseCount - 1 do if Databases[i] <> nil then
1939	<	begin
1940	<	pteb^[i].db_handle := @(Databases[i].Handle);
1941	<	pteb^[i].tpb_length := FTPBLength;
1942	<	pteb^[i].tpb_address := FTPB;
1943	<	end;
1944	<	if Call(isc_start_multiple(StatusVector, @FHandle,
1945	<	DatabaseCount, PISC_TEB(pteb)), False) > 0 then
1946	<	begin
1947	<	FHandle := nil;
1948	<	IBDataBaseError;
1993	<	end;
1994	<	if not (csDesigning in ComponentState) then
1995	<	MonitorHook.TRStart(Self);
1996	<	finally
1997	<	FreeMem(pteb);
1935	>	ValidDatabaseCount := 0;
1936	>	for i := 0 to DatabaseCount - 1 do
1937	>	if Databases[i] <> nil then Inc(ValidDatabaseCount);
1938	>
1939	>	if ValidDatabaseCount = 1 then
1940	>	FTransactionIntf := Databases[0].Attachment.StartTransaction(FTPB,DefaultAction)
1941	>	else
1942	>	begin
1943	>	SetLength(Attachments,ValidDatabaseCount);
1944	>	for i := 0 to DatabaseCount - 1 do
1945	>	if Databases[i] <> nil then
1946	>	Attachments[i] := Databases[i].Attachment;
1947	>
1948	>	FTransactionIntf := FirebirdAPI.StartTransaction(Attachments,FTPB,DefaultAction);
1949		end;
1950	+
1951	+	if not (csDesigning in ComponentState) then
1952	+	MonitorHook.TRStart(Self);
1953		DoOnStartTransaction;
1954		end;
1955
#	Line 2003 | Line 1957 | procedure TIBTransaction.TimeoutTransact
1957		begin
1958		if InTransaction then
1959		begin
1960	<	if FCanTimeout then
1960	>	if not TransactionIntf.HasActivity then
1961		begin
1962		EndTransaction(FDefaultAction, True);
1963		if Assigned(FOnIdleTimer) then
1964		FOnIdleTimer(Self);
1965		end
2012	–	else
2013	–	FCanTimeout := True;
1966		end;
1967		end;
1968
#	Line 2023 | Line 1975 | procedure TIBTransaction.TRParamsChangin
1975		begin
1976		EnsureNotInTransaction;
1977		CheckNotInTransaction;
1978	+	FTransactionIntf := nil;
1979		end;
1980
1981		{ TIBBase }
#	Line 2038 | Line 1991 | begin
1991		inherited Destroy;
1992		end;
1993
2041	–	function TIBBase.GetDefaultCharSetName: RawByteString;
2042	–	begin
2043	–	Result := Database.FDefaultCharSetName;
2044	–	end;
2045	–
2046	–	function TIBBase.GetDefaultCharSetID: cardinal;
2047	–	begin
2048	–	Result := Database.DefaultCharSetID;
2049	–	end;
2050	–
1994		procedure TIBBase.HandleException(Sender: TObject);
1995		begin
1996		if assigned(Database) then
#	Line 2086 | Line 2029 | begin
2029		FTransaction.CheckInTransaction;
2030		end;
2031
2089	–	function TIBBase.GetDBHandle: PISC_DB_HANDLE;
2090	–	begin
2091	–	CheckDatabase;
2092	–	result := @FDatabase.Handle;
2093	–	end;
2094	–
2095	–	function TIBBase.GetTRHandle: PISC_TR_HANDLE;
2096	–	begin
2097	–	CheckTransaction;
2098	–	result := @FTransaction.Handle;
2099	–	end;
2100	–
2032		procedure TIBBase.DoBeforeDatabaseConnect(DBParams: TStrings; var DBName: string
2033		);
2034		begin
#	Line 2212 | Line 2143 | end;
2143		parameter buffer, and return it and its length
2144		in DPB and DPBLength, respectively. }
2145
2146	<	procedure GenerateDPB(sl: TStrings; var DPB: string; var DPBLength: Short);
2146	>	function GenerateDPB(sl: TStrings): IDPB;
2147		var
2148	<	i, j, pval: Integer;
2148	>	i, j: Integer;
2149		DPBVal: UShort;
2150		ParamName, ParamValue: string;
2151		begin
2152	<	{ The DPB is initially empty, with the exception that
2222	<	the DPB version must be the first byte of the string. }
2223	<	DPBLength := 1;
2224	<	DPB := Char(isc_dpb_version1);
2152	>	Result := FirebirdAPI.AllocateDPB;
2153
2154		{Iterate through the textual database parameters, constructing
2155		a DPB on-the-fly }
#	Line 2260 | Line 2188 | begin
2188		begin
2189		if DPBVal = isc_dpb_sql_dialect then
2190		ParamValue[1] := Char(Ord(ParamValue[1]) - 48);
2191	<	DPB := DPB +
2264	<	Char(DPBVal) +
2265	<	Char(Length(ParamValue)) +
2266	<	ParamValue;
2267	<	Inc(DPBLength, 2 + Length(ParamValue));
2191	>	Result.Add(DPBVal).SetAsString(ParamValue);
2192		end;
2193	+
2194		isc_dpb_num_buffers, isc_dpb_dbkey_scope, isc_dpb_force_write,
2195		isc_dpb_no_reserve, isc_dpb_damaged, isc_dpb_verify:
2196	<	begin
2197	<	DPB := DPB +
2273	<	Char(DPBVal) +
2274	<	#1 +
2275	<	Char(StrToInt(ParamValue));
2276	<	Inc(DPBLength, 3);
2277	<	end;
2196	>	Result.Add(DPBVal).SetAsByte(byte(ParamValue[1]));
2197	>
2198		isc_dpb_sweep:
2199	<	begin
2200	<	DPB := DPB +
2281	<	Char(DPBVal) +
2282	<	#1 +
2283	<	Char(isc_dpb_records);
2284	<	Inc(DPBLength, 3);
2285	<	end;
2199	>	Result.Add(DPBVal).SetAsByte(isc_dpb_records);
2200	>
2201		isc_dpb_sweep_interval:
2202	<	begin
2203	<	pval := StrToInt(ParamValue);
2289	<	DPB := DPB +
2290	<	Char(DPBVal) +
2291	<	#4 +
2292	<	PChar(@pval)[0] +
2293	<	PChar(@pval)[1] +
2294	<	PChar(@pval)[2] +
2295	<	PChar(@pval)[3];
2296	<	Inc(DPBLength, 6);
2297	<	end;
2202	>	Result.Add(DPBVal).SetAsInteger(StrToInt(ParamValue));
2203	>
2204		isc_dpb_activate_shadow, isc_dpb_delete_shadow, isc_dpb_begin_log,
2205		isc_dpb_quit_log:
2206	<	begin
2301	<	DPB := DPB +
2302	<	Char(DPBVal) +
2303	<	#1 + #0;
2304	<	Inc(DPBLength, 3);
2305	<	end;
2206	>	Result.Add(DPBVal).SetAsByte(0);
2207		else
2208		begin
2209		if (DPBVal > 0) and
#	Line 2320 | Line 2221 | end;
2221		of the transaction parameters, generate a transaction
2222		parameter buffer, and return it and its length in
2223		TPB and TPBLength, respectively. }
2224	<	procedure GenerateTPB(sl: TStrings; var TPB: string; var TPBLength: Short);
2224	>	function GenerateTPB(sl: TStrings): ITPB;
2225		var
2226	<	i, j, TPBVal, ParamLength: Integer;
2226	>	i, j, TPBVal: Integer;
2227		ParamName, ParamValue: string;
2228		begin
2229	<	TPB := '';
2329	<	if (sl.Count = 0) then
2330	<	TPBLength := 0
2331	<	else
2332	<	begin
2333	<	TPBLength := sl.Count + 1;
2334	<	TPB := TPB + Char(isc_tpb_version3);
2335	<	end;
2229	>	Result := FirebirdAPI.AllocateTPB;
2230		for i := 0 to sl.Count - 1 do
2231		begin
2232		if (Trim(sl[i]) =  '') then
2339	–	begin
2340	–	Dec(TPBLength);
2233		Continue;
2234	<	end;
2234	>
2235		if (Pos('=', sl[i]) = 0) then {mbcs ok}
2236		ParamName := LowerCase(sl[i]) {mbcs ok}
2237		else
#	Line 2363 | Line 2255 | begin
2255		isc_tpb_concurrency, isc_tpb_shared, isc_tpb_wait, isc_tpb_nowait,
2256		isc_tpb_read, isc_tpb_write, isc_tpb_ignore_limbo,
2257		isc_tpb_read_committed, isc_tpb_rec_version, isc_tpb_no_rec_version:
2258	<	TPB := TPB + Char(TPBVal);
2258	>	Result.Add(TPBVal);
2259	>
2260		isc_tpb_lock_read, isc_tpb_lock_write:
2261	<	begin
2262	<	TPB := TPB + Char(TPBVal);
2370	<	{ Now set the string parameter }
2371	<	ParamLength := Length(ParamValue);
2372	<	Inc(TPBLength, ParamLength + 1);
2373	<	TPB := TPB + Char(ParamLength) + ParamValue;
2374	<	end;
2261	>	Result.Add(TPBVal).SetAsString(ParamValue);
2262	>
2263		else
2264		begin
2265		if (TPBVal > 0) and

Diff Legend

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