ViewVC Help

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

root/public/ibx/branches/udr/client/FBAttachment.pas

Comparing:
ibx/branches/journaling/fbintf/client/FBAttachment.pas (file contents), Revision 363 by tony, Tue Dec 7 13:30:05 2021 UTC vs.
ibx/branches/udr/client/FBAttachment.pas (file contents), Revision 387 by tony, Wed Jan 19 13:34:42 2022 UTC

#	Line 16 | Line 16
16		*
17		*  The Initial Developer of the Original Code is Tony Whyman.
18		*
19	<	*  The Original Code is (C) 2016 Tony Whyman, MWA Software
19	>	*  The Original Code is (C) 2016-2021 Tony Whyman, MWA Software
20		*  (http://www.mwasoftware.co.uk).
21		*
22		*  All Rights Reserved.
#	Line 69 | Line 69 | type
69		Syntax:
70
71		Transaction Start:
72	<	*S:<date/time>,<session id>,<transaction no.>,<string length>:<transaction Name>,<string length>:<TPB>,<default Completion>
72	>	*S:<date/time>,<attachmentid>,<session id>,<transaction no.>,<string length>:<transaction Name>,<string length>:<TPB>,<default Completion>
73
74		Transaction Commit:
75	<	*C:<date/time>,<session id>,<transaction no.>
75	>	*C:<date/time>,<attachmentid>,<session id>,<transaction no.>
76
77		Transaction Commit retaining :
78	<	*c:<date/time>,<session id>,<transaction no.><old transaction no.>
78	>	*c:<date/time>,<attachmentid>,<session id>,<transaction no.><old transaction no.>
79
80		Transaction Rollback:
81	<	*R:<date/time>,<session id>,<transaction no.>
81	>	*R:<date/time>,<attachmentid>,<session id>,<transaction no.>
82
83		Transaction Rollback retaining:
84	<	*r:<date/time>,<session id>,<transaction no.><old transaction no.>
84	>	*r:<date/time>,<attachmentid>,<session id>,<transaction no.><old transaction no.>
85
86		Update/Insert/Delete
87	<	*Q:<date/time>,<session id>,<transaction no.>,<length of query text in bytes>:<query text>
87	>	*Q:<date/time>,<attachmentid>,<session id>,<transaction no.>,<length of query text in bytes>:<query text>
88
89		}
90
#	Line 93 | Line 93 | type
93		TFBJournaling = class(TActivityHandler, IJournallingHook)
94		private
95		{Logfile}
96	<	const sQueryJournal          = '*Q:''%s'',%d,%d,%d:%s' + LineEnding;
97	<	const sTransStartJnl         = '*S:''%s'',%d,%d,%d:%s,%d:%s,%d' + LineEnding;
98	<	const sTransCommitJnl        = '*C:''%s'',%d,%d' + LineEnding;
99	<	const sTransCommitRetJnl     = '*c:''%s'',%d,%d,%d' + LineEnding;
100	<	const sTransRollBackJnl      = '*R:''%s'',%d,%d' + LineEnding;
101	<	const sTransRollBackRetJnl   = '*r:''%s'',%d,%d,%d' + LineEnding;
96	>	const sQueryJournal          = '*Q:''%s'',%d,%d,%d,%d:%s' + LineEnding;
97	>	const sTransStartJnl         = '*S:''%s'',%d,%d,%d,%d:%s,%d:%s,%d' + LineEnding;
98	>	const sTransCommitJnl        = '*C:''%s'',%d,%d,%d' + LineEnding;
99	>	const sTransCommitFailJnl    = '*F:''%s'',%d,%d,%d' + LineEnding;
100	>	const sTransCommitRetJnl     = '*c:''%s'',%d,%d,%d,%d' + LineEnding;
101	>	const sTransRollBackJnl      = '*R:''%s'',%d,%d,%d' + LineEnding;
102	>	const sTransRollBackFailJnl  = '*f:''%s'',%d,%d,%d' + LineEnding;
103	>	const sTransRollBackRetJnl   = '*r:''%s'',%d,%d,%d,%d' + LineEnding;
104		private
105		FOptions: TJournalOptions;
106		FJournalFilePath: string;
#	Line 115 | Line 117 | type
117		public
118		{IJournallingHook}
119		procedure TransactionStart(Tr: ITransaction);
120	<	function TransactionEnd( TransactionID: integer; Action: TTransactionAction): boolean;
120	>	function TransactionEnd( TransactionID: integer; Completion: TTrCompletionState): boolean;
121		procedure TransactionRetained(Tr: ITransaction; OldTransactionID: integer;
122		Action: TTransactionAction);
123		procedure ExecQuery(Stmt: IStatement);
124	+	procedure ExecImmediateJnl(sql: AnsiString; tr: ITransaction);
125		public
126		{Client side Journaling}
127		function JournalingActive: boolean;
128		function GetJournalOptions: TJournalOptions;
129		function StartJournaling(aJournalLogFile: AnsiString): integer; overload;
130		function StartJournaling(aJournalLogFile: AnsiString; Options: TJournalOptions): integer; overload;
131	+	function StartJournaling(S: TStream; Options: TJournalOptions): integer; overload;
132		procedure StopJournaling(RetainJournal: boolean);
133		end;
134
#	Line 139 | Line 143 | type
143		FUserCharSetMap: array of TCharSetMap;
144		FSecDatabase: AnsiString;
145		FInlineBlobLimit: integer;
146	<	protected
143	<	FDatabaseName: AnsiString;
144	<	FRaiseExceptionOnConnectError: boolean;
146	>	FAttachmentID: integer;
147		FSQLDialect: integer;
148		FHasDefaultCharSet: boolean;
149		FCharSetID: integer;
150		FCodePage: TSystemCodePage;
151		FRemoteProtocol: AnsiString;
152		FAuthMethod: AnsiString;
153	+	FHasConnectionInfo: boolean;
154	+	procedure NeedDBInfo;
155	+	procedure NeedConnectionInfo;
156	+	protected
157	+	FDatabaseName: AnsiString;
158	+	FRaiseExceptionOnConnectError: boolean;
159		constructor Create(api: TFBClientAPI; DatabaseName: AnsiString; DPB: IDPB;
160		RaiseExceptionOnConnectError: boolean);
161		procedure CheckHandle; virtual; abstract;
162	+	procedure ClearCachedInfo;
163		function GenerateCreateDatabaseSQL(DatabaseName: AnsiString; aDPB: IDPB): AnsiString;
155	–	procedure GetODSAndConnectionInfo;
164		function GetDBInfo(ReqBuffer: PByte; ReqBufLen: integer): IDBInformation; virtual; abstract;
165		function IsConnected: boolean; virtual; abstract;
166		procedure EndAllTransactions;
167		procedure DPBFromCreateSQL(CreateSQL: AnsiString);
168		procedure SetParameters(SQLParams: ISQLParams; params: array of const);
169	+	procedure SetSQLDialect(aValue: integer);
170		procedure UseServerICUChanged; virtual;
171		public
172		destructor Destroy; override;
173	+	procedure Disconnect(Force: boolean); override;
174		function getFirebirdAPI: IFirebirdAPI;
175		function getDPB: IDPB;
176		function AllocateBPB: IBPB;
#	Line 217 | Line 227 | type
227		function GetEventHandler(Event: AnsiString): IEvents; overload;
228
229		function GetSQLDialect: integer;
230	+	function GetAttachmentID: integer;
231		function CreateBlob(transaction: ITransaction; RelationName, ColumnName: AnsiString; BPB: IBPB=nil): IBlob; overload;
232		function CreateBlob(transaction: ITransaction; BlobMetaData: IBlobMetaData; BPB: IBPB=nil): IBlob; overload; virtual; abstract;
233		function OpenBlob(transaction: ITransaction; BlobMetaData: IBlobMetaData; BlobID: TISC_QUAD; BPB: IBPB=nil): IBlob; overload; virtual; abstract;
#	Line 227 | Line 238 | type
238		function CreateArray(transaction: ITransaction; ArrayMetaData: IArrayMetaData): IArray; overload; virtual; abstract;
239		function OpenArray(transaction: ITransaction; RelationName, ColumnName: AnsiString; ArrayID: TISC_QUAD): IArray; overload;
240		function OpenArray(transaction: ITransaction; ArrayMetaData: IArrayMetaData; ArrayID: TISC_QUAD): IArray; overload; virtual; abstract;
241	<	property SQLDialect: integer read FSQLDialect;
241	>	property SQLDialect: integer read GetSQLDialect;
242		property DPB: IDPB read FDPB;
243		public
244		function GetDBInformation(Requests: array of byte): IDBInformation; overload;
245		function GetDBInformation(Request: byte): IDBInformation; overload;
246		function GetDBInformation(Requests: IDIRB): IDBInformation; overload;
236	–	function GetAttachmentID: integer;
247		function GetConnectString: AnsiString;
248		function GetRemoteProtocol: AnsiString;
249		function GetAuthenticationMethod: AnsiString;
250		function GetSecurityDatabase: AnsiString;
251		function GetODSMajorVersion: integer;
252		function GetODSMinorVersion: integer;
253	+	function GetCharSetID: integer;
254		function HasDecFloatSupport: boolean; virtual;
255		function GetInlineBlobLimit: integer;
256		procedure SetInlineBlobLimit(limit: integer);
257		function HasBatchMode: boolean; virtual;
258		function HasTable(aTableName: AnsiString): boolean;
259	+	function HasFunction(aFunctionName: AnsiString): boolean;
260	+	function HasProcedure(aProcName: AnsiString): boolean;
261
262		public
263		{Character Sets}
#	Line 259 | Line 272 | type
272		AllowReverseLookup:boolean; out CharSetID: integer);
273		function GetBlobMetaData(Transaction: ITransaction; tableName, columnName: AnsiString): IBlobMetaData; virtual; abstract;
274		function GetArrayMetaData(Transaction: ITransaction; tableName, columnName: AnsiString): IArrayMetaData; virtual; abstract;
275	<	property CharSetID: integer read FCharSetID;
275	>	property CharSetID: integer read GetCharSetID;
276		property CodePage: TSystemCodePage read FCodePage;
277
278		public
#	Line 473 | Line 486 | const
486		'process_name',
487		'trusted_role',
488		'org_filename',
489	<	'utf8_ilename',
489	>	'utf8_filename',
490		'ext_call_depth',
491		'auth_block',
492		'client_version',
#	Line 610 | Line 623 | end;
623
624		procedure TFBJournaling.EndSession(RetainJournal: boolean);
625		begin
626	<	if JournalingActive then
626	>	if JournalingActive and (FJournalFilePath <> '') then
627		begin
628		FreeAndNil(FJournalFileStream);
629	<	if not RetainJournal then
629	>	if not (joNoServerTable in FOptions) and not RetainJournal then
630		try
631		GetAttachment.ExecuteSQL([isc_tpb_write,isc_tpb_wait,isc_tpb_consistency],
632		sqlCleanUpSession,[FSessionID]);
#	Line 637 | Line 650 | procedure TFBJournaling.TransactionStart
650		var LogEntry: AnsiString;
651		TPBText: AnsiString;
652		begin
653	<	FDoNotJournal := true;
653	>	if not (joNoServerTable in FOptions) then
654		try
655	+	FDoNotJournal := true;
656		GetAttachment.ExecuteSQL(Tr,sqlRecordJournalEntry,[FSessionID,Tr.GetTransactionID,NULL]);
657		finally
658		FDoNotJournal := false;
659		end;
660		TPBText := Tr.getTPB.AsText;
661		LogEntry := Format(sTransStartJnl,[FBFormatDateTime(GetDateTimeFmt,Now),
662	+	GetAttachment.GetAttachmentID,
663		FSessionID,
664		Tr.GetTransactionID,
665		Length(Tr.TransactionName),
#	Line 656 | Line 671 | begin
671		end;
672
673		function TFBJournaling.TransactionEnd(TransactionID: integer;
674	<	Action: TTransactionAction): boolean;
674	>	Completion: TTrCompletionState): boolean;
675
676		var LogEntry: AnsiString;
677		begin
678		Result := false;
679	<	case Action of
680	<	TARollback:
679	>	case Completion of
680	>	trRolledback:
681		begin
682	<	LogEntry := Format(sTransRollbackJnl,[FBFormatDateTime(GetDateTimeFmt,Now),FSessionID,TransactionID]);
682	>	LogEntry := Format(sTransRollbackJnl,[FBFormatDateTime(GetDateTimeFmt,Now),
683	>	GetAttachment.GetAttachmentID,
684	>	FSessionID,TransactionID]);
685		Result := true;
686		end;
687	<	TACommit:
687	>
688	>	trRollbackFailed:
689		begin
690	<	LogEntry := Format(sTransCommitJnl,[FBFormatDateTime(GetDateTimeFmt,Now),FSessionID,TransactionID]);
690	>	LogEntry := Format(sTransRollbackFailJnl,[FBFormatDateTime(GetDateTimeFmt,Now),
691	>	GetAttachment.GetAttachmentID,
692	>	FSessionID,TransactionID]);
693	>	Result := true;
694	>	end;
695	>
696	>	trCommitted:
697	>	begin
698	>	LogEntry := Format(sTransCommitJnl,[FBFormatDateTime(GetDateTimeFmt,Now),
699	>	GetAttachment.GetAttachmentID,
700	>	FSessionID,TransactionID]);
701	>	Result := true;
702	>	end;
703	>
704	>	trCommitFailed:
705	>	begin
706	>	LogEntry := Format(sTransCommitFailJnl,[FBFormatDateTime(GetDateTimeFmt,Now),
707	>	GetAttachment.GetAttachmentID,
708	>	FSessionID,TransactionID]);
709		Result := true;
710		end;
711		end;
#	Line 684 | Line 720 | begin
720		case Action of
721		TACommitRetaining:
722		LogEntry := Format(sTransCommitRetJnl,[FBFormatDateTime(GetDateTimeFmt,Now),
723	+	GetAttachment.GetAttachmentID,
724		FSessionID,Tr.GetTransactionID,OldTransactionID]);
725		TARollbackRetaining:
726		LogEntry := Format(sTransRollbackRetJnl,[FBFormatDateTime(GetDateTimeFmt,Now),
727	+	GetAttachment.GetAttachmentID,
728		FSessionID,Tr.GetTransactionID,OldTransactionID]);
729		end;
730		if assigned(FJournalFileStream) then
731		FJournalFileStream.Write(LogEntry[1],Length(LogEntry));
732
733	<	FDoNotJournal := true;
733	>	if not (joNoServerTable in FOptions) then
734		try
735	+	FDoNotJournal := true;
736		GetAttachment.ExecuteSQL(Tr,sqlRecordJournalEntry,[FSessionID,Tr.GetTransactionID,OldTransactionID]);
737		finally
738		FDoNotJournal := false;
#	Line 706 | Line 745 | var SQL: AnsiString;
745		begin
746		SQL := TQueryProcessor.Execute(Stmt);
747		LogEntry := Format(sQueryJournal,[FBFormatDateTime(GetDateTimeFmt,Now),
748	+	GetAttachment.GetAttachmentID,
749		FSessionID,
750		Stmt.GetTransaction.GetTransactionID,
751		Length(SQL),SQL]);
#	Line 713 | Line 753 | begin
753		FJournalFileStream.Write(LogEntry[1],Length(LogEntry));
754		end;
755
756	+	procedure TFBJournaling.ExecImmediateJnl(sql: AnsiString; tr: ITransaction);
757	+	var LogEntry: AnsiString;
758	+	begin
759	+	LogEntry := Format(sQueryJournal,[FBFormatDateTime(GetDateTimeFmt,Now),
760	+	GetAttachment.GetAttachmentID,
761	+	FSessionID,
762	+	tr.GetTransactionID,
763	+	Length(sql),sql]);
764	+	if assigned(FJournalFileStream) then
765	+	FJournalFileStream.Write(LogEntry[1],Length(LogEntry));
766	+	end;
767	+
768		function TFBJournaling.JournalingActive: boolean;
769		begin
770		Result := (FJournalFileStream <> nil) and not FDoNotJournal;
#	Line 731 | Line 783 | end;
783		function TFBJournaling.StartJournaling(aJournalLogFile: AnsiString;
784		Options: TJournalOptions): integer;
785		begin
786	+	try
787	+	StartJournaling(TFileStream.Create(aJournalLogFile,fmCreate),Options);
788	+	finally
789	+	FJournalFilePath := aJournalLogFile;
790	+	end;
791	+	end;
792	+
793	+	function TFBJournaling.StartJournaling(S: TStream; Options: TJournalOptions
794	+	): integer;
795	+	begin
796		FOptions := Options;
797	+	if not (joNoServerTable in FOptions) then
798		with GetAttachment do
799		begin
800	<	if not HasTable(sJournalTableName) then
800	>	if  not HasTable(sJournalTableName) then
801		begin
802		ExecImmediate([isc_tpb_write,isc_tpb_wait,isc_tpb_consistency],sqlCreateJournalTable);
803		ExecImmediate([isc_tpb_write,isc_tpb_wait,isc_tpb_consistency],sqlCreateSequence);
804		end;
805		FSessionID := OpenCursorAtStart(sqlGetNextSessionID)[0].AsInteger;
806		end;
807	<	FJournalFilePath := aJournalLogFile;
745	<	FJournalFileStream := TFileStream.Create(FJournalFilePath,fmCreate);
807	>	FJournalFileStream := S;
808		Result := FSessionID;
809		end;
810
#	Line 751 | Line 813 | begin
813		EndSession(RetainJournal);
814		end;
815
754	–
755	–
756	–
816		{ TFBAttachment }
817
818	<	procedure TFBAttachment.GetODSAndConnectionInfo;
819	<	var DBInfo: IDBInformation;
761	<	i: integer;
762	<	Stmt: IStatement;
818	>	procedure TFBAttachment.NeedConnectionInfo;
819	>	var Stmt: IStatement;
820		ResultSet: IResultSet;
821		Param: IDPBItem;
822		begin
823	<	if not IsConnected then Exit;
824	<	DBInfo := GetDBInformation([isc_info_db_id,isc_info_ods_version,isc_info_ods_minor_version,
768	<	isc_info_db_SQL_Dialect]);
769	<	for i := 0 to DBInfo.GetCount - 1 do
770	<	with DBInfo[i] do
771	<	case getItemType of
772	<	isc_info_ods_minor_version:
773	<	FODSMinorVersion := getAsInteger;
774	<	isc_info_ods_version:
775	<	FODSMajorVersion := getAsInteger;
776	<	isc_info_db_SQL_Dialect:
777	<	FSQLDialect := getAsInteger;
778	<	end;
779	<
823	>	if not IsConnected or FHasConnectionInfo then Exit;
824	>	NeedDBInfo;
825		FCharSetID := 0;
826		FRemoteProtocol := '';
827		FAuthMethod := 'Legacy_Auth';
#	Line 822 | Line 867 | begin
867		end;
868		end;
869		FHasDefaultCharSet := CharSetID2CodePage(FCharSetID,FCodePage) and (FCharSetID > 1);
870	+	FHasConnectionInfo := true;
871	+	end;
872	+
873	+	procedure TFBAttachment.NeedDBInfo;
874	+	var DBInfo: IDBInformation;
875	+	i: integer;
876	+	begin
877	+	if not IsConnected or (FAttachmentID > 0) then Exit;
878	+	DBInfo := GetDBInformation([isc_info_db_id,isc_info_ods_version,isc_info_ods_minor_version,
879	+	isc_info_db_SQL_Dialect, isc_info_attachment_id]);
880	+	for i := 0 to DBInfo.GetCount - 1 do
881	+	with DBInfo[i] do
882	+	case getItemType of
883	+	isc_info_ods_minor_version:
884	+	FODSMinorVersion := getAsInteger;
885	+	isc_info_ods_version:
886	+	FODSMajorVersion := getAsInteger;
887	+	isc_info_db_SQL_Dialect:
888	+	FSQLDialect := getAsInteger;
889	+	isc_info_attachment_id:
890	+	FAttachmentID := getAsInteger;
891	+	end;
892		end;
893
894		constructor TFBAttachment.Create(api: TFBClientAPI; DatabaseName: AnsiString;
#	Line 831 | Line 898 | begin
898		FFirebirdAPI := api.GetAPI; {Keep reference to interface}
899		FSQLDialect := 3;
900		FDatabaseName := DatabaseName;
834	–	FDPB := DPB;
901		SetLength(FUserCharSetMap,0);
902	+	ClearCachedInfo;
903	+	FInlineBlobLimit := DefaultMaxInlineBlobLimit;
904	+	FDPB := DPB;
905		FRaiseExceptionOnConnectError := RaiseExceptionOnConnectError;
906	+	end;
907	+
908	+	procedure TFBAttachment.ClearCachedInfo;
909	+	begin
910	+	FHasDefaultCharSet := false;
911	+	FAttachmentID := 0;
912		FODSMajorVersion := 0;
913		FODSMinorVersion := 0;
914	<	FInlineBlobLimit := DefaultMaxInlineBlobLimit;
914	>	FCodePage := CP_NONE;
915	>	FCharSetID := 0;
916	>	FRemoteProtocol := '';
917	>	FAuthMethod := '';
918	>	FSecDatabase := '';
919	>	FHasConnectionInfo := false;
920		end;
921
922		function TFBAttachment.GenerateCreateDatabaseSQL(DatabaseName: AnsiString;  aDPB: IDPB): AnsiString;
#	Line 970 | Line 1050 | begin
1050		end;
1051		end;
1052
1053	+	procedure TFBAttachment.SetSQLDialect(aValue: integer);
1054	+	begin
1055	+	FSQLDialect := aValue;
1056	+	end;
1057	+
1058		procedure TFBAttachment.UseServerICUChanged;
1059		begin
1060		// Do nothing by default
#	Line 981 | Line 1066 | begin
1066		inherited Destroy;
1067		end;
1068
1069	+	procedure TFBAttachment.Disconnect(Force: boolean);
1070	+	begin
1071	+	inherited Disconnect(Force);
1072	+	ClearCachedInfo;
1073	+	end;
1074	+
1075		function TFBAttachment.getFirebirdAPI: IFirebirdAPI;
1076		begin
1077		Result := FFirebirdAPI;
#	Line 1003 | Line 1094 | end;
1094
1095		procedure TFBAttachment.ExecImmediate(TPB: array of byte; sql: AnsiString;
1096		aSQLDialect: integer);
1097	+	var tr: ITransaction;
1098		begin
1099	<	ExecImmediate(StartTransaction(TPB,taCommit),sql,aSQLDialect);
1099	>	tr := StartTransaction(TPB,taCommit);
1100	>	try
1101	>	ExecImmediate(tr,sql,aSQLDialect);
1102	>	except
1103	>	tr.Rollback(true);
1104	>	raise;
1105	>	end;
1106		end;
1107
1108		procedure TFBAttachment.ExecImmediate(transaction: ITransaction; sql: AnsiString);
#	Line 1014 | Line 1112 | end;
1112
1113		procedure TFBAttachment.ExecImmediate(TPB: array of byte; sql: AnsiString);
1114		begin
1115	<	ExecImmediate(StartTransaction(TPB,taCommit),sql,FSQLDialect);
1115	>	ExecImmediate(TPB,sql,FSQLDialect);
1116		end;
1117
1118		function TFBAttachment.ExecuteSQL(TPB: array of byte; sql: AnsiString;
1119		SQLDialect: integer; params: array of const): IResults;
1120	+	var tr: ITransaction;
1121		begin
1122	<	Result := ExecuteSQL(StartTransaction(TPB,taCommit),sql,SQLDialect,params);
1122	>	tr := StartTransaction(TPB,taCommit);
1123	>	try
1124	>	Result := ExecuteSQL(tr,sql,SQLDialect,params);
1125	>	except
1126	>	tr.Rollback(true);
1127	>	raise;
1128	>	end;
1129		end;
1130
1131		function TFBAttachment.ExecuteSQL(transaction: ITransaction; sql: AnsiString;
#	Line 1036 | Line 1141 | end;
1141		function TFBAttachment.ExecuteSQL(TPB: array of byte; sql: AnsiString;
1142		params: array of const): IResults;
1143		begin
1144	<	Result := ExecuteSQL(StartTransaction(TPB,taCommit),sql,params);
1144	>	Result := ExecuteSQL(TPB,sql,FSQLDialect,params);
1145		end;
1146
1147		function TFBAttachment.ExecuteSQL(transaction: ITransaction; sql: AnsiString;
1148		params: array of const): IResults;
1149		begin
1150	<	with Prepare(transaction,sql,FSQLDialect) do
1046	<	begin
1047	<	SetParameters(SQLParams,params);
1048	<	Result := Execute;
1049	<	end;
1150	>	Result := ExecuteSQL(transaction,sql,FSQLDialect,params);
1151		end;
1152
1153		function TFBAttachment.OpenCursor(transaction: ITransaction; sql: AnsiString;
#	Line 1139 | Line 1240 | end;
1240
1241		function TFBAttachment.OpenCursorAtStart(sql: AnsiString; Scrollable: boolean;
1242		params: array of const): IResultSet;
1243	+	var tr: ITransaction;
1244		begin
1245	<	Result := OpenCursorAtStart(StartTransaction([isc_tpb_read,isc_tpb_wait,isc_tpb_concurrency],taCommit),sql,FSQLDialect,
1246	<	Scrollable,params);
1245	>	tr := StartTransaction([isc_tpb_read,isc_tpb_wait,isc_tpb_concurrency],taCommit);
1246	>	try
1247	>	Result := OpenCursorAtStart(tr,sql,FSQLDialect,Scrollable,params);
1248	>	except
1249	>	tr.Rollback(true);
1250	>	raise;
1251	>	end;
1252		end;
1253
1254		function TFBAttachment.OpenCursorAtStart(sql: AnsiString;
1255		params: array of const): IResultSet;
1256		begin
1257	<	Result := OpenCursorAtStart(StartTransaction([isc_tpb_read,isc_tpb_wait,isc_tpb_concurrency],taCommit),sql,FSQLDialect,
1151	<	false,params);
1257	>	Result := OpenCursorAtStart(sql,false,params);
1258		end;
1259
1260		function TFBAttachment.Prepare(transaction: ITransaction; sql: AnsiString;
#	Line 1178 | Line 1284 | end;
1284
1285		function TFBAttachment.GetSQLDialect: integer;
1286		begin
1287	+	NeedDBInfo;
1288		Result := FSQLDialect;
1289		end;
1290
1291	+	function TFBAttachment.GetAttachmentID: integer;
1292	+	begin
1293	+	NeedDBInfo;
1294	+	Result := FAttachmentID;
1295	+	end;
1296	+
1297		function TFBAttachment.CreateBlob(transaction: ITransaction; RelationName,
1298		ColumnName: AnsiString; BPB: IBPB): IBlob;
1299		begin
#	Line 1250 | Line 1363 | begin
1363		Result := GetDBInfo(getBuffer,getDataLength);
1364		end;
1365
1253	–	function TFBAttachment.GetAttachmentID: integer;
1254	–	var Info: IDBInformation;
1255	–	begin
1256	–	Info := GetDBInformation(isc_info_attachment_id);
1257	–	if (Info.Count > 0) and (Info[0].getItemType = isc_info_attachment_id) then
1258	–	Result := Info[0].getAsInteger
1259	–	else
1260	–	Result := -1;
1261	–	end;
1262	–
1366		function TFBAttachment.GetConnectString: AnsiString;
1367		begin
1368		Result := FDatabaseName;
#	Line 1267 | Line 1370 | end;
1370
1371		function TFBAttachment.GetRemoteProtocol: AnsiString;
1372		begin
1373	+	NeedConnectionInfo;
1374		Result := FRemoteProtocol;
1375		end;
1376
1377		function TFBAttachment.GetAuthenticationMethod: AnsiString;
1378		begin
1379	+	NeedConnectionInfo;
1380		Result := FAuthMethod;
1381		end;
1382
1383		function TFBAttachment.GetSecurityDatabase: AnsiString;
1384		begin
1385	+	NeedConnectionInfo;
1386		Result := FSecDatabase;
1387		end;
1388
1389		function TFBAttachment.GetODSMajorVersion: integer;
1390		begin
1391	+	NeedDBInfo;
1392		Result := FODSMajorVersion;
1393		end;
1394
1395		function TFBAttachment.GetODSMinorVersion: integer;
1396		begin
1397	+	NeedDBInfo;
1398		Result := FODSMinorVersion;
1399		end;
1400
1401	+	function TFBAttachment.GetCharSetID: integer;
1402	+	begin
1403	+	NeedConnectionInfo;
1404	+	Result := FCharSetID;
1405	+	end;
1406	+
1407		function TFBAttachment.HasDecFloatSupport: boolean;
1408		begin
1409		Result := false;
#	Line 1320 | Line 1434 | begin
1434		[aTableName])[0].AsInteger > 0;
1435		end;
1436
1437	+	function TFBAttachment.HasFunction(aFunctionName: AnsiString): boolean;
1438	+	begin
1439	+	Result := OpenCursorAtStart(
1440	+	'Select count(*) From RDB$FUNCTIONS Where RDB$FUNCTION_NAME = ?',
1441	+	[aFunctionName])[0].AsInteger > 0;
1442	+	end;
1443	+
1444	+	function TFBAttachment.HasProcedure(aProcName: AnsiString): boolean;
1445	+	begin
1446	+	Result := OpenCursorAtStart(
1447	+	'Select count(*) From RDB$PROCEDURES Where RDB$PROCEDURE_NAME = ?',
1448	+	[aProcName])[0].AsInteger > 0;
1449	+	end;
1450	+
1451		function TFBAttachment.HasDefaultCharSet: boolean;
1452		begin
1453	+	NeedConnectionInfo;
1454		Result := FHasDefaultCharSet
1455		end;
1456
1457		function TFBAttachment.GetDefaultCharSetID: integer;
1458		begin
1459	+	NeedConnectionInfo;
1460		Result := FCharsetID;
1461		end;
1462

Comparing:
ibx/branches/journaling/fbintf/client/FBAttachment.pas (property svn:eol-style), Revision 363 by tony, Tue Dec 7 13:30:05 2021 UTC vs.
ibx/branches/udr/client/FBAttachment.pas (property svn:eol-style), Revision 387 by tony, Wed Jan 19 13:34:42 2022 UTC

#	Line 0 | Line 1
1	+	native

Diff Legend

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