ViewVC Help

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

root/public/ibx/branches/journaling/fbintf/client/FBClientAPI.pas

Comparing ibx/trunk/fbintf/client/FBClientAPI.pas (file contents):
Revision 60 by tony, Mon Mar 27 15:21:02 2017 UTC vs.
Revision 319 by tony, Thu Feb 25 12:05:40 2021 UTC

#	Line 76 | Line 76 | uses
76		Classes,
77		{$IFDEF WINDOWS}Windows, {$ENDIF}
78		{$IFDEF FPC} Dynlibs, {$ENDIF}
79	<	IB, IBHeader, FBActivityMonitor, FBMessages, IBExternals;
79	>	IB, IBHeader, FBActivityMonitor, FBMessages, IBExternals, FmtBCD;
80
81	<	{For Linux see result of GetFirebirdLibList method}
81	>	{For Linux see result of GetFirebirdLibListruntime/nongui/winipc.inc method}
82		{$IFDEF DARWIN}
83		const
84		FIREBIRD_SO2 = 'libfbclient.dylib';
#	Line 90 | Line 90 | FIREBIRD_CLIENT = 'fbclient.dll'; {do no
90		FIREBIRD_EMBEDDED = 'fbembed.dll';
91		{$ENDIF}
92
93	<	{$IFNDEF FPC}
94	<	type
95	<	TLibHandle = THandle;
93	>	const
94	>	{fb_shutdown reasons}
95	>	fb_shutrsn_svc_stopped          = -1;
96	>	fb_shutrsn_no_connection        = -2;
97	>	fb_shutrsn_app_stopped          = -3;
98	>	fb_shutrsn_signal               = -5;
99	>	fb_shutrsn_services             = -6;
100	>	fb_shutrsn_exit_called          = -7;
101
102		const
103	<	NilHandle = 0;
104	<	DirectorySeparator = '\';
105	<	{$ENDIF}
103	>	DefaultTimeZoneFile = '/etc/timezone';
104	>
105	>	const
106	>	IBLocalBufferLength = 512;
107	>	IBBigLocalBufferLength = IBLocalBufferLength * 2;
108	>	IBHugeLocalBufferLength = IBBigLocalBufferLength * 20;
109
110		type
111		TStatusVector              = array[0..19] of NativeInt;
#	Line 125 | Line 133 | type
133		procedure SetIBDataBaseErrorMessages(Value: TIBDataBaseErrorMessages);
134		end;
135
136	+	{ TFBLibrary }
137	+
138	+	TFBLibrary = class(TFBInterfacedObject,IFirebirdLibrary)
139	+	private
140	+	class var FEnvSetupDone: boolean;
141	+	class var FLibraryList: array of IFirebirdLibrary;
142	+	private
143	+	FFirebirdAPI: IFirebirdAPI;
144	+	FRequestedLibName: string;
145	+	function LoadIBLibrary: boolean;
146	+	protected
147	+	FFBLibraryName: string;
148	+	FIBLibrary: TLibHandle;
149	+	procedure FreeFBLibrary;
150	+	function GetOverrideLibName: string;
151	+	class procedure SetupEnvironment;
152	+	protected
153	+	function GetFirebird3API: IFirebirdAPI; virtual; abstract;
154	+	function GetLegacyFirebirdAPI: IFirebirdAPI; virtual; abstract;
155	+	public
156	+	constructor Create(aLibPathName: string='');
157	+	destructor Destroy; override;
158	+	class function GetFBLibrary(aLibPathName: string): IFirebirdLibrary;
159	+	class procedure FreeLibraries;
160	+	function SameLibrary(aLibName: string): boolean;
161	+
162	+	public
163	+	{IFirebirdLibrary}
164	+	function GetHandle: TLibHandle;
165	+	function GetLibraryName: string;
166	+	function GetLibraryFilePath: string;
167	+	function GetFirebirdAPI: IFirebirdAPI;
168	+	property IBLibrary: TLibHandle read FIBLibrary;
169	+	end;
170	+
171		{ TFBClientAPI }
172
173		TFBClientAPI = class(TFBInterfacedObject)
174		private
175	<	FOwnsIBLibrary: boolean;
175	>	FLocalTimeZoneName: AnsiString; {Informal Time Zone Name from tzname e.g. GMT or BST}
176	>	FTZDataTimeZoneID: AnsiString; {TZData DB ID e.g. Europe/London}
177	>	FLocalTimeOffset: integer;
178	>	FIsDaylightSavingsTime: boolean;
179		class var FIBCS: TRTLCriticalSection;
180	<	procedure LoadIBLibrary;
180	>	function FBTimeStampToDateTime(aDate, aTime: longint): TDateTime;
181	>	procedure GetTZDataSettings;
182		protected
183	<	class var FFBLibraryName: string;
137	<	class var IBLibrary: TLibHandle;
138	<	{$IFDEF WINDOWS}
139	<	class var FFBLibraryPath: string;
140	<	{$ENDIF}
183	>	FFBLibrary: TFBLibrary;
184		function GetProcAddr(ProcName: PAnsiChar): Pointer;
185	<	function GetOverrideLibName: string;
186	<	{$IFDEF UNIX}
187	<	function GetFirebirdLibList: string; virtual; abstract;
188	<	{$ENDIF}
189	<	procedure LoadInterface; virtual;
185	>
186	>	protected type
187	>	Tfb_shutdown = function (timeout: uint;
188	>	const reason: int): int;
189	>	{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
190	>	protected
191	>	{FB Shutdown API}
192	>	fb_shutdown: Tfb_shutdown;
193	>
194		public
195		{Taken from legacy API}
196		isc_sqlcode: Tisc_sqlcode;
197		isc_sql_interprete: Tisc_sql_interprete;
151	–	isc_interprete: Tisc_interprete;
198		isc_event_counts: Tisc_event_counts;
199		isc_event_block: Tisc_event_block;
200		isc_free: Tisc_free;
201
202	<	constructor Create;
157	<	destructor Destroy; override;
202	>	constructor Create(aFBLibrary: TFBLibrary);
203		procedure IBAlloc(var P; OldSize, NewSize: Integer);
204		procedure IBDataBaseError;
205	<	procedure SetupEnvironment;
205	>	function LoadInterface: boolean; virtual;
206	>	procedure FBShutdown; virtual;
207	>	function GetAPI: IFirebirdAPI; virtual; abstract;
208	>	{$IFDEF UNIX}
209	>	function GetFirebirdLibList: string; virtual; abstract;
210	>	{$ENDIF}
211	>	function HasDecFloatSupport: boolean;
212	>	function HasInt128Support: boolean; virtual;
213	>	function HasLocalTZDB: boolean; virtual;
214	>	function HasExtendedTZSupport: boolean; virtual;
215	>	function HasTimeZoneSupport: boolean; virtual;
216
217	+	public
218	+	property LocalTimeZoneName: AnsiString read FLocalTimeZoneName;
219	+	property TZDataTimeZoneID: AnsiString read FTZDataTimeZoneID;
220	+	property LocalTimeOffset: integer read FLocalTimeOffset;
221	+	public
222		{Encode/Decode}
223		procedure EncodeInteger(aValue: integer; len: integer; buffer: PByte);
224		function DecodeInteger(bufptr: PByte; len: short): integer; virtual; abstract;
225	<	procedure SQLEncodeDate(aDate: TDateTime; bufptr: PByte); virtual; abstract;
226	<	function SQLDecodeDate(byfptr: PByte): TDateTime; virtual; abstract;
227	<	procedure SQLEncodeTime(aTime: TDateTime; bufptr: PByte); virtual; abstract;
225	>	procedure SQLEncodeDate(aDate: TDateTime; bufptr: PByte);  virtual; abstract;
226	>	function SQLDecodeDate(byfptr: PByte): TDateTime;  virtual; abstract;
227	>	procedure SQLEncodeTime(aTime: TDateTime; bufptr: PByte);  virtual; abstract;
228		function SQLDecodeTime(bufptr: PByte): TDateTime;  virtual; abstract;
229		procedure SQLEncodeDateTime(aDateTime: TDateTime; bufptr: PByte); virtual; abstract;
230	<	function SQLDecodeDateTime(bufptr: PByte): TDateTime; virtual; abstract;
231	<
230	>	function  SQLDecodeDateTime(bufptr: PByte): TDateTime; virtual; abstract;
231	>	function FormatStatus(Status: TFBStatus): AnsiString; virtual; abstract;
232	>	function Int128ToStr(bufptr: PByte; scale: integer): AnsiString; virtual;
233	>	procedure StrToInt128(scale: integer; aValue: AnsiString; bufptr: PByte);
234	>	virtual;
235	>	procedure SQLDecFloatEncode(aValue: tBCD; SQLType: cardinal; bufptr: PByte); virtual;
236	>	function SQLDecFloatDecode(SQLType: cardinal;  bufptr: PByte): tBCD; virtual;
237
238		{IFirebirdAPI}
239		function GetStatus: IStatus; virtual; abstract;
240		function IsLibraryLoaded: boolean;
241		function IsEmbeddedServer: boolean; virtual; abstract;
242	<	function GetLibraryName: string;
242	>	function GetFBLibrary: IFirebirdLibrary;
243	>	function GetImplementationVersion: AnsiString;
244	>	function GetClientMajor: integer;  virtual; abstract;
245	>	function GetClientMinor: integer;  virtual; abstract;
246		end;
247
180	–	var FirebirdClientAPI: TFBClientAPI = nil;
181	–
248		implementation
249
250	<	uses IBUtils, Registry, {$IFDEF Unix} initc, {$ENDIF}
250	>	uses IBUtils, Registry,
251	>	{$IFDEF Unix} unix, initc, dl, {$ENDIF}
252		{$IFDEF FPC}
253		{$IFDEF WINDOWS }
254		WinDirs,
#	Line 197 | Line 264 | SysUtils;
264		{$I 'include/wloadlibrary.inc'}
265		{$ENDIF}
266
267	<	{$IFDEF Unix}
268	<	{SetEnvironmentVariable doesn't exist so we have to use C Library}
269	<	function setenv(name:Pchar; value:Pchar; replace:integer):integer;cdecl;external clib name 'setenv';
270	<	function unsetenv(name:Pchar):integer;cdecl;external clib name 'unsetenv';
271	<	function SetEnvironmentVariable(name:PAnsiChar; value:PAnsiChar):boolean;
272	<	// Set environment variable; if empty string given, remove it.
267	>
268	>	{ TFBLibrary }
269	>
270	>	function TFBLibrary.GetOverrideLibName: string;
271	>	begin
272	>	Result := FFBLibraryName;
273	>	if (Result = '') and AllowUseOfFBLIB then
274	>	Result := GetEnvironmentVariable('FBLIB');
275	>	if Result = '' then
276		begin
277	<	result:=false; //assume failure
278	<	if value = '' then
209	<	begin
210	<	// Assume user wants to remove variable.
211	<	if unsetenv(name)=0 then result:=true;
212	<	end
213	<	else
214	<	begin
215	<	// Non empty so set the variable
216	<	if setenv(name, value, 1)=0 then result:=true;
217	<	end;
277	>	if assigned(OnGetLibraryName) then
278	>	OnGetLibraryName(Result)
279		end;
280	<	{$ENDIF}
280	>	end;
281
282	<	{ TFBClientAPI }
282	>	procedure TFBLibrary.FreeFBLibrary;
283	>	begin
284	>	(FFirebirdAPI as TFBClientAPI).FBShutdown;
285	>	if FIBLibrary <> NilHandle then
286	>	FreeLibrary(FIBLibrary);
287	>	FIBLibrary := NilHandle;
288	>	FFBLibraryName := '';
289	>	end;
290	>
291	>	function TFBLibrary.GetLibraryName: string;
292	>	begin
293	>	Result := ExtractFileName(FFBLibraryName);
294	>	end;
295	>
296	>	function TFBLibrary.GetFirebirdAPI: IFirebirdAPI;
297	>	begin
298	>	Result := FFirebirdAPI;
299	>	end;
300
301	<	constructor TFBClientAPI.Create;
301	>	constructor TFBLibrary.Create(aLibPathName: string);
302		begin
303		inherited Create;
304	<	LoadIBLibrary;
305	<	if (IBLibrary <> NilHandle) then
304	>	SetupEnvironment;
305	>	FFBLibraryName := aLibPathName;
306	>	FIBLibrary := NilHandle;
307	>	FFirebirdAPI := GetFirebird3API;
308	>	FRequestedLibName := aLibPathName;
309	>	if aLibPathName <> '' then
310		begin
311	<	SetupEnvironment;
312	<	LoadInterface;
311	>	SetLength(FLibraryList,Length(FLibraryList)+1);
312	>	FLibraryList[Length(FLibraryList)-1] := self;
313		end;
314	<	FirebirdClientAPI := self;
314	>	if FFirebirdAPI <> nil then
315	>	begin
316	>	{First try Firebird 3}
317	>	if not LoadIBLibrary or not (FFirebirdAPI as TFBClientAPI).LoadInterface then
318	>	FFirebirdAPI := nil;
319	>	end;
320	>
321	>	if FFirebirdAPI = nil then
322	>	begin
323	>	{now try Firebird 2.5. Under Unix we need to reload the library in case we
324	>	are to use the embedded library}
325	>	FFirebirdAPI := GetLegacyFirebirdAPI;
326	>	if FFirebirdAPI <> nil then
327	>	begin
328	>	{$IFDEF UNIX}
329	>	FreeFBLibrary;
330	>	{$ENDIF}
331	>	if not LoadIBLibrary or not (FFirebirdAPI as TFBClientAPI).LoadInterface then
332	>	FFirebirdAPI := nil;
333	>	end;
334	>	end;
335	>	{Note: FFirebirdAPI will be set to nil if the Firebird API fails to load}
336		end;
337
338	<	destructor TFBClientAPI.Destroy;
338	>	destructor TFBLibrary.Destroy;
339		begin
340	<	FirebirdClientAPI := nil;
341	<	if FOwnsIBLibrary and (IBLibrary <> NilHandle) then
239	<	FreeLibrary(IBLibrary);
240	<	IBLibrary := NilHandle;
340	>	FreeFBLibrary;
341	>	FFirebirdAPI := nil;
342		inherited Destroy;
343		end;
344
345	+	class function TFBLibrary.GetFBLibrary(aLibPathName: string): IFirebirdLibrary;
346	+	var i: integer;
347	+	begin
348	+	Result := nil;
349	+	if aLibPathName <> '' then
350	+	begin
351	+	for i := 0 to Length(FLibraryList) - 1 do
352	+	begin
353	+	if (FLibraryList[i] as TFBLibrary).SameLibrary(aLibPathName) then
354	+	begin
355	+	Result := FLibraryList[i];
356	+	Exit;
357	+	end;
358	+	end;
359	+	Result := Create(aLibPathName);
360	+	end;
361	+
362	+	end;
363	+
364	+	class procedure TFBLibrary.FreeLibraries;
365	+	var i: integer;
366	+	begin
367	+	for i := 0 to Length(FLibraryList) - 1 do
368	+	FLibraryList[i] := nil;
369	+	SetLength(FLibraryList,0);
370	+	end;
371	+
372	+	function TFBLibrary.SameLibrary(aLibName: string): boolean;
373	+	begin
374	+	Result := FRequestedLibName = aLibName;
375	+	end;
376	+
377	+	function TFBLibrary.GetHandle: TLibHandle;
378	+	begin
379	+	Result := FIBLibrary;
380	+	end;
381	+
382	+	{ TFBClientAPI }
383	+
384	+	constructor TFBClientAPI.Create(aFBLibrary: TFBLibrary);
385	+	begin
386	+	inherited Create;
387	+	FFBLibrary := aFBLibrary;
388	+	GetTZDataSettings;
389	+	end;
390	+
391		procedure TFBClientAPI.IBAlloc(var P; OldSize, NewSize: Integer);
392		var
393		i: Integer;
#	Line 254 | Line 401 | begin
401		raise EIBInterBaseError.Create(GetStatus);
402		end;
403
257	–	{Under Unixes, if using an embedded server then set up local TMP and LOCK Directories}
258	–
259	–	procedure TFBClientAPI.SetupEnvironment;
260	–	var TmpDir: AnsiString;
261	–	begin
262	–	{$IFDEF UNIX}
263	–	TmpDir := GetTempDir +
264	–	DirectorySeparator + 'firebird_' + sysutils.GetEnvironmentVariable('USER');
265	–	if sysutils.GetEnvironmentVariable('FIREBIRD_TMP') = '' then
266	–	begin
267	–	if not DirectoryExists(tmpDir) then
268	–	mkdir(tmpDir);
269	–	SetEnvironmentVariable('FIREBIRD_TMP',PAnsiChar(TmpDir));
270	–	end;
271	–	if sysutils.GetEnvironmentVariable('FIREBIRD_LOCK') = '' then
272	–	begin
273	–	if not DirectoryExists(tmpDir) then
274	–	mkdir(tmpDir);
275	–	SetEnvironmentVariable('FIREBIRD_LOCK',PAnsiChar(TmpDir));
276	–	end;
277	–	{$ENDIF}
278	–	end;
279	–
404		procedure TFBClientAPI.EncodeInteger(aValue: integer; len: integer; buffer: PByte);
405		begin
406		while len > 0 do
#	Line 288 | Line 412 | begin
412		end;
413		end;
414
415	+	function TFBClientAPI.Int128ToStr(bufptr: PByte; scale: integer): AnsiString;
416	+	begin
417	+	if not HasInt128Support then
418	+	IBError(ibxeNotSupported,[]);
419	+	end;
420	+
421	+	procedure TFBClientAPI.StrToInt128(scale: integer; aValue: AnsiString; bufptr: PByte);
422	+	begin
423	+	if not HasInt128Support then
424	+	IBError(ibxeNotSupported,[]);
425	+	end;
426	+
427	+	procedure TFBClientAPI.SQLDecFloatEncode(aValue: tBCD; SQLType: cardinal;
428	+	bufptr: PByte);
429	+	begin
430	+	if not HasDecFloatSupport then
431	+	IBError(ibxeNotSupported,[]);
432	+	end;
433	+
434	+	function TFBClientAPI.SQLDecFloatDecode(SQLType: cardinal; bufptr: PByte): tBCD;
435	+	begin
436	+	if not HasDecFloatSupport then
437	+	IBError(ibxeNotSupported,[]);
438	+	end;
439	+
440		function TFBClientAPI.IsLibraryLoaded: boolean;
441		begin
442	<	Result := IBLibrary <> NilHandle;
442	>	Result := FFBLibrary.IBLibrary <> NilHandle;
443	>	end;
444	>
445	>	function TFBClientAPI.GetFBLibrary: IFirebirdLibrary;
446	>	begin
447	>	Result := FFBLibrary;
448	>	end;
449	>
450	>	function TFBClientAPI.FBTimeStampToDateTime(aDate, aTime: longint): TDateTime;
451	>	begin
452	>	{aDate/aTime are in TTimestamp format but aTime is decimilliseconds}
453	>	aDate := aDate - DateDelta;
454	>	if aDate < 0 then
455	>	Result := trunc(aDate) - abs(frac(aTime / (MSecsPerDay*10)))
456	>	else
457	>	Result := trunc(aDate) + abs(frac(aTime / (MSecsPerDay*10)));
458	>	end;
459	>
460	>	{$IFDEF UNIX}
461	>	procedure TFBClientAPI.GetTZDataSettings;
462	>	var S: TStringList;
463	>	begin
464	>	FLocalTimeOffset := GetLocalTimeOffset;
465	>	FLocalTimeZoneName := strpas(tzname[tzdaylight]);
466	>	FIsDaylightSavingsTime := tzdaylight;
467	>	if FileExists(DefaultTimeZoneFile) then
468	>	begin
469	>	S := TStringList.Create;
470	>	try
471	>	S.LoadFromFile(DefaultTimeZoneFile);
472	>	if S.Count > 0 then
473	>	FTZDataTimeZoneID := S[0];
474	>	finally
475	>	S.Free;
476	>	end;
477	>	end;
478		end;
479	+	{$ENDIF}
480	+
481	+	{$IFDEF WINDOWS}
482	+	procedure TFBClientAPI.GetTZDataSettings;
483	+	var TZInfo: TTimeZoneInformation;
484	+	begin
485	+	FIsDaylightSavingsTime := false;
486	+	{is there any way of working out the default TZData DB time zone ID under Windows?}
487	+	case GetTimeZoneInformation(TZInfo) of
488	+	TIME_ZONE_ID_UNKNOWN:
489	+	begin
490	+	FLocalTimeZoneName := '';
491	+	FLocalTimeOffset := 0;
492	+	end;
493	+	TIME_ZONE_ID_STANDARD:
494	+	begin
495	+	FLocalTimeZoneName := strpas(PWideChar(@TZInfo.StandardName));
496	+	FLocalTimeOffset := TZInfo.Bias;
497	+	end;
498	+	TIME_ZONE_ID_DAYLIGHT:
499	+	begin
500	+	FLocalTimeZoneName := strpas(PWideChar(@TZInfo.DaylightName));
501	+	FLocalTimeOffset := TZInfo.DayLightBias;
502	+	FIsDaylightSavingsTime := true;
503	+	end;
504	+	end;
505	+	end;
506	+	{$ENDIF}
507
508		function TFBClientAPI.GetProcAddr(ProcName: PAnsiChar): Pointer;
509		begin
510	<	Result := GetProcAddress(IBLibrary, ProcName);
510	>	Result := GetProcAddress(FFBLibrary.IBLibrary, ProcName);
511		if not Assigned(Result) then
512		raise Exception.CreateFmt(SFirebirdAPIFuncNotFound,[ProcName]);
513		end;
514
515	<	function TFBClientAPI.GetOverrideLibName: string;
515	>	function TFBClientAPI.HasDecFloatSupport: boolean;
516		begin
517	<	Result := '';
306	<	if AllowUseOfFBLIB then
307	<	Result := GetEnvironmentVariable('FBLIB');
308	<	if Result = '' then
309	<	begin
310	<	if assigned(OnGetLibraryName) then
311	<	OnGetLibraryName(Result)
312	<	end;
517	>	Result := GetClientMajor >= 4;
518		end;
519
520	<	procedure TFBClientAPI.LoadInterface;
520	>	function TFBClientAPI.HasInt128Support: boolean;
521	>	begin
522	>	Result := false;
523	>	end;
524	>
525	>	function TFBClientAPI.HasLocalTZDB: boolean;
526	>	begin
527	>	Result := false;
528	>	end;
529	>
530	>	function TFBClientAPI.HasExtendedTZSupport: boolean;
531	>	begin
532	>	Result := false;
533	>	end;
534	>
535	>	function TFBClientAPI.HasTimeZoneSupport: boolean;
536	>	begin
537	>	Result := false;
538	>	end;
539	>
540	>	function TFBClientAPI.GetImplementationVersion: AnsiString;
541	>	begin
542	>	Result := Format('%d.%d',[GetClientMajor,GetClientMinor]);
543	>	end;
544	>
545	>	function TFBClientAPI.LoadInterface: boolean;
546		begin
547		isc_sqlcode := GetProcAddr('isc_sqlcode'); {do not localize}
548		isc_sql_interprete := GetProcAddr('isc_sql_interprete'); {do not localize}
319	–	isc_interprete := GetProcAddr('isc_interprete'); {do not localize}
549		isc_event_counts := GetProcAddr('isc_event_counts'); {do not localize}
550		isc_event_block := GetProcAddr('isc_event_block'); {do not localize}
551		isc_free := GetProcAddr('isc_free'); {do not localize}
552	+	fb_shutdown := GetProcAddr('fb_shutdown'); {do not localize}
553	+	Result := assigned(isc_free);
554		end;
555
556	<	function TFBClientAPI.GetLibraryName: string;
556	>	procedure TFBClientAPI.FBShutdown;
557		begin
558	<	Result := FFBLibraryName;
558	>	if assigned(fb_shutdown) then
559	>	fb_shutdown(0,fb_shutrsn_exit_called);
560		end;
561
330	–	const
331	–	IBLocalBufferLength = 512;
332	–	IBBigLocalBufferLength = IBLocalBufferLength * 2;
333	–	IBHugeLocalBufferLength = IBBigLocalBufferLength * 20;
334	–
562		{ TFBStatus }
563
564		constructor TFBStatus.Create(aOwner: TFBClientAPI);
#	Line 356 | Line 583 | function TFBStatus.GetMessage: AnsiStrin
583		var local_buffer: array[0..IBHugeLocalBufferLength - 1] of AnsiChar;
584		IBDataBaseErrorMessages: TIBDataBaseErrorMessages;
585		sqlcode: Long;
359	–	psb: PStatusVector;
586		begin
587		Result := '';
588		IBDataBaseErrorMessages := FIBDataBaseErrorMessages;
#	Line 368 | Line 594 | begin
594		if (ShowSQLMessage in IBDataBaseErrorMessages) then
595		begin
596		with FOwner do
597	<	isc_sql_interprete(sqlcode, local_buffer, IBLocalBufferLength);
597	>	isc_sql_interprete(sqlcode, local_buffer, sizeof(local_buffer));
598		if (ShowSQLCode in FIBDataBaseErrorMessages) then
599		Result := Result + CRLF;
600		Result := Result + strpas(local_buffer);
#	Line 378 | Line 604 | begin
604		begin
605		if (ShowSQLCode in IBDataBaseErrorMessages) or
606		(ShowSQLMessage in IBDataBaseErrorMessages) then
607	<	Result := Result + CRLF;
608	<	psb := StatusVector;
383	<	with FOwner do
384	<	while (isc_interprete(@local_buffer, @psb) > 0) do
385	<	begin
386	<	if (Result <> '') and (Result[Length(Result)] <> LF) then
387	<	Result := Result + CRLF;
388	<	Result := Result + strpas(local_buffer);
389	<	end;
607	>	Result := Result + LineEnding;
608	>	Result := Result + FOwner.FormatStatus(self);
609		end;
610		if (Result <> '') and (Result[Length(Result)] = '.') then
611		Delete(Result, Length(Result), 1);
#	Line 444 | Line 663 | begin
663		end;
664
665		initialization
666	<	TFBClientAPI.IBLibrary := NilHandle;
666	>	TFBLibrary.FEnvSetupDone := false;
667		{$IFNDEF FPC}
668		InitializeCriticalSection(TFBClientAPI.FIBCS);
669		{$ELSE}
#	Line 452 | Line 671 | initialization
671		{$ENDIF}
672
673		finalization
674	+	TFBLibrary.FreeLibraries;
675		{$IFNDEF FPC}
676		DeleteCriticalSection(TFBClientAPI.FIBCS);
677		{$ELSE}
678		DoneCriticalSection(TFBClientAPI.FIBCS);
679		{$ENDIF}
460	–	if TFBClientAPI.IBLibrary <> NilHandle then
461	–	begin
462	–	FreeLibrary(TFBClientAPI.IBLibrary);
463	–	TFBClientAPI.IBLibrary := NilHandle;
464	–	TFBClientAPI.FFBLibraryName := '';
465	–	end;
466	–
680		end.
681

Diff Legend

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