fbintf/testsuite/Test13.pas

unit Test13;

{$mode objfpc}{$H+}
{$codepage UTF8}

{Test 13: Tranasction over two databases}

{
  The objective of this test is to test multi-database transactions. Two new
  databases are created and both are populated with a table and data. The data
  insert uses the same transaction. This is committed. Both are then read back
  to ensure that the data has been written to both.
}


interface

uses
  Classes, SysUtils, TestManager, IB;

type
    { TTest13 }

  TTest13 = class(TTestBase)
  private
    procedure UpdateDatabase(Attachment: IAttachment);
    procedure QueryDatabase(Attachment: IAttachment);
    procedure ModifyDatabase1(Attachment: IAttachment; Transaction: ITransaction);
    procedure ModifyDatabase2(Attachment: IAttachment; Transaction: ITransaction);
  public
    function TestTitle: string; override;
    procedure RunTest(CharSet: string; SQLDialect: integer); override;
  end;

implementation

const
  sqlCreateTable =
    'Create Table TestData ('+
    'RowID Integer not null,'+
    'Title VarChar(32) Character Set UTF8,'+
    'Notes VarChar(64) Character Set ISO8859_1,'+
    'BlobData Blob sub_type 1 Character Set WIN1252, '+
    'BlobData2 Blob sub_type 1 Character Set UTF8, '+
    'InClear VarChar(16) Character Set NONE, '+
    'Primary Key(RowID)'+
    ')';


  sqlInsert = 'Insert into TestData(RowID,Title,Notes, BlobData,BlobData2,InClear) Values(:RowID,:Title,:Notes,:BlobData,:BlobData2,:InClear)';


{ TTest13 }

procedure TTest13.UpdateDatabase(Attachment: IAttachment);
var Transaction: ITransaction;
    Statement: IStatement;
begin
  Transaction := Attachment.StartTransaction([isc_tpb_write,isc_tpb_nowait,isc_tpb_concurrency],taCommit);

  Statement := Attachment.PrepareWithNamedParameters(Transaction,sqlInsert);
  with Statement.GetSQLParams do
  begin
    ByName('rowid').AsInteger := 1;
    ByName('title').AsString := 'Blob Test ©€';
    ByName('Notes').AsString := 'Écoute moi';
    ByName('BlobData').AsString := 'Some German Special Characters like ÖÄÜöäüß';
    ByName('BlobData2').AsBlob := Attachment.CreateBlob(Transaction,'TestData','BlobData').SetString('Some German Special Characters like ÖÄÜöäüß');
    ByName('InClear').AsString := #$01'Test'#$0D#$C3;
  end;
  Statement.Execute;
end;

procedure TTest13.QueryDatabase(Attachment: IAttachment);
var Transaction: ITransaction;
    Statement: IStatement;
    ResultSet: IResultSet;
begin
  Transaction := Attachment.StartTransaction([isc_tpb_write,isc_tpb_nowait,isc_tpb_concurrency],taCommit);
  Statement := Attachment.Prepare(Transaction,'Select * from TestData');
  ReportResults(Statement);
end;

procedure TTest13.ModifyDatabase1(Attachment: IAttachment;
  Transaction: ITransaction);
var Statement: IStatement;
begin
  Statement := Attachment.Prepare(Transaction,'Update TestData Set Title = ''Database1''');
  Statement.Execute;
end;

procedure TTest13.ModifyDatabase2(Attachment: IAttachment;
  Transaction: ITransaction);
var Statement: IStatement;
begin
  Statement := Attachment.Prepare(Transaction,'Update TestData Set Title = ''Database2''');
  Statement.Execute;
end;

function TTest13.TestTitle: string;
begin
  Result := 'Test 13: Transaction over two databases';
end;

procedure TTest13.RunTest(CharSet: string; SQLDialect: integer);
var DPB: IDPB;
    Attachment, Attachment2: IAttachment;
    Transaction: ITransaction;
begin
  FHexStrings := true;
  DPB := FirebirdAPI.AllocateDPB;
  DPB.Add(isc_dpb_user_name).setAsString(Owner.GetUserName);
  DPB.Add(isc_dpb_password).setAsString(Owner.GetPassword);
  DPB.Add(isc_dpb_lc_ctype).setAsString('UTF8');
  DPB.Add(isc_dpb_set_db_SQL_dialect).setAsByte(SQLDialect);
  Attachment := FirebirdAPI.CreateDatabase(Owner.GetNewDatabaseName,DPB);
  Attachment.ExecImmediate([isc_tpb_write,isc_tpb_wait,isc_tpb_consistency],sqlCreateTable);

  writeln(OutFile,'Init Database 1');
  UpdateDatabase(Attachment);
  QueryDatabase(Attachment);

  {Now create second identical database}

  Attachment2 := FirebirdAPI.CreateDatabase(Owner.GetSecondNewDatabaseName,DPB);
  Attachment2.ExecImmediate([isc_tpb_write,isc_tpb_wait,isc_tpb_consistency],sqlCreateTable);

  writeln(OutFile,'Init Database 2');
  UpdateDatabase(Attachment2);
  QueryDatabase(Attachment2);

  Transaction := FirebirdAPI.StartTransaction(
                   [Attachment,Attachment2],
                   [isc_tpb_write,isc_tpb_nowait,isc_tpb_concurrency], taCommit);

  ModifyDatabase1(Attachment,Transaction);
  ModifyDatabase2(Attachment2,Transaction);

  Transaction.PrepareForCommit;
  Transaction.Commit;

  QueryDatabase(Attachment);
  QueryDatabase(Attachment2);

  Attachment.DropDatabase;
  Attachment2.DropDatabase;

end;

initialization
  RegisterTest(TTest13);
end.

Revision:	45
Committed:	Tue Dec 6 10:33:46 2016 UTC (8 years ago) by tony
Content type:	text/x-pascal
File size:	4742 byte(s)
Log Message:	Committing updates for Release R2-0-0
#	Content
1	unit Test13;
2
3	{$mode objfpc}{$H+}
4	{$codepage UTF8}
5
6	{Test 13: Tranasction over two databases}
7
8	{
9	The objective of this test is to test multi-database transactions. Two new
10	databases are created and both are populated with a table and data. The data
11	insert uses the same transaction. This is committed. Both are then read back
12	to ensure that the data has been written to both.
13	}
14
15
16	interface
17
18	uses
19	Classes, SysUtils, TestManager, IB;
20
21	type
22	{ TTest13 }
23
24	TTest13 = class(TTestBase)
25	private
26	procedure UpdateDatabase(Attachment: IAttachment);
27	procedure QueryDatabase(Attachment: IAttachment);
28	procedure ModifyDatabase1(Attachment: IAttachment; Transaction: ITransaction);
29	procedure ModifyDatabase2(Attachment: IAttachment; Transaction: ITransaction);
30	public
31	function TestTitle: string; override;
32	procedure RunTest(CharSet: string; SQLDialect: integer); override;
33	end;
34
35	implementation
36
37	const
38	sqlCreateTable =
39	'Create Table TestData ('+
40	'RowID Integer not null,'+
41	'Title VarChar(32) Character Set UTF8,'+
42	'Notes VarChar(64) Character Set ISO8859_1,'+
43	'BlobData Blob sub_type 1 Character Set WIN1252, '+
44	'BlobData2 Blob sub_type 1 Character Set UTF8, '+
45	'InClear VarChar(16) Character Set NONE, '+
46	'Primary Key(RowID)'+
47	')';
48
49
50	sqlInsert = 'Insert into TestData(RowID,Title,Notes, BlobData,BlobData2,InClear) Values(:RowID,:Title,:Notes,:BlobData,:BlobData2,:InClear)';
51
52
53	{ TTest13 }
54
55	procedure TTest13.UpdateDatabase(Attachment: IAttachment);
56	var Transaction: ITransaction;
57	Statement: IStatement;
58	begin
59	Transaction := Attachment.StartTransaction([isc_tpb_write,isc_tpb_nowait,isc_tpb_concurrency],taCommit);
60
61	Statement := Attachment.PrepareWithNamedParameters(Transaction,sqlInsert);
62	with Statement.GetSQLParams do
63	begin
64	ByName('rowid').AsInteger := 1;
65	ByName('title').AsString := 'Blob Test ©€';
66	ByName('Notes').AsString := 'Écoute moi';
67	ByName('BlobData').AsString := 'Some German Special Characters like ÖÄÜöäüß';
68	ByName('BlobData2').AsBlob := Attachment.CreateBlob(Transaction,'TestData','BlobData').SetString('Some German Special Characters like ÖÄÜöäüß');
69	ByName('InClear').AsString := #$01'Test'#$0D#$C3;
70	end;
71	Statement.Execute;
72	end;
73
74	procedure TTest13.QueryDatabase(Attachment: IAttachment);
75	var Transaction: ITransaction;
76	Statement: IStatement;
77	ResultSet: IResultSet;
78	begin
79	Transaction := Attachment.StartTransaction([isc_tpb_write,isc_tpb_nowait,isc_tpb_concurrency],taCommit);
80	Statement := Attachment.Prepare(Transaction,'Select * from TestData');
81	ReportResults(Statement);
82	end;
83
84	procedure TTest13.ModifyDatabase1(Attachment: IAttachment;
85	Transaction: ITransaction);
86	var Statement: IStatement;
87	begin
88	Statement := Attachment.Prepare(Transaction,'Update TestData Set Title = ''Database1''');
89	Statement.Execute;
90	end;
91
92	procedure TTest13.ModifyDatabase2(Attachment: IAttachment;
93	Transaction: ITransaction);
94	var Statement: IStatement;
95	begin
96	Statement := Attachment.Prepare(Transaction,'Update TestData Set Title = ''Database2''');
97	Statement.Execute;
98	end;
99
100	function TTest13.TestTitle: string;
101	begin
102	Result := 'Test 13: Transaction over two databases';
103	end;
104
105	procedure TTest13.RunTest(CharSet: string; SQLDialect: integer);
106	var DPB: IDPB;
107	Attachment, Attachment2: IAttachment;
108	Transaction: ITransaction;
109	begin
110	FHexStrings := true;
111	DPB := FirebirdAPI.AllocateDPB;
112	DPB.Add(isc_dpb_user_name).setAsString(Owner.GetUserName);
113	DPB.Add(isc_dpb_password).setAsString(Owner.GetPassword);
114	DPB.Add(isc_dpb_lc_ctype).setAsString('UTF8');
115	DPB.Add(isc_dpb_set_db_SQL_dialect).setAsByte(SQLDialect);
116	Attachment := FirebirdAPI.CreateDatabase(Owner.GetNewDatabaseName,DPB);
117	Attachment.ExecImmediate([isc_tpb_write,isc_tpb_wait,isc_tpb_consistency],sqlCreateTable);
118
119	writeln(OutFile,'Init Database 1');
120	UpdateDatabase(Attachment);
121	QueryDatabase(Attachment);
122
123	{Now create second identical database}
124
125	Attachment2 := FirebirdAPI.CreateDatabase(Owner.GetSecondNewDatabaseName,DPB);
126	Attachment2.ExecImmediate([isc_tpb_write,isc_tpb_wait,isc_tpb_consistency],sqlCreateTable);
127
128	writeln(OutFile,'Init Database 2');
129	UpdateDatabase(Attachment2);
130	QueryDatabase(Attachment2);
131
132	Transaction := FirebirdAPI.StartTransaction(
133	[Attachment,Attachment2],
134	[isc_tpb_write,isc_tpb_nowait,isc_tpb_concurrency], taCommit);
135
136	ModifyDatabase1(Attachment,Transaction);
137	ModifyDatabase2(Attachment2,Transaction);
138
139	Transaction.PrepareForCommit;
140	Transaction.Commit;
141
142	QueryDatabase(Attachment);
143	QueryDatabase(Attachment2);
144
145	Attachment.DropDatabase;
146	Attachment2.DropDatabase;
147
148	end;
149
150	initialization
151	RegisterTest(TTest13);
152	end.
153