vtallen/CipherStash-Encrypted-Database-Test-Runner
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Inital commit with most of the completed code

Browse Source
This commit is contained in:
Vincent Allen
2026-04-29 12:49:11 -04:00
commit b693a68279
469 changed files with 45970 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
__history/DataGenerator.pas.~1~ Normal file
View File

@@ -0,0 +1,43 @@
unit DataGenerator;
interface
type
TDataGenerator = class
public
constructor Create;
destructor Destroy; override;
function GenerateRandomEmail: string;
function GenerateRandomAge: Integer;
function GenerateRandomSocial: string;
end;
implementation
constructor TDataGenerator.Create;
begin
end;
destructor TDataGenerator.Destroy;
begin
end;
function TDataGenerator.GenerateRandomEmail: string;
begin
end;
function TDataGenerator.GenerateRandomSocial: string;
begin
end;
function TDataGenerator.GenerateRandomAge: Integer;
begin
end;
end.

48
__history/DataGenerator.pas.~2~ Normal file
View File

@@ -0,0 +1,48 @@
unit DataGenerator;
interface
type
TDataGenerator = class
private
var FSeed: Integer;
public
constructor Create(seed:Integer);
destructor Destroy; override;
function GenerateRandomEmail: string;
function GenerateRandomAge: Integer;
function GenerateRandomSocial: string;
end;
implementation
constructor TDataGenerator.Create(seed: Integer);
begin
RandSeed := FSeed;
end;
destructor TDataGenerator.Destroy;
begin
RandSeed := FSeed;
// set RandSeed
end;
function TDataGenerator.GenerateRandomEmail: string;
begin
RandSeed := FSeed
end;
function TDataGenerator.GenerateRandomSocial: string;
begin
end;
function TDataGenerator.GenerateRandomAge: Integer;
begin
end;
end.

47
__history/DataGenerator.pas.~3~ Normal file
View File

@@ -0,0 +1,47 @@
unit DataGenerator;
interface
type
TDataGenerator = class
private
var FSeed: Integer;
public
constructor Create(seed:Integer);
destructor Destroy; override;
function GenerateRandomEmail: string;
function GenerateRandomAge: Integer;
function GenerateRandomSocial: string;
end;
implementation
constructor TDataGenerator.Create(seed: Integer);
begin
FSeed := seed;
RandSeed := FSeed;
end;
destructor TDataGenerator.Destroy;
begin
end;
function TDataGenerator.GenerateRandomEmail: string;
begin
RandSeed := FSeed
end;
function TDataGenerator.GenerateRandomSocial: string;
begin
end;
function TDataGenerator.GenerateRandomAge: Integer;
begin
end;
end.

155
__history/DatabaseTestExecutor.pas.~15~ Normal file
View File

@@ -0,0 +1,155 @@
unit DatabaseTestExecutor;
interface
uses
System.SysUtils,
System.Diagnostics,
ZConnection,
ZDataset,
ZExceptions,
DataGenerator;
type
TDatabaseManager = class
private
FConnection: TZConnection;
FDataGenerator: TDataGenerator;
FSeed: Integer;
FStopwatch: TStopwatch;
function PerformSingleInsert(APrimaryKey: Integer): Double;
function PerformSingleRead(APrimaryKey: Integer): Double;
public
constructor Create(AConnection:TZConnection; ASeed:Integer);
destructor Destroy; override;
function SetupDatabase: Boolean;
function TestInserts(ACount:Integer): TArray<Double>;
function TestReads(ACount:Integer): TArray<Double>;
end;
implementation
constructor TDatabaseManager.Create(AConnection:TZConnection; ASeed:Integer);
begin
FSeed := ASeed;
FConnection := AConnection;
FDataGenerator := TDataGenerator.Create(FSeed);
FStopwatch := TStopwatch.Create;
end;
destructor TDatabaseManager.Destroy;
begin
FreeAndNil(FDataGenerator);
end;
function TDatabaseManager.SetupDatabase: Boolean;
begin
var Query: TZQuery;
Query := TZQuery.Create(nil);
Query.Connection := FConnection;
Query.Sql.Add('DROP TABLE IF EXISTS users');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Query.SQL.Clear;
Query.SQL.Add('CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, email VARCHAR(255), social_security_number VARCHAR(255), age INT);');
try
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end
end;
finally
FreeAndNil(Query);
end;
Result := True;
end;
function TDatabaseManager.PerformSingleInsert(APrimaryKey: Integer): Double;
begin
var LEmail: string;
LEmail := FDataGenerator.GenerateRandomEmail;
var LSocial: string;
LSocial := FDataGenerator.GenerateRandomSocial;
var LAge: Integer;
LAge := FDataGenerator.GenerateRandomAge;
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('INSERT INTO users (id, email, social_security_number, age) ' +
'VALUES (:id, :email, :ssn, :age)');
LQuery.ParamByName('id').AsInteger := APrimaryKey;
LQuery.ParamByName('email').AsString := LEmail;
LQuery.ParamByName('ssn').AsString := LSocial;
LQuery.ParamByName('age').AsInteger := LAge;
FStopwatch := TStopwatch.StartNew;
try
LQuery.ExecSQL;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.ElapsedMilliseconds;
end;
function TDatabaseManager.PerformSingleRead(APrimaryKey: Integer): Double;
begin
FStopwatch := TStopwatch.StartNew;
FStopwatch.Stop;
Result := FStopwatch.ElapsedMilliseconds;
end;
function TDatabaseManager.TestReads(ACount: Integer):Tarray<Double>;
begin
end;
function TDatabaseManager.TestInserts(ACount: Integer): TArray<Double>;
begin
Result := TArray<Double>.Create();
var Index: Integer;
for Index := 1 to ACount do
begin
var RunResult := PerformSingleInsert(Index);
if RunResult <> -1.0 then
Result := Result + [RunResult];
end;
end;
end.

160
__history/DatabaseTestExecutor.pas.~16~ Normal file
View File

@@ -0,0 +1,160 @@
unit DatabaseTestExecutor;
interface
uses
System.SysUtils,
System.Diagnostics,
ZConnection,
ZDataset,
ZExceptions,
DataGenerator;
type
TDatabaseManager = class
private
FConnection: TZConnection;
FDataGenerator: TDataGenerator;
FSeed: Integer;
FStopwatch: TStopwatch;
function PerformSingleInsert(APrimaryKey: Integer): Double;
function PerformSingleRead(APrimaryKey: Integer): Double;
public
constructor Create(AConnection:TZConnection; ASeed:Integer);
destructor Destroy; override;
function SetupDatabase: Boolean;
function TestInserts(ACount:Integer): TArray<Double>;
function TestReads(ACount:Integer): TArray<Double>;
end;
implementation
constructor TDatabaseManager.Create(AConnection:TZConnection; ASeed:Integer);
begin
FSeed := ASeed;
FConnection := AConnection;
FDataGenerator := TDataGenerator.Create(FSeed);
FStopwatch := TStopwatch.Create;
end;
destructor TDatabaseManager.Destroy;
begin
FreeAndNil(FDataGenerator);
end;
function TDatabaseManager.SetupDatabase: Boolean;
begin
var Query: TZQuery;
Query := TZQuery.Create(nil);
Query.Connection := FConnection;
Query.Sql.Add('DROP TABLE IF EXISTS users');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Query.SQL.Clear;
Query.SQL.Add('CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, email VARCHAR(255), social_security_number VARCHAR(255), age INT);');
try
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end
end;
finally
FreeAndNil(Query);
end;
Result := True;
end;
function TDatabaseManager.PerformSingleInsert(APrimaryKey: Integer): Double;
begin
var LEmail: string;
LEmail := FDataGenerator.GenerateRandomEmail;
var LSocial: string;
LSocial := FDataGenerator.GenerateRandomSocial;
var LAge: Integer;
LAge := FDataGenerator.GenerateRandomAge;
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('INSERT INTO users (id, email, social_security_number, age) ' +
'VALUES (:id, :email, :ssn, :age)');
LQuery.ParamByName('id').AsInteger := APrimaryKey;
LQuery.ParamByName('email').AsString := LEmail;
LQuery.ParamByName('ssn').AsString := LSocial;
LQuery.ParamByName('age').AsInteger := LAge;
FStopwatch := TStopwatch.StartNew;
try
LQuery.ExecSQL;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.ElapsedMilliseconds;
end;
function TDatabaseManager.PerformSingleRead(APrimaryKey: Integer): Double;
begin
FStopwatch := TStopwatch.StartNew;
FStopwatch.Stop;
Result := FStopwatch.ElapsedMilliseconds;
end;
function TDatabaseManager.TestReads(ACount: Integer):Tarray<Double>;
begin
Result := TArray<Double>.Create();
var LIndex: Integer;
for LIndex := 1 to ACount do
end;
function TDatabaseManager.TestInserts(ACount: Integer): TArray<Double>;
begin
Result := TArray<Double>.Create();
var Index: Integer;
for Index := 1 to ACount do
begin
var RunResult := PerformSingleInsert(Index);
if RunResult <> -1.0 then
Result := Result + [RunResult];
end;
end;
end.

164
__history/DatabaseTestExecutor.pas.~17~ Normal file
View File

@@ -0,0 +1,164 @@
unit DatabaseTestExecutor;
interface
uses
System.SysUtils,
System.Diagnostics,
ZConnection,
ZDataset,
ZExceptions,
DataGenerator;
type
TDatabaseManager = class
private
FConnection: TZConnection;
FDataGenerator: TDataGenerator;
FSeed: Integer;
FStopwatch: TStopwatch;
function PerformSingleInsert(APrimaryKey: Integer): Double;
function PerformSingleRead(APrimaryKey: Integer): Double;
public
constructor Create(AConnection:TZConnection; ASeed:Integer);
destructor Destroy; override;
function SetupDatabase: Boolean;
function TestInserts(ACount:Integer): TArray<Double>;
function TestReads(ACount:Integer): TArray<Double>;
end;
implementation
constructor TDatabaseManager.Create(AConnection:TZConnection; ASeed:Integer);
begin
FSeed := ASeed;
FConnection := AConnection;
FDataGenerator := TDataGenerator.Create(FSeed);
FStopwatch := TStopwatch.Create;
end;
destructor TDatabaseManager.Destroy;
begin
FreeAndNil(FDataGenerator);
end;
function TDatabaseManager.SetupDatabase: Boolean;
begin
var Query: TZQuery;
Query := TZQuery.Create(nil);
Query.Connection := FConnection;
Query.Sql.Add('DROP TABLE IF EXISTS users');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Query.SQL.Clear;
Query.SQL.Add('CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, email VARCHAR(255), social_security_number VARCHAR(255), age INT);');
try
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end
end;
finally
FreeAndNil(Query);
end;
Result := True;
end;
function TDatabaseManager.PerformSingleInsert(APrimaryKey: Integer): Double;
begin
var LEmail: string;
LEmail := FDataGenerator.GenerateRandomEmail;
var LSocial: string;
LSocial := FDataGenerator.GenerateRandomSocial;
var LAge: Integer;
LAge := FDataGenerator.GenerateRandomAge;
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('INSERT INTO users (id, email, social_security_number, age) ' +
'VALUES (:id, :email, :ssn, :age)');
LQuery.ParamByName('id').AsInteger := APrimaryKey;
LQuery.ParamByName('email').AsString := LEmail;
LQuery.ParamByName('ssn').AsString := LSocial;
LQuery.ParamByName('age').AsInteger := LAge;
FStopwatch := TStopwatch.StartNew;
try
LQuery.ExecSQL;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.ElapsedMilliseconds;
end;
function TDatabaseManager.PerformSingleRead(APrimaryKey: Integer): Double;
begin
FStopwatch := TStopwatch.StartNew;
FStopwatch.Stop;
Result := FStopwatch.ElapsedMilliseconds;
end;
function TDatabaseManager.TestReads(ACount: Integer):Tarray<Double>;
begin
Result := TArray<Double>.Create();
var LIndex: Integer;
for LIndex := 1 to ACount do
begin
var LRunResult := PerformSingleRead(LIndex);
if LRunResult <> -1.0 then
Result := Result + [LRunResult];
end;
end;
function TDatabaseManager.TestInserts(ACount: Integer): TArray<Double>;
begin
Result := TArray<Double>.Create();
var Index: Integer;
for Index := 1 to ACount do
begin
var RunResult := PerformSingleInsert(Index);
if RunResult <> -1.0 then
Result := Result + [RunResult];
end;
end;
end.

183
__history/DatabaseTestExecutor.pas.~18~ Normal file
View File

@@ -0,0 +1,183 @@
unit DatabaseTestExecutor;
interface
uses
System.SysUtils,
System.Diagnostics,
ZConnection,
ZDataset,
ZExceptions,
DataGenerator;
type
TDatabaseManager = class
private
FConnection: TZConnection;
FDataGenerator: TDataGenerator;
FSeed: Integer;
FStopwatch: TStopwatch;
function PerformSingleInsert(APrimaryKey: Integer): Double;
function PerformSingleRead(APrimaryKey: Integer): Double;
public
constructor Create(AConnection:TZConnection; ASeed:Integer);
destructor Destroy; override;
function SetupDatabase: Boolean;
function TestInserts(ACount:Integer): TArray<Double>;
function TestReads(ACount:Integer): TArray<Double>;
end;
implementation
constructor TDatabaseManager.Create(AConnection:TZConnection; ASeed:Integer);
begin
FSeed := ASeed;
FConnection := AConnection;
FDataGenerator := TDataGenerator.Create(FSeed);
FStopwatch := TStopwatch.Create;
end;
destructor TDatabaseManager.Destroy;
begin
FreeAndNil(FDataGenerator);
end;
function TDatabaseManager.SetupDatabase: Boolean;
begin
var Query: TZQuery;
Query := TZQuery.Create(nil);
Query.Connection := FConnection;
Query.Sql.Add('DROP TABLE IF EXISTS users');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Query.SQL.Clear;
Query.SQL.Add('CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, email VARCHAR(255), social_security_number VARCHAR(255), age INT);');
try
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end
end;
finally
FreeAndNil(Query);
end;
Result := True;
end;
function TDatabaseManager.PerformSingleInsert(APrimaryKey: Integer): Double;
begin
var LEmail: string;
LEmail := FDataGenerator.GenerateRandomEmail;
var LSocial: string;
LSocial := FDataGenerator.GenerateRandomSocial;
var LAge: Integer;
LAge := FDataGenerator.GenerateRandomAge;
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('INSERT INTO users (id, email, social_security_number, age) ' +
'VALUES (:id, :email, :ssn, :age)');
LQuery.ParamByName('id').AsInteger := APrimaryKey;
LQuery.ParamByName('email').AsString := LEmail;
LQuery.ParamByName('ssn').AsString := LSocial;
LQuery.ParamByName('age').AsInteger := LAge;
FStopwatch := TStopwatch.StartNew;
try
LQuery.ExecSQL;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.ElapsedMilliseconds;
end;
function TDatabaseManager.PerformSingleRead(APrimaryKey: Integer): Double;
begin
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('SELECT id, email, social_security_number, age FROM users WHERE id = :id');
LQuery.ParamByName('id').AsInteger := APrimaryKey;
FStopwatch := TStopwatch.StartNew;
try
LQuery.Open;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.ElapsedMilliseconds;
end;
function TDatabaseManager.TestReads(ACount: Integer):Tarray<Double>;
begin
Result := TArray<Double>.Create();
var LIndex: Integer;
for LIndex := 1 to ACount do
begin
var LRunResult := PerformSingleRead(LIndex);
if LRunResult <> -1.0 then
Result := Result + [LRunResult];
end;
end;
function TDatabaseManager.TestInserts(ACount: Integer): TArray<Double>;
begin
Result := TArray<Double>.Create();
var Index: Integer;
for Index := 1 to ACount do
begin
var RunResult := PerformSingleInsert(Index);
if RunResult <> -1.0 then
Result := Result + [RunResult];
end;
end;
end.

285
__history/DatabaseTestExecutor.pas.~19~ Normal file
View File

@@ -0,0 +1,285 @@
unit DatabaseTestExecutor;
interface
uses
System.SysUtils,
System.Diagnostics,
ZConnection,
ZDataset,
ZExceptions,
DataGenerator;
type
TDatabaseManager = class
private
FConnection: TZConnection;
FDataGenerator: TDataGenerator;
FSeed: Integer;
FStopwatch: TStopwatch;
FGeneratedEmails: TArray<string>;
FGeneratedSocials: TArray<string>;
FGeneratedAges: TArray<Integer>;
function PerformSingleInsert(APrimaryKey: Integer): Double;
function PerformSingleRead(APrimaryKey: Integer): Double;
function PerformSingleReadByEmail(const AEmail: string): Double;
function PerformSingleReadBySocial(const ASocial: string): Double;
public
constructor Create(AConnection:TZConnection; ASeed:Integer);
destructor Destroy; override;
function SetupDatabase: Boolean;
function TestInserts(ACount:Integer): TArray<Double>;
function TestReads(ACount:Integer): TArray<Double>;
function TestReadsByEmail: TArray<Double>;
function TestReadsBySocial: TArray<Double>;
end;
implementation
constructor TDatabaseManager.Create(AConnection:TZConnection; ASeed:Integer);
begin
FSeed := ASeed;
FConnection := AConnection;
FDataGenerator := TDataGenerator.Create(FSeed);
FStopwatch := TStopwatch.Create;
FGeneratedEmails := TArray<string>.Create();
FGeneratedSocials := TArray<string>.Create();
FGeneratedAges := TArray<Integer>.Create();
end;
destructor TDatabaseManager.Destroy;
begin
FreeAndNil(FDataGenerator);
end;
function TDatabaseManager.SetupDatabase: Boolean;
begin
var Query: TZQuery;
Query := TZQuery.Create(nil);
Query.Connection := FConnection;
Query.Sql.Add('DROP TABLE IF EXISTS users');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Query.SQL.Clear;
Query.SQL.Add('CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, email VARCHAR(255), social_security_number VARCHAR(255), age INT);');
try
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end
end;
finally
FreeAndNil(Query);
end;
Result := True;
end;
function TDatabaseManager.PerformSingleInsert(APrimaryKey: Integer): Double;
begin
var LEmail: string;
LEmail := FDataGenerator.GenerateRandomEmail;
FGeneratedEmails := FGeneratedEmails + [LEmail];
var LSocial: string;
LSocial := FDataGenerator.GenerateRandomSocial;
FGeneratedSocials := FGeneratedSocials + [LSocial];
var LAge: Integer;
LAge := FDataGenerator.GenerateRandomAge;
FGeneratedAges := FGeneratedAges + [LAge];
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('INSERT INTO users (id, email, social_security_number, age) ' +
'VALUES (:id, :email, :ssn, :age)');
LQuery.ParamByName('id').AsInteger := APrimaryKey;
LQuery.ParamByName('email').AsString := LEmail;
LQuery.ParamByName('ssn').AsString := LSocial;
LQuery.ParamByName('age').AsInteger := LAge;
FStopwatch := TStopwatch.StartNew;
try
LQuery.ExecSQL;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.PerformSingleRead(APrimaryKey: Integer): Double;
begin
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('SELECT id, email, social_security_number, age FROM users WHERE id = :id');
LQuery.ParamByName('id').AsInteger := APrimaryKey;
FStopwatch := TStopwatch.StartNew;
try
LQuery.Open;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.TestReads(ACount: Integer):Tarray<Double>;
begin
Result := TArray<Double>.Create();
var LIndex: Integer;
for LIndex := 1 to ACount do
begin
var LRunResult := PerformSingleRead(LIndex);
if LRunResult <> -1.0 then
Result := Result + [LRunResult];
end;
end;
function TDatabaseManager.PerformSingleReadByEmail(const AEmail: string): Double;
begin
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('SELECT id, email, social_security_number, age FROM users WHERE email = :email');
LQuery.ParamByName('email').AsString := AEmail;
FStopwatch := TStopwatch.StartNew;
try
LQuery.Open;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.PerformSingleReadBySocial(const ASocial: string): Double;
begin
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('SELECT id, email, social_security_number, age FROM users WHERE social_security_number = :ssn');
LQuery.ParamByName('ssn').AsString := ASocial;
FStopwatch := TStopwatch.StartNew;
try
LQuery.Open;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.TestReadsByEmail: TArray<Double>;
begin
Result := TArray<Double>.Create();
var LEmail: string;
for LEmail in FGeneratedEmails do
begin
var LRunResult := PerformSingleReadByEmail(LEmail);
if LRunResult <> -1.0 then
Result := Result + [LRunResult];
end;
end;
function TDatabaseManager.TestReadsBySocial: TArray<Double>;
begin
Result := TArray<Double>.Create();
var LSocial: string;
for LSocial in FGeneratedSocials do
begin
var LRunResult := PerformSingleReadBySocial(LSocial);
if LRunResult <> -1.0 then
Result := Result + [LRunResult];
end;
end;
function TDatabaseManager.TestInserts(ACount: Integer): TArray<Double>;
begin
SetLength(FGeneratedEmails, 0);
SetLength(FGeneratedSocials, 0);
SetLength(FGeneratedAges, 0);
Result := TArray<Double>.Create();
var Index: Integer;
for Index := 1 to ACount do
begin
var RunResult := PerformSingleInsert(Index);
if RunResult <> -1.0 then
Result := Result + [RunResult];
end;
end;
end.

287
__history/DatabaseTestExecutor.pas.~20~ Normal file
View File

@@ -0,0 +1,287 @@
unit DatabaseTestExecutor;
interface
uses
System.SysUtils,
System.Diagnostics,
ZConnection,
ZDataset,
ZExceptions,
DataGenerator;
type
TDatabaseManager = class
private
FConnection: TZConnection;
FDataGenerator: TDataGenerator;
FSeed: Integer;
FStopwatch: TStopwatch;
FUseEncryptionProxy: Boolean;
FGeneratedEmails: TArray<string>;
FGeneratedSocials: TArray<string>;
FGeneratedAges: TArray<Integer>;
function PerformSingleInsert(APrimaryKey: Integer): Double;
function PerformSingleRead(APrimaryKey: Integer): Double;
function PerformSingleReadByEmail(const AEmail: string): Double;
function PerformSingleReadBySocial(const ASocial: string): Double;
public
constructor Create(AConnection:TZConnection; ASeed:Integer; AUseEncryptionProxy: Boolean);
destructor Destroy; override;
function SetupDatabase: Boolean;
function TestInserts(ACount:Integer): TArray<Double>;
function TestReads(ACount:Integer): TArray<Double>;
function TestReadsByEmail: TArray<Double>;
function TestReadsBySocial: TArray<Double>;
end;
implementation
constructor TDatabaseManager.Create(AConnection:TZConnection; ASeed:Integer; AUseEncryptionProxy: Boolean);
begin
FSeed := ASeed;
FUseEncryptionProxy := AUseEncryptionProxy;
FConnection := AConnection;
FDataGenerator := TDataGenerator.Create(FSeed);
FStopwatch := TStopwatch.Create;
FGeneratedEmails := TArray<string>.Create();
FGeneratedSocials := TArray<string>.Create();
FGeneratedAges := TArray<Integer>.Create();
end;
destructor TDatabaseManager.Destroy;
begin
FreeAndNil(FDataGenerator);
end;
function TDatabaseManager.SetupDatabase: Boolean;
begin
var Query: TZQuery;
Query := TZQuery.Create(nil);
Query.Connection := FConnection;
Query.Sql.Add('DROP TABLE IF EXISTS users');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Query.SQL.Clear;
Query.SQL.Add('CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, email VARCHAR(255), social_security_number VARCHAR(255), age INT);');
try
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end
end;
finally
FreeAndNil(Query);
end;
Result := True;
end;
function TDatabaseManager.PerformSingleInsert(APrimaryKey: Integer): Double;
begin
var LEmail: string;
LEmail := FDataGenerator.GenerateRandomEmail;
FGeneratedEmails := FGeneratedEmails + [LEmail];
var LSocial: string;
LSocial := FDataGenerator.GenerateRandomSocial;
FGeneratedSocials := FGeneratedSocials + [LSocial];
var LAge: Integer;
LAge := FDataGenerator.GenerateRandomAge;
FGeneratedAges := FGeneratedAges + [LAge];
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('INSERT INTO users (id, email, social_security_number, age) ' +
'VALUES (:id, :email, :ssn, :age)');
LQuery.ParamByName('id').AsInteger := APrimaryKey;
LQuery.ParamByName('email').AsString := LEmail;
LQuery.ParamByName('ssn').AsString := LSocial;
LQuery.ParamByName('age').AsInteger := LAge;
FStopwatch := TStopwatch.StartNew;
try
LQuery.ExecSQL;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.PerformSingleRead(APrimaryKey: Integer): Double;
begin
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('SELECT id, email, social_security_number, age FROM users WHERE id = :id');
LQuery.ParamByName('id').AsInteger := APrimaryKey;
FStopwatch := TStopwatch.StartNew;
try
LQuery.Open;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.TestReads(ACount: Integer):Tarray<Double>;
begin
Result := TArray<Double>.Create();
var LIndex: Integer;
for LIndex := 1 to ACount do
begin
var LRunResult := PerformSingleRead(LIndex);
if LRunResult <> -1.0 then
Result := Result + [LRunResult];
end;
end;
function TDatabaseManager.PerformSingleReadByEmail(const AEmail: string): Double;
begin
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('SELECT id, email, social_security_number, age FROM users WHERE email = :email');
LQuery.ParamByName('email').AsString := AEmail;
FStopwatch := TStopwatch.StartNew;
try
LQuery.Open;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.PerformSingleReadBySocial(const ASocial: string): Double;
begin
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('SELECT id, email, social_security_number, age FROM users WHERE social_security_number = :ssn');
LQuery.ParamByName('ssn').AsString := ASocial;
FStopwatch := TStopwatch.StartNew;
try
LQuery.Open;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.TestReadsByEmail: TArray<Double>;
begin
Result := TArray<Double>.Create();
var LEmail: string;
for LEmail in FGeneratedEmails do
begin
var LRunResult := PerformSingleReadByEmail(LEmail);
if LRunResult <> -1.0 then
Result := Result + [LRunResult];
end;
end;
function TDatabaseManager.TestReadsBySocial: TArray<Double>;
begin
Result := TArray<Double>.Create();
var LSocial: string;
for LSocial in FGeneratedSocials do
begin
var LRunResult := PerformSingleReadBySocial(LSocial);
if LRunResult <> -1.0 then
Result := Result + [LRunResult];
end;
end;
function TDatabaseManager.TestInserts(ACount: Integer): TArray<Double>;
begin
SetLength(FGeneratedEmails, 0);
SetLength(FGeneratedSocials, 0);
SetLength(FGeneratedAges, 0);
Result := TArray<Double>.Create();
var Index: Integer;
for Index := 1 to ACount do
begin
var RunResult := PerformSingleInsert(Index);
if RunResult <> -1.0 then
Result := Result + [RunResult];
end;
end;
end.

299
__history/DatabaseTestExecutor.pas.~21~ Normal file
View File

@@ -0,0 +1,299 @@
unit DatabaseTestExecutor;
interface
uses
System.SysUtils,
System.Diagnostics,
ZConnection,
ZDataset,
ZExceptions,
DataGenerator;
type
TDatabaseManager = class
private
FConnection: TZConnection;
FDataGenerator: TDataGenerator;
FSeed: Integer;
FStopwatch: TStopwatch;
FUseEncryptionProxy: Boolean;
FGeneratedEmails: TArray<string>;
FGeneratedSocials: TArray<string>;
FGeneratedAges: TArray<Integer>;
function PerformSingleInsert(APrimaryKey: Integer): Double;
function PerformSingleRead(APrimaryKey: Integer): Double;
function PerformSingleReadByEmail(const AEmail: string): Double;
function PerformSingleReadBySocial(const ASocial: string): Double;
public
constructor Create(AConnection:TZConnection; ASeed:Integer; AUseEncryptionProxy: Boolean);
destructor Destroy; override;
function SetupDatabase: Boolean;
function TestInserts(ACount:Integer): TArray<Double>;
function TestReads(ACount:Integer): TArray<Double>;
function TestReadsByEmail: TArray<Double>;
function TestReadsBySocial: TArray<Double>;
end;
implementation
constructor TDatabaseManager.Create(AConnection:TZConnection; ASeed:Integer; AUseEncryptionProxy: Boolean);
begin
FSeed := ASeed;
FUseEncryptionProxy := AUseEncryptionProxy;
FConnection := AConnection;
FDataGenerator := TDataGenerator.Create(FSeed);
FStopwatch := TStopwatch.Create;
FGeneratedEmails := TArray<string>.Create();
FGeneratedSocials := TArray<string>.Create();
FGeneratedAges := TArray<Integer>.Create();
end;
destructor TDatabaseManager.Destroy;
begin
FreeAndNil(FDataGenerator);
end;
function TDatabaseManager.SetupDatabase: Boolean;
begin
var Query: TZQuery;
Query := TZQuery.Create(nil);
Query.Connection := FConnection;
Query.Sql.Add('DROP TABLE IF EXISTS users');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Query.SQL.Clear;
// We need to create the test table in a specific way if
// we are going to run the command through the proxy
if FUseEncryptionProxy then
begin
Query.SQL.Add('CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, email eql_v2_encrypted, social_security_number eql_v2_encrypted, age eql_v2_encrypted);');
end
else
begin
Query.SQL.Add('CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, email VARCHAR(255), social_security_number VARCHAR(255), age INT);');
end;
try
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end
end;
finally
FreeAndNil(Query);
end;
Result := True;
end;
function TDatabaseManager.PerformSingleInsert(APrimaryKey: Integer): Double;
begin
var LEmail: string;
LEmail := FDataGenerator.GenerateRandomEmail;
FGeneratedEmails := FGeneratedEmails + [LEmail];
var LSocial: string;
LSocial := FDataGenerator.GenerateRandomSocial;
FGeneratedSocials := FGeneratedSocials + [LSocial];
var LAge: Integer;
LAge := FDataGenerator.GenerateRandomAge;
FGeneratedAges := FGeneratedAges + [LAge];
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('INSERT INTO users (id, email, social_security_number, age) ' +
'VALUES (:id, :email, :ssn, :age)');
LQuery.ParamByName('id').AsInteger := APrimaryKey;
LQuery.ParamByName('email').AsString := LEmail;
LQuery.ParamByName('ssn').AsString := LSocial;
LQuery.ParamByName('age').AsInteger := LAge;
FStopwatch := TStopwatch.StartNew;
try
LQuery.ExecSQL;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.PerformSingleRead(APrimaryKey: Integer): Double;
begin
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('SELECT id, email, social_security_number, age FROM users WHERE id = :id');
LQuery.ParamByName('id').AsInteger := APrimaryKey;
FStopwatch := TStopwatch.StartNew;
try
LQuery.Open;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.TestReads(ACount: Integer):Tarray<Double>;
begin
Result := TArray<Double>.Create();
var LIndex: Integer;
for LIndex := 1 to ACount do
begin
var LRunResult := PerformSingleRead(LIndex);
if LRunResult <> -1.0 then
Result := Result + [LRunResult];
end;
end;
function TDatabaseManager.PerformSingleReadByEmail(const AEmail: string): Double;
begin
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('SELECT id, email, social_security_number, age FROM users WHERE email = :email');
LQuery.ParamByName('email').AsString := AEmail;
FStopwatch := TStopwatch.StartNew;
try
LQuery.Open;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.PerformSingleReadBySocial(const ASocial: string): Double;
begin
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('SELECT id, email, social_security_number, age FROM users WHERE social_security_number = :ssn');
LQuery.ParamByName('ssn').AsString := ASocial;
FStopwatch := TStopwatch.StartNew;
try
LQuery.Open;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.TestReadsByEmail: TArray<Double>;
begin
Result := TArray<Double>.Create();
var LEmail: string;
for LEmail in FGeneratedEmails do
begin
var LRunResult := PerformSingleReadByEmail(LEmail);
if LRunResult <> -1.0 then
Result := Result + [LRunResult];
end;
end;
function TDatabaseManager.TestReadsBySocial: TArray<Double>;
begin
Result := TArray<Double>.Create();
var LSocial: string;
for LSocial in FGeneratedSocials do
begin
var LRunResult := PerformSingleReadBySocial(LSocial);
if LRunResult <> -1.0 then
Result := Result + [LRunResult];
end;
end;
function TDatabaseManager.TestInserts(ACount: Integer): TArray<Double>;
begin
SetLength(FGeneratedEmails, 0);
SetLength(FGeneratedSocials, 0);
SetLength(FGeneratedAges, 0);
Result := TArray<Double>.Create();
var Index: Integer;
for Index := 1 to ACount do
begin
var RunResult := PerformSingleInsert(Index);
if RunResult <> -1.0 then
Result := Result + [RunResult];
end;
end;
end.

298
__history/DatabaseTestExecutor.pas.~22~ Normal file
View File

@@ -0,0 +1,298 @@
unit DatabaseTestExecutor;
interface
uses
System.SysUtils,
System.Diagnostics,
ZConnection,
ZDataset,
ZExceptions,
DataGenerator;
type
TDatabaseManager = class
private
FConnection: TZConnection;
FDataGenerator: TDataGenerator;
FSeed: Integer;
FStopwatch: TStopwatch;
FUseEncryptionProxy: Boolean;
FGeneratedEmails: TArray<string>;
FGeneratedSocials: TArray<string>;
FGeneratedAges: TArray<Integer>;
function PerformSingleInsert(APrimaryKey: Integer): Double;
function PerformSingleRead(APrimaryKey: Integer): Double;
function PerformSingleReadByEmail(const AEmail: string): Double;
function PerformSingleReadBySocial(const ASocial: string): Double;
public
constructor Create(AConnection:TZConnection; ASeed:Integer; AUseEncryptionProxy: Boolean);
destructor Destroy; override;
function SetupDatabase: Boolean;
function TestInserts(ACount:Integer): TArray<Double>;
function TestReads(ACount:Integer): TArray<Double>;
function TestReadsByEmail: TArray<Double>;
function TestReadsBySocial: TArray<Double>;
end;
implementation
constructor TDatabaseManager.Create(AConnection:TZConnection; ASeed:Integer; AUseEncryptionProxy: Boolean);
begin
FSeed := ASeed;
FUseEncryptionProxy := AUseEncryptionProxy;
FConnection := AConnection;
FDataGenerator := TDataGenerator.Create(FSeed);
FStopwatch := TStopwatch.Create;
FGeneratedEmails := TArray<string>.Create();
FGeneratedSocials := TArray<string>.Create();
FGeneratedAges := TArray<Integer>.Create();
end;
destructor TDatabaseManager.Destroy;
begin
FreeAndNil(FDataGenerator);
end;
function TDatabaseManager.SetupDatabase: Boolean;
begin
var Query: TZQuery;
Query := TZQuery.Create(nil);
Query.Connection := FConnection;
Query.Sql.Add('DROP TABLE IF EXISTS users');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Query.SQL.Clear;
// We need to create the test table in a specific way if
// we are going to run the command through the proxy
if FUseEncryptionProxy then
begin
Query.SQL.Add('CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, email eql_v2_encrypted, social_security_number eql_v2_encrypted, age eql_v2_encrypted);');
end
else
begin
Query.SQL.Add('CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, email VARCHAR(255), social_security_number VARCHAR(255), age INT);');
end;
try
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end
end;
finally
FreeAndNil(Query);
end;
Result := True;
end;
function TDatabaseManager.PerformSingleInsert(APrimaryKey: Integer): Double;
begin
var LEmail: string;
LEmail := FDataGenerator.GenerateRandomEmail;
FGeneratedEmails := FGeneratedEmails + [LEmail];
var LSocial: string;
LSocial := FDataGenerator.GenerateRandomSocial;
FGeneratedSocials := FGeneratedSocials + [LSocial];
var LAge: Integer;
LAge := FDataGenerator.GenerateRandomAge;
FGeneratedAges := FGeneratedAges + [LAge];
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('INSERT INTO users (id, email, social_security_number, age) ' +
'VALUES (:id, :email, :ssn, :age)');
LQuery.ParamByName('id').AsInteger := APrimaryKey;
LQuery.ParamByName('email').AsString := LEmail;
LQuery.ParamByName('ssn').AsString := LSocial;
LQuery.ParamByName('age').AsInteger := LAge;
FStopwatch := TStopwatch.StartNew;
try
LQuery.ExecSQL;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.PerformSingleRead(APrimaryKey: Integer): Double;
begin
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('SELECT id, email, social_security_number, age FROM users WHERE id = :id');
LQuery.ParamByName('id').AsInteger := APrimaryKey;
FStopwatch := TStopwatch.StartNew;
try
LQuery.Open;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.TestReads(ACount: Integer):Tarray<Double>;
begin
Result := TArray<Double>.Create();
var LIndex: Integer;
for LIndex := 1 to ACount do
begin
var LRunResult := PerformSingleRead(LIndex);
if LRunResult <> -1.0 then
Result := Result + [LRunResult];
end;
end;
function TDatabaseManager.PerformSingleReadByEmail(const AEmail: string): Double;
begin
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('SELECT id, email, social_security_number, age FROM users WHERE email = :email');
LQuery.ParamByName('email').AsString := AEmail;
FStopwatch := TStopwatch.StartNew;
try
LQuery.Open;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.PerformSingleReadBySocial(const ASocial: string): Double;
begin
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('SELECT id, email, social_security_number, age FROM users WHERE social_security_number = :ssn');
LQuery.ParamByName('ssn').AsString := ASocial;
FStopwatch := TStopwatch.StartNew;
try
LQuery.Open;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.TestReadsByEmail: TArray<Double>;
begin
Result := TArray<Double>.Create();
var LEmail: string;
for LEmail in FGeneratedEmails do
begin
var LRunResult := PerformSingleReadByEmail(LEmail);
if LRunResult <> -1.0 then
Result := Result + [LRunResult];
end;
end;
function TDatabaseManager.TestReadsBySocial: TArray<Double>;
begin
Result := TArray<Double>.Create();
var LSocial: string;
for LSocial in FGeneratedSocials do
begin
var LRunResult := PerformSingleReadBySocial(LSocial);
if LRunResult <> -1.0 then
Result := Result + [LRunResult];
end;
end;
function TDatabaseManager.TestInserts(ACount: Integer): TArray<Double>;
begin
SetLength(FGeneratedEmails, 0);
SetLength(FGeneratedSocials, 0);
SetLength(FGeneratedAges, 0);
Result := TArray<Double>.Create();
var Index: Integer;
for Index := 1 to ACount do
begin
var RunResult := PerformSingleInsert(Index);
if RunResult <> -1.0 then
Result := Result + [RunResult];
end;
end;
end.

322
__history/DatabaseTestExecutor.pas.~23~ Normal file
View File

@@ -0,0 +1,322 @@
unit DatabaseTestExecutor;
interface
uses
System.SysUtils,
System.Diagnostics,
ZConnection,
ZDataset,
ZExceptions,
DataGenerator;
type
TDatabaseManager = class
private
FConnection: TZConnection;
FDataGenerator: TDataGenerator;
FSeed: Integer;
FStopwatch: TStopwatch;
FUseEncryptionProxy: Boolean;
FGeneratedEmails: TArray<string>;
FGeneratedSocials: TArray<string>;
FGeneratedAges: TArray<Integer>;
function PerformSingleInsert(APrimaryKey: Integer): Double;
function PerformSingleRead(APrimaryKey: Integer): Double;
function PerformSingleReadByEmail(const AEmail: string): Double;
function PerformSingleReadBySocial(const ASocial: string): Double;
public
constructor Create(AConnection:TZConnection; ASeed:Integer; AUseEncryptionProxy: Boolean);
destructor Destroy; override;
function SetupDatabase: Boolean;
function TestInserts(ACount:Integer): TArray<Double>;
function TestReads(ACount:Integer): TArray<Double>;
function TestReadsByEmail: TArray<Double>;
function TestReadsBySocial: TArray<Double>;
end;
implementation
constructor TDatabaseManager.Create(AConnection:TZConnection; ASeed:Integer; AUseEncryptionProxy: Boolean);
begin
FSeed := ASeed;
FUseEncryptionProxy := AUseEncryptionProxy;
FConnection := AConnection;
FDataGenerator := TDataGenerator.Create(FSeed);
FStopwatch := TStopwatch.Create;
FGeneratedEmails := TArray<string>.Create();
FGeneratedSocials := TArray<string>.Create();
FGeneratedAges := TArray<Integer>.Create();
end;
destructor TDatabaseManager.Destroy;
begin
FreeAndNil(FDataGenerator);
end;
function TDatabaseManager.SetupDatabase: Boolean;
begin
var Query: TZQuery;
Query := TZQuery.Create(nil);
Query.Connection := FConnection;
Query.Sql.Add('DROP TABLE IF EXISTS users');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Query.SQL.Clear;
// We need to create the test table in a specific way if
// we are going to run the command through the proxy
if FUseEncryptionProxy then
begin
Query.SQL.Add('CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, email eql_v2_encrypted, social_security_number eql_v2_encrypted, age eql_v2_encrypted);');
end
else
begin
Query.SQL.Add('CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, email VARCHAR(255), social_security_number VARCHAR(255), age INT);');
end;
try
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end
end;
finally
FreeAndNil(Query);
end;
// When using cipher stash we need to do some configuration
// on the table to enable each type of search we want to be able to
// do
Query := TZQuery.Create(nil);
Query.Connection := FConnection;
Query.SQL.Add('SELECT eql_v2.add_search_config(''users'', ''email'', ''unique'', ''text'');');
Query.SQL.Add('SELECT eql_v2.add_search_config(''users'', ''social_security_number'', ''unique'', ''text'');');
try
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
finally
FreeAndNil(Query)
end;
Result := True;
end;
function TDatabaseManager.PerformSingleInsert(APrimaryKey: Integer): Double;
begin
var LEmail: string;
LEmail := FDataGenerator.GenerateRandomEmail;
FGeneratedEmails := FGeneratedEmails + [LEmail];
var LSocial: string;
LSocial := FDataGenerator.GenerateRandomSocial;
FGeneratedSocials := FGeneratedSocials + [LSocial];
var LAge: Integer;
LAge := FDataGenerator.GenerateRandomAge;
FGeneratedAges := FGeneratedAges + [LAge];
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('INSERT INTO users (id, email, social_security_number, age) ' +
'VALUES (:id, :email, :ssn, :age)');
LQuery.ParamByName('id').AsInteger := APrimaryKey;
LQuery.ParamByName('email').AsString := LEmail;
LQuery.ParamByName('ssn').AsString := LSocial;
LQuery.ParamByName('age').AsInteger := LAge;
FStopwatch := TStopwatch.StartNew;
try
LQuery.ExecSQL;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.PerformSingleRead(APrimaryKey: Integer): Double;
begin
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('SELECT id, email, social_security_number, age FROM users WHERE id = :id');
LQuery.ParamByName('id').AsInteger := APrimaryKey;
FStopwatch := TStopwatch.StartNew;
try
LQuery.Open;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.TestReads(ACount: Integer):Tarray<Double>;
begin
Result := TArray<Double>.Create();
var LIndex: Integer;
for LIndex := 1 to ACount do
begin
var LRunResult := PerformSingleRead(LIndex);
if LRunResult <> -1.0 then
Result := Result + [LRunResult];
end;
end;
function TDatabaseManager.PerformSingleReadByEmail(const AEmail: string): Double;
begin
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('SELECT id, email, social_security_number, age FROM users WHERE email = :email');
LQuery.ParamByName('email').AsString := AEmail;
FStopwatch := TStopwatch.StartNew;
try
LQuery.Open;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.PerformSingleReadBySocial(const ASocial: string): Double;
begin
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('SELECT id, email, social_security_number, age FROM users WHERE social_security_number = :ssn');
LQuery.ParamByName('ssn').AsString := ASocial;
FStopwatch := TStopwatch.StartNew;
try
LQuery.Open;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.TestReadsByEmail: TArray<Double>;
begin
Result := TArray<Double>.Create();
var LEmail: string;
for LEmail in FGeneratedEmails do
begin
var LRunResult := PerformSingleReadByEmail(LEmail);
if LRunResult <> -1.0 then
Result := Result + [LRunResult];
end;
end;
function TDatabaseManager.TestReadsBySocial: TArray<Double>;
begin
Result := TArray<Double>.Create();
var LSocial: string;
for LSocial in FGeneratedSocials do
begin
var LRunResult := PerformSingleReadBySocial(LSocial);
if LRunResult <> -1.0 then
Result := Result + [LRunResult];
end;
end;
function TDatabaseManager.TestInserts(ACount: Integer): TArray<Double>;
begin
SetLength(FGeneratedEmails, 0);
SetLength(FGeneratedSocials, 0);
SetLength(FGeneratedAges, 0);
Result := TArray<Double>.Create();
var Index: Integer;
for Index := 1 to ACount do
begin
var RunResult := PerformSingleInsert(Index);
if RunResult <> -1.0 then
Result := Result + [RunResult];
end;
end;
end.

317
__history/DatabaseTestExecutor.pas.~24~ Normal file
View File

@@ -0,0 +1,317 @@
unit DatabaseTestExecutor;
interface
uses
System.SysUtils,
System.Diagnostics,
ZConnection,
ZDataset,
ZExceptions,
DataGenerator;
type
TDatabaseManager = class
private
FConnection: TZConnection;
FDataGenerator: TDataGenerator;
FSeed: Integer;
FStopwatch: TStopwatch;
FUseEncryptionProxy: Boolean;
FGeneratedEmails: TArray<string>;
FGeneratedSocials: TArray<string>;
FGeneratedAges: TArray<Integer>;
function PerformSingleInsert(APrimaryKey: Integer): Double;
function PerformSingleRead(APrimaryKey: Integer): Double;
function PerformSingleReadByEmail(const AEmail: string): Double;
function PerformSingleReadBySocial(const ASocial: string): Double;
public
constructor Create(AConnection:TZConnection; ASeed:Integer; AUseEncryptionProxy: Boolean);
destructor Destroy; override;
function SetupDatabase: Boolean;
function TestInserts(ACount:Integer): TArray<Double>;
function TestReads(ACount:Integer): TArray<Double>;
function TestReadsByEmail: TArray<Double>;
function TestReadsBySocial: TArray<Double>;
end;
implementation
constructor TDatabaseManager.Create(AConnection:TZConnection; ASeed:Integer; AUseEncryptionProxy: Boolean);
begin
FSeed := ASeed;
FUseEncryptionProxy := AUseEncryptionProxy;
FConnection := AConnection;
FDataGenerator := TDataGenerator.Create(FSeed);
FStopwatch := TStopwatch.Create;
FGeneratedEmails := TArray<string>.Create();
FGeneratedSocials := TArray<string>.Create();
FGeneratedAges := TArray<Integer>.Create();
end;
destructor TDatabaseManager.Destroy;
begin
FreeAndNil(FDataGenerator);
end;
function TDatabaseManager.SetupDatabase: Boolean;
begin
var Query: TZQuery;
Query := TZQuery.Create(nil);
Query.Connection := FConnection;
Query.Sql.Add('DROP TABLE IF EXISTS users');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Query.SQL.Clear;
// We need to create the test table in a specific way if
// we are going to run the command through the proxy
if FUseEncryptionProxy then
begin
Query.SQL.Add('CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, email eql_v2_encrypted, social_security_number eql_v2_encrypted, age eql_v2_encrypted);');
// When using cipher stash we need to do some configuration
// on the table to enable each type of search we want to be able to
// do
Query.SQL.Add('SELECT eql_v2.add_search_config(''users'', ''email'', ''unique'', ''text'');');
Query.SQL.Add('SELECT eql_v2.add_search_config(''users'', ''social_security_number'', ''unique'', ''text'');');
end
else
begin
Query.SQL.Add('CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, email VARCHAR(255), social_security_number VARCHAR(255), age INT);');
end;
try
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end
end;
finally
FreeAndNil(Query);
end;
try
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
finally
FreeAndNil(Query)
end;
Result := True;
end;
function TDatabaseManager.PerformSingleInsert(APrimaryKey: Integer): Double;
begin
var LEmail: string;
LEmail := FDataGenerator.GenerateRandomEmail;
FGeneratedEmails := FGeneratedEmails + [LEmail];
var LSocial: string;
LSocial := FDataGenerator.GenerateRandomSocial;
FGeneratedSocials := FGeneratedSocials + [LSocial];
var LAge: Integer;
LAge := FDataGenerator.GenerateRandomAge;
FGeneratedAges := FGeneratedAges + [LAge];
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('INSERT INTO users (id, email, social_security_number, age) ' +
'VALUES (:id, :email, :ssn, :age)');
LQuery.ParamByName('id').AsInteger := APrimaryKey;
LQuery.ParamByName('email').AsString := LEmail;
LQuery.ParamByName('ssn').AsString := LSocial;
LQuery.ParamByName('age').AsInteger := LAge;
FStopwatch := TStopwatch.StartNew;
try
LQuery.ExecSQL;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.PerformSingleRead(APrimaryKey: Integer): Double;
begin
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('SELECT id, email, social_security_number, age FROM users WHERE id = :id');
LQuery.ParamByName('id').AsInteger := APrimaryKey;
FStopwatch := TStopwatch.StartNew;
try
LQuery.Open;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.TestReads(ACount: Integer):Tarray<Double>;
begin
Result := TArray<Double>.Create();
var LIndex: Integer;
for LIndex := 1 to ACount do
begin
var LRunResult := PerformSingleRead(LIndex);
if LRunResult <> -1.0 then
Result := Result + [LRunResult];
end;
end;
function TDatabaseManager.PerformSingleReadByEmail(const AEmail: string): Double;
begin
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('SELECT id, email, social_security_number, age FROM users WHERE email = :email');
LQuery.ParamByName('email').AsString := AEmail;
FStopwatch := TStopwatch.StartNew;
try
LQuery.Open;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.PerformSingleReadBySocial(const ASocial: string): Double;
begin
var LQuery: TZQuery;
try
LQuery := TZQuery.Create(nil);
LQuery.Connection := FConnection;
LQuery.SQL.Add('SELECT id, email, social_security_number, age FROM users WHERE social_security_number = :ssn');
LQuery.ParamByName('ssn').AsString := ASocial;
FStopwatch := TStopwatch.StartNew;
try
LQuery.Open;
except
on E: EZSQLException do
begin
Exit(-1.0);
end
end;
finally
FreeAndNil(LQuery);
end;
FStopwatch.Stop;
Result := FStopwatch.Elapsed.TotalMilliseconds;
end;
function TDatabaseManager.TestReadsByEmail: TArray<Double>;
begin
Result := TArray<Double>.Create();
var LEmail: string;
for LEmail in FGeneratedEmails do
begin
var LRunResult := PerformSingleReadByEmail(LEmail);
if LRunResult <> -1.0 then
Result := Result + [LRunResult];
end;
end;
function TDatabaseManager.TestReadsBySocial: TArray<Double>;
begin
Result := TArray<Double>.Create();
var LSocial: string;
for LSocial in FGeneratedSocials do
begin
var LRunResult := PerformSingleReadBySocial(LSocial);
if LRunResult <> -1.0 then
Result := Result + [LRunResult];
end;
end;
function TDatabaseManager.TestInserts(ACount: Integer): TArray<Double>;
begin
SetLength(FGeneratedEmails, 0);
SetLength(FGeneratedSocials, 0);
SetLength(FGeneratedAges, 0);
Result := TArray<Double>.Create();
var Index: Integer;
for Index := 1 to ACount do
begin
var RunResult := PerformSingleInsert(Index);
if RunResult <> -1.0 then
Result := Result + [RunResult];
end;
end;
end.

78
__history/Main.dpr.~10~ Normal file
View File

@@ -0,0 +1,78 @@
program Main;
{$APPTYPE CONSOLE}
{$R *.res}
uses
System.SysUtils,
System.Math,
ZConnection,
ZDataset,
DatabaseTestExecutor in 'DatabaseTestExecutor.pas',
DataGenerator in 'DataGenerator.pas';
var
LConnection: TZConnection;
begin
LConnection := TZConnection.Create(nil);
LConnection.LibraryLocation := ExtractFilePath(ParamStr(0)) + 'libpq.dll';
try
LConnection.Protocol := 'postgresql';
LConnection.HostName := 'localhost';
LConnection.Port := 5433;
LConnection.Database := 'test_db';
LConnection.User := 'postgres';
LConnection.Password := 'postgres';
Writeln('Connecting to PostgreSQL...');
LConnection.Connect;
Writeln('Connected successfully!');
Writeln('-------------------------');
var DatabaseManager: TDatabaseManager;
DatabaseManager := TDatabaseManager.Create(LConnection, 1234);
var SetupSuccess: Boolean;
SetupSuccess := DatabaseManager.SetupDatabase();
if SetupSuccess then
begin
Writeln('Done setting up database!');
end
else
begin
Writeln('Failed to setup database connection!');
end;
var LNumActions: Integer;
LNumActions := 10000;
var LInsertTimes: TArray<Double>;
LInsertTimes := DatabaseManager.TestInserts(LNumActions);
var LMeanInsertTime: Double;
LMeanInsertTime := Mean(LInsertTimes);
if Length(LInsertTimes) <> LNumActions then
begin
WriteLn('All inserts did not complete, got=' + Length(LInsertTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' inserts completed, average time =' + LMeanInsertTime.ToString + 'ms');
end;
finally
FreeAndNil(LConnection);
end;
Writeln('-------------------------');
Writeln('Press Enter to exit...');
Readln;
end.

88
__history/Main.dpr.~11~ Normal file
View File

@@ -0,0 +1,88 @@
program Main;
{$APPTYPE CONSOLE}
{$R *.res}
uses
System.SysUtils,
System.Math,
ZConnection,
ZDataset,
DatabaseTestExecutor in 'DatabaseTestExecutor.pas',
DataGenerator in 'DataGenerator.pas';
var
LConnection: TZConnection;
begin
LConnection := TZConnection.Create(nil);
LConnection.LibraryLocation := ExtractFilePath(ParamStr(0)) + 'libpq.dll';
try
LConnection.Protocol := 'postgresql';
LConnection.HostName := 'localhost';
LConnection.Port := 5433;
LConnection.Database := 'test_db';
LConnection.User := 'postgres';
LConnection.Password := 'postgres';
Writeln('Connecting to PostgreSQL...');
LConnection.Connect;
Writeln('Connected successfully!');
Writeln('-------------------------');
var DatabaseManager: TDatabaseManager;
DatabaseManager := TDatabaseManager.Create(LConnection, 1234);
var SetupSuccess: Boolean;
SetupSuccess := DatabaseManager.SetupDatabase();
if SetupSuccess then
begin
Writeln('Done setting up database!');
end
else
begin
Writeln('Failed to setup database connection!');
end;
Writeln('-------------------------');
var LNumActions: Integer;
LNumActions := 10000;
WriteLn('Testing Database Inserts');
var LInsertTimes: TArray<Double>;
LInsertTimes := DatabaseManager.TestInserts(LNumActions);
var LMeanInsertTime: Double;
LMeanInsertTime := Mean(LInsertTimes);
if Length(LInsertTimes) <> LNumActions then
begin
WriteLn('All inserts did not complete, got=' + Length(LInsertTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' inserts completed, average time =' + LMeanInsertTime.ToString + 'ms');
end;
Writeln('-------------------------');
WriteLn('Testing reading back each record by primary key');
var LReadTimes: TArray<Double>;
LReadTimes := TArray<Double>.Create();
LReadTimes := DatabaseManager.TestReads(LNumActions);
finally
FreeAndNil(LConnection);
end;
Writeln('-------------------------');
Writeln('Press Enter to exit...');
Readln;
end.

98
__history/Main.dpr.~12~ Normal file
View File

@@ -0,0 +1,98 @@
program Main;
{$APPTYPE CONSOLE}
{$R *.res}
uses
System.SysUtils,
System.Math,
ZConnection,
ZDataset,
DatabaseTestExecutor in 'DatabaseTestExecutor.pas',
DataGenerator in 'DataGenerator.pas';
var
LConnection: TZConnection;
begin
LConnection := TZConnection.Create(nil);
LConnection.LibraryLocation := ExtractFilePath(ParamStr(0)) + 'libpq.dll';
try
LConnection.Protocol := 'postgresql';
LConnection.HostName := 'localhost';
LConnection.Port := 5433;
LConnection.Database := 'test_db';
LConnection.User := 'postgres';
LConnection.Password := 'postgres';
Writeln('Connecting to PostgreSQL...');
LConnection.Connect;
Writeln('Connected successfully!');
Writeln('-------------------------');
var DatabaseManager: TDatabaseManager;
DatabaseManager := TDatabaseManager.Create(LConnection, 1234);
var SetupSuccess: Boolean;
SetupSuccess := DatabaseManager.SetupDatabase();
if SetupSuccess then
begin
Writeln('Done setting up database!');
end
else
begin
Writeln('Failed to setup database connection!');
end;
Writeln('-------------------------');
var LNumActions: Integer;
LNumActions := 10000;
WriteLn('Testing Database Inserts');
var LInsertTimes: TArray<Double>;
LInsertTimes := DatabaseManager.TestInserts(LNumActions);
var LMeanInsertTime: Double;
LMeanInsertTime := Mean(LInsertTimes);
if Length(LInsertTimes) <> LNumActions then
begin
WriteLn('All inserts did not complete, got=' + Length(LInsertTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' inserts completed, average time ' + LMeanInsertTime.ToString + 'ms');
end;
Writeln('-------------------------');
WriteLn('Testing reading back each record by primary key');
var LReadTimes: TArray<Double>;
LReadTimes := TArray<Double>.Create();
LReadTimes := DatabaseManager.TestReads(LNumActions);
var LMeanReadTime: Double;
LMeanReadTime := Mean(LInsertTimes);
if Length(LInsertTimes) <> LNumActions then
begin
WriteLn('All inserts did not complete, got=' + Length(LReadTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' reads completed, average time ' + LMeanReadTime.ToString + 'ms');
end;
finally
FreeAndNil(LConnection);
end;
Writeln('-------------------------');
Writeln('Press Enter to exit...');
Readln;
end.

98
__history/Main.dpr.~13~ Normal file
View File

@@ -0,0 +1,98 @@
program Main;
{$APPTYPE CONSOLE}
{$R *.res}
uses
System.SysUtils,
System.Math,
ZConnection,
ZDataset,
DatabaseTestExecutor in 'DatabaseTestExecutor.pas',
DataGenerator in 'DataGenerator.pas';
var
LConnection: TZConnection;
begin
LConnection := TZConnection.Create(nil);
LConnection.LibraryLocation := ExtractFilePath(ParamStr(0)) + 'libpq.dll';
try
LConnection.Protocol := 'postgresql';
LConnection.HostName := 'localhost';
LConnection.Port := 5433;
LConnection.Database := 'test_db';
LConnection.User := 'postgres';
LConnection.Password := 'postgres';
Writeln('Connecting to PostgreSQL...');
LConnection.Connect;
Writeln('Connected successfully!');
Writeln('-------------------------');
var DatabaseManager: TDatabaseManager;
DatabaseManager := TDatabaseManager.Create(LConnection, 1234);
var SetupSuccess: Boolean;
SetupSuccess := DatabaseManager.SetupDatabase();
if SetupSuccess then
begin
Writeln('Done setting up database!');
end
else
begin
Writeln('Failed to setup database connection!');
end;
Writeln('-------------------------');
var LNumActions: Integer;
LNumActions := 10000;
WriteLn('Testing Database Inserts');
var LInsertTimes: TArray<Double>;
LInsertTimes := DatabaseManager.TestInserts(LNumActions);
var LMeanInsertTime: Double;
LMeanInsertTime := Mean(LInsertTimes);
if Length(LInsertTimes) <> LNumActions then
begin
WriteLn('All inserts did not complete, got=' + Length(LInsertTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' inserts completed, average time ' + LMeanInsertTime.ToString + 'ms');
end;
Writeln('-------------------------');
WriteLn('Testing reading back each record by primary key');
var LReadTimes: TArray<Double>;
LReadTimes := TArray<Double>.Create();
LReadTimes := DatabaseManager.TestReads(LNumActions);
var LMeanReadTime: Double;
LMeanReadTime := Mean(LInsertTimes);
if Length(LReadTimes) <> LNumActions then
begin
WriteLn('All inserts did not complete, got=' + Length(LReadTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' reads completed, average time ' + LMeanReadTime.ToString + 'ms');
end;
finally
FreeAndNil(LConnection);
end;
Writeln('-------------------------');
Writeln('Press Enter to exit...');
Readln;
end.

98
__history/Main.dpr.~14~ Normal file
View File

@@ -0,0 +1,98 @@
program Main;
{$APPTYPE CONSOLE}
{$R *.res}
uses
System.SysUtils,
System.Math,
ZConnection,
ZDataset,
DatabaseTestExecutor in 'DatabaseTestExecutor.pas',
DataGenerator in 'DataGenerator.pas';
var
LConnection: TZConnection;
begin
LConnection := TZConnection.Create(nil);
LConnection.LibraryLocation := ExtractFilePath(ParamStr(0)) + 'libpq.dll';
try
LConnection.Protocol := 'postgresql';
LConnection.HostName := 'localhost';
LConnection.Port := 5433;
LConnection.Database := 'test_db';
LConnection.User := 'postgres';
LConnection.Password := 'postgres';
Writeln('Connecting to PostgreSQL...');
LConnection.Connect;
Writeln('Connected successfully!');
Writeln('-------------------------');
var DatabaseManager: TDatabaseManager;
DatabaseManager := TDatabaseManager.Create(LConnection, 1234);
var SetupSuccess: Boolean;
SetupSuccess := DatabaseManager.SetupDatabase();
if SetupSuccess then
begin
Writeln('Done setting up database!');
end
else
begin
Writeln('Failed to setup database connection!');
end;
Writeln('-------------------------');
var LNumActions: Integer;
LNumActions := 10000;
WriteLn('Testing Database Inserts');
var LInsertTimes: TArray<Double>;
LInsertTimes := DatabaseManager.TestInserts(LNumActions);
var LMeanInsertTime: Double;
LMeanInsertTime := Mean(LInsertTimes);
if Length(LInsertTimes) <> LNumActions then
begin
WriteLn('All inserts did not complete, got=' + Length(LInsertTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' inserts completed, average time ' + LMeanInsertTime.ToString + 'ms');
end;
Writeln('-------------------------');
WriteLn('Testing reading back each record by primary key');
var LReadTimes: TArray<Double>;
LReadTimes := TArray<Double>.Create();
LReadTimes := DatabaseManager.TestReads(LNumActions);
var LMeanReadTime: Double;
LMeanReadTime := Mean(LReadTimes);
if Length(LReadTimes) <> LNumActions then
begin
WriteLn('All inserts did not complete, got=' + Length(LReadTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' reads completed, average time ' + LMeanReadTime.ToString + 'ms');
end;
finally
FreeAndNil(LConnection);
end;
Writeln('-------------------------');
Writeln('Press Enter to exit...');
Readln;
end.

137
__history/Main.dpr.~15~ Normal file
View File

@@ -0,0 +1,137 @@
program Main;
{$APPTYPE CONSOLE}
{$R *.res}
uses
System.SysUtils,
System.Math,
ZConnection,
ZDataset,
DatabaseTestExecutor in 'DatabaseTestExecutor.pas',
DataGenerator in 'DataGenerator.pas';
var
LConnection: TZConnection;
begin
LConnection := TZConnection.Create(nil);
LConnection.LibraryLocation := ExtractFilePath(ParamStr(0)) + 'libpq.dll';
try
LConnection.Protocol := 'postgresql';
LConnection.HostName := 'localhost';
LConnection.Port := 5433;
LConnection.Database := 'test_db';
LConnection.User := 'postgres';
LConnection.Password := 'postgres';
Writeln('Connecting to PostgreSQL...');
LConnection.Connect;
Writeln('Connected successfully!');
Writeln('-------------------------');
var DatabaseManager: TDatabaseManager;
DatabaseManager := TDatabaseManager.Create(LConnection, 1234);
try
var SetupSuccess: Boolean;
SetupSuccess := DatabaseManager.SetupDatabase();
if SetupSuccess then
begin
Writeln('Done setting up database!');
end
else
begin
Writeln('Failed to setup database connection!');
end;
Writeln('-------------------------');
var LNumActions: Integer;
LNumActions := 10000;
WriteLn('Testing Database Inserts');
var LInsertTimes: TArray<Double>;
LInsertTimes := DatabaseManager.TestInserts(LNumActions);
var LMeanInsertTime: Double;
LMeanInsertTime := Mean(LInsertTimes);
if Length(LInsertTimes) <> LNumActions then
begin
WriteLn('All inserts did not complete, got=' + Length(LInsertTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' inserts completed, average time ' + LMeanInsertTime.ToString + 'ms');
end;
Writeln('-------------------------');
WriteLn('Testing reading back each record by primary key');
var LReadTimes: TArray<Double>;
LReadTimes := TArray<Double>.Create();
LReadTimes := DatabaseManager.TestReads(LNumActions);
var LMeanReadTime: Double;
LMeanReadTime := Mean(LReadTimes);
if Length(LReadTimes) <> LNumActions then
begin
WriteLn('All reads did not complete, got=' + Length(LReadTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' reads completed, average time ' + LMeanReadTime.ToString + 'ms');
end;
Writeln('-------------------------');
WriteLn('Testing reading back each record by email');
var LReadByEmailTimes: TArray<Double>;
LReadByEmailTimes := DatabaseManager.TestReadsByEmail();
var LMeanReadByEmailTime: Double;
LMeanReadByEmailTime := Mean(LReadByEmailTimes);
if Length(LReadByEmailTimes) <> LNumActions then
begin
WriteLn('All reads by email did not complete, got=' + Length(LReadByEmailTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' reads by email completed, average time ' + LMeanReadByEmailTime.ToString + 'ms');
end;
Writeln('-------------------------');
WriteLn('Testing reading back each record by social security number');
var LReadBySocialTimes: TArray<Double>;
LReadBySocialTimes := DatabaseManager.TestReadsBySocial();
var LMeanReadBySocialTime: Double;
LMeanReadBySocialTime := Mean(LReadBySocialTimes);
if Length(LReadBySocialTimes) <> LNumActions then
begin
WriteLn('All reads by social did not complete, got=' + Length(LReadBySocialTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' reads by social completed, average time ' + LMeanReadBySocialTime.ToString + 'ms');
end;
finally
DatabaseManager.Free;
end;
finally
FreeAndNil(LConnection);
end;
Writeln('-------------------------');
Writeln('Press Enter to exit...');
Readln;
end.

153
__history/Main.dpr.~16~ Normal file
View File

@@ -0,0 +1,153 @@
program Main;
{$APPTYPE CONSOLE}
{$R *.res}
uses
System.SysUtils,
System.Math,
ZConnection,
ZDataset,
DatabaseTestExecutor in 'DatabaseTestExecutor.pas',
DataGenerator in 'DataGenerator.pas';
function GetStringArg(const ASwitch, ADefault: string): string;
begin
if not FindCmdLineSwitch(ASwitch, Result, True) then
Result := ADefault;
end;
function GetIntArg(const ASwitch: string; ADefault: Integer): Integer;
begin
var LStrValue: string;
if FindCmdLineSwitch(ASwitch, LStrValue, True) then
Result := StrToIntDef(LStrValue, ADefault)
else
Result := ADefault;
end;
var
LConnection: TZConnection;
begin
LConnection := TZConnection.Create(nil);
LConnection.LibraryLocation := ExtractFilePath(ParamStr(0)) + 'libpq.dll';
try
LConnection.Protocol := 'postgresql';
LConnection.HostName := 'localhost';
LConnection.Port := 5433;
LConnection.Database := 'test_db';
LConnection.User := 'postgres';
LConnection.Password := 'postgres';
Writeln('Connecting to PostgreSQL...');
LConnection.Connect;
Writeln('Connected successfully!');
Writeln('-------------------------');
var DatabaseManager: TDatabaseManager;
DatabaseManager := TDatabaseManager.Create(LConnection, 1234);
try
var SetupSuccess: Boolean;
SetupSuccess := DatabaseManager.SetupDatabase();
if SetupSuccess then
begin
Writeln('Done setting up database!');
end
else
begin
Writeln('Failed to setup database connection!');
end;
Writeln('-------------------------');
var LNumActions: Integer;
LNumActions := 10000;
WriteLn('Testing Database Inserts');
var LInsertTimes: TArray<Double>;
LInsertTimes := DatabaseManager.TestInserts(LNumActions);
var LMeanInsertTime: Double;
LMeanInsertTime := Mean(LInsertTimes);
if Length(LInsertTimes) <> LNumActions then
begin
WriteLn('All inserts did not complete, got=' + Length(LInsertTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' inserts completed, average time ' + LMeanInsertTime.ToString + 'ms');
end;
Writeln('-------------------------');
WriteLn('Testing reading back each record by primary key');
var LReadTimes: TArray<Double>;
LReadTimes := TArray<Double>.Create();
LReadTimes := DatabaseManager.TestReads(LNumActions);
var LMeanReadTime: Double;
LMeanReadTime := Mean(LReadTimes);
if Length(LReadTimes) <> LNumActions then
begin
WriteLn('All reads did not complete, got=' + Length(LReadTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' reads completed, average time ' + LMeanReadTime.ToString + 'ms');
end;
Writeln('-------------------------');
WriteLn('Testing reading back each record by email');
var LReadByEmailTimes: TArray<Double>;
LReadByEmailTimes := DatabaseManager.TestReadsByEmail();
var LMeanReadByEmailTime: Double;
LMeanReadByEmailTime := Mean(LReadByEmailTimes);
if Length(LReadByEmailTimes) <> LNumActions then
begin
WriteLn('All reads by email did not complete, got=' + Length(LReadByEmailTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' reads by email completed, average time ' + LMeanReadByEmailTime.ToString + 'ms');
end;
Writeln('-------------------------');
WriteLn('Testing reading back each record by social security number');
var LReadBySocialTimes: TArray<Double>;
LReadBySocialTimes := DatabaseManager.TestReadsBySocial();
var LMeanReadBySocialTime: Double;
LMeanReadBySocialTime := Mean(LReadBySocialTimes);
if Length(LReadBySocialTimes) <> LNumActions then
begin
WriteLn('All reads by social did not complete, got=' + Length(LReadBySocialTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' reads by social completed, average time ' + LMeanReadBySocialTime.ToString + 'ms');
end;
finally
DatabaseManager.Free;
end;
finally
FreeAndNil(LConnection);
end;
Writeln('-------------------------');
Writeln('Press Enter to exit...');
Readln;
end.

171
__history/Main.dpr.~17~ Normal file
View File

@@ -0,0 +1,171 @@
program Main;
{$APPTYPE CONSOLE}
{$R *.res}
uses
System.SysUtils,
System.Math,
ZConnection,
ZDataset,
DatabaseTestExecutor in 'DatabaseTestExecutor.pas',
DataGenerator in 'DataGenerator.pas';
function GetStringArg(const ASwitch, ADefault: string): string;
begin
if not FindCmdLineSwitch(ASwitch, Result, True) then
Result := ADefault;
end;
function GetIntArg(const ASwitch: string; ADefault: Integer): Integer;
begin
var LStrValue: string;
if FindCmdLineSwitch(ASwitch, LStrValue, True) then
Result := StrToIntDef(LStrValue, ADefault)
else
Result := ADefault;
end;
var
LConnection: TZConnection;
begin
var LHost: string;
LHost := GetStringArg('host', 'localhost');
var LPort: Integer;
LPort := GetIntArg('port', 5433);
var LDatabase: string;
LDatabase := GetStringArg('db', 'test_db');
var LUser: string;
LUser := GetStringArg('user', 'postgres');
var LPassword: string;
LPassword := GetStringArg('pass', 'postgres');
var LSeed: Integer;
LSeed := GetIntArg('seed', 1234);
var LNumActions: Integer;
LNumActions := GetIntArg('ops', 10000);
LConnection := TZConnection.Create(nil);
LConnection.LibraryLocation := ExtractFilePath(ParamStr(0)) + 'libpq.dll';
try
LConnection.Protocol := 'postgresql';
LConnection.HostName := LHost;
LConnection.Port := LPort;
LConnection.Database := LDatabase;
LConnection.User := LUser;
LConnection.Password := LPassword;
Writeln('Connecting to PostgreSQL...');
LConnection.Connect;
Writeln('Connected successfully!');
Writeln('-------------------------');
var DatabaseManager: TDatabaseManager;
DatabaseManager := TDatabaseManager.Create(LConnection, LSeed);
try
var SetupSuccess: Boolean;
SetupSuccess := DatabaseManager.SetupDatabase();
if SetupSuccess then
begin
Writeln('Done setting up database!');
end
else
begin
Writeln('Failed to setup database connection!');
end;
Writeln('-------------------------');
WriteLn('Testing Database Inserts');
var LInsertTimes: TArray<Double>;
LInsertTimes := DatabaseManager.TestInserts(LNumActions);
var LMeanInsertTime: Double;
LMeanInsertTime := Mean(LInsertTimes);
if Length(LInsertTimes) <> LNumActions then
begin
WriteLn('All inserts did not complete, got=' + Length(LInsertTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' inserts completed, average time ' + LMeanInsertTime.ToString + 'ms');
end;
Writeln('-------------------------');
WriteLn('Testing reading back each record by primary key');
var LReadTimes: TArray<Double>;
LReadTimes := TArray<Double>.Create();
LReadTimes := DatabaseManager.TestReads(LNumActions);
var LMeanReadTime: Double;
LMeanReadTime := Mean(LReadTimes);
if Length(LReadTimes) <> LNumActions then
begin
WriteLn('All reads did not complete, got=' + Length(LReadTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' reads completed, average time ' + LMeanReadTime.ToString + 'ms');
end;
Writeln('-------------------------');
WriteLn('Testing reading back each record by email');
var LReadByEmailTimes: TArray<Double>;
LReadByEmailTimes := DatabaseManager.TestReadsByEmail();
var LMeanReadByEmailTime: Double;
LMeanReadByEmailTime := Mean(LReadByEmailTimes);
if Length(LReadByEmailTimes) <> LNumActions then
begin
WriteLn('All reads by email did not complete, got=' + Length(LReadByEmailTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' reads by email completed, average time ' + LMeanReadByEmailTime.ToString + 'ms');
end;
Writeln('-------------------------');
WriteLn('Testing reading back each record by social security number');
var LReadBySocialTimes: TArray<Double>;
LReadBySocialTimes := DatabaseManager.TestReadsBySocial();
var LMeanReadBySocialTime: Double;
LMeanReadBySocialTime := Mean(LReadBySocialTimes);
if Length(LReadBySocialTimes) <> LNumActions then
begin
WriteLn('All reads by social did not complete, got=' + Length(LReadBySocialTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' reads by social completed, average time ' + LMeanReadBySocialTime.ToString + 'ms');
end;
finally
DatabaseManager.Free;
end;
finally
FreeAndNil(LConnection);
end;
Writeln('-------------------------');
Writeln('Press Enter to exit...');
Readln;
end.

206
__history/Main.dpr.~18~ Normal file
View File

@@ -0,0 +1,206 @@
program Main;
{$APPTYPE CONSOLE}
{$R *.res}
uses
System.SysUtils,
System.Math,
System.Classes,
ZConnection,
ZDataset,
DatabaseTestExecutor in 'DatabaseTestExecutor.pas',
DataGenerator in 'DataGenerator.pas';
function GetStringArg(const ASwitch, ADefault: string): string;
begin
if not FindCmdLineSwitch(ASwitch, Result, True) then
Result := ADefault;
end;
function GetIntArg(const ASwitch: string; ADefault: Integer): Integer;
begin
var LStrValue: string;
if FindCmdLineSwitch(ASwitch, LStrValue, True) then
Result := StrToIntDef(LStrValue, ADefault)
else
Result := ADefault;
end;
procedure WriteResultsToCSV(const AFileName, AActionType: string; const ATimes: TArray<Double>);
begin
var LFileExists: Boolean;
LFileExists := FileExists(AFileName);
var LWriter: TStreamWriter;
LWriter := TStreamWriter.Create(AFileName, True); // True enables Append mode
try
if not LFileExists then
LWriter.WriteLine('actiontype,value');
var LTime: Double;
for LTime in ATimes do
begin
LWriter.WriteLine(AActionType + ',' + FloatToStr(LTime));
end;
finally
LWriter.Free;
end;
end;
var
LConnection: TZConnection;
begin
var LHost: string;
LHost := GetStringArg('host', 'localhost');
var LPort: Integer;
LPort := GetIntArg('port', 5433);
var LDatabase: string;
LDatabase := GetStringArg('db', 'test_db');
var LUser: string;
LUser := GetStringArg('user', 'postgres');
var LPassword: string;
LPassword := GetStringArg('pass', 'postgres');
var LSeed: Integer;
LSeed := GetIntArg('seed', 1234);
var LNumActions: Integer;
LNumActions := GetIntArg('ops', 10000);
var LOutputFileName: string;
LOutputFileName := GetStringArg('out', '');
if LOutputFileName = '' then
begin
LOutputFileName := Format('test_results_%s.csv', [FormatDateTime('yyyymmdd_hhnnss_zzz', Now)]);
end;
Writeln('Test results will be saved to: ', LOutputFileName);
Writeln('-------------------------');
LConnection := TZConnection.Create(nil);
LConnection.LibraryLocation := ExtractFilePath(ParamStr(0)) + 'libpq.dll';
try
LConnection.Protocol := 'postgresql';
LConnection.HostName := LHost;
LConnection.Port := LPort;
LConnection.Database := LDatabase;
LConnection.User := LUser;
LConnection.Password := LPassword;
Writeln('Connecting to PostgreSQL...');
LConnection.Connect;
Writeln('Connected successfully!');
Writeln('-------------------------');
var DatabaseManager: TDatabaseManager;
DatabaseManager := TDatabaseManager.Create(LConnection, LSeed);
try
var SetupSuccess: Boolean;
SetupSuccess := DatabaseManager.SetupDatabase();
if SetupSuccess then
begin
Writeln('Done setting up database!');
end
else
begin
Writeln('Failed to setup database connection!');
end;
Writeln('-------------------------');
WriteLn('Testing Database Inserts');
var LInsertTimes: TArray<Double>;
LInsertTimes := DatabaseManager.TestInserts(LNumActions);
WriteResultsToCSV(LOutputFileName, 'insert', LInsertTimes);
var LMeanInsertTime: Double;
LMeanInsertTime := Mean(LInsertTimes);
if Length(LInsertTimes) <> LNumActions then
begin
WriteLn('All inserts did not complete, got=' + Length(LInsertTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' inserts completed, average time ' + LMeanInsertTime.ToString + 'ms');
end;
Writeln('-------------------------');
WriteLn('Testing reading back each record by primary key');
var LReadTimes: TArray<Double>;
LReadTimes := TArray<Double>.Create();
LReadTimes := DatabaseManager.TestReads(LNumActions);
WriteResultsToCSV(LOutputFileName, 'read_pk', LReadTimes);
var LMeanReadTime: Double;
LMeanReadTime := Mean(LReadTimes);
if Length(LReadTimes) <> LNumActions then
begin
WriteLn('All reads did not complete, got=' + Length(LReadTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' reads completed, average time ' + LMeanReadTime.ToString + 'ms');
end;
Writeln('-------------------------');
WriteLn('Testing reading back each record by email');
var LReadByEmailTimes: TArray<Double>;
LReadByEmailTimes := DatabaseManager.TestReadsByEmail();
WriteResultsToCSV(LOutputFileName, 'read_email', LReadByEmailTimes);
var LMeanReadByEmailTime: Double;
LMeanReadByEmailTime := Mean(LReadByEmailTimes);
if Length(LReadByEmailTimes) <> LNumActions then
begin
WriteLn('All reads by email did not complete, got=' + Length(LReadByEmailTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' reads by email completed, average time ' + LMeanReadByEmailTime.ToString + 'ms');
end;
Writeln('-------------------------');
WriteLn('Testing reading back each record by social security number');
var LReadBySocialTimes: TArray<Double>;
LReadBySocialTimes := DatabaseManager.TestReadsBySocial();
WriteResultsToCSV(LOutputFileName, 'read_social', LReadBySocialTimes);
var LMeanReadBySocialTime: Double;
LMeanReadBySocialTime := Mean(LReadBySocialTimes);
if Length(LReadBySocialTimes) <> LNumActions then
begin
WriteLn('All reads by social did not complete, got=' + Length(LReadBySocialTimes).ToString + ' expected=' + LNumActions.ToString);
end
else
begin
WriteLn(LNumActions.ToString + ' reads by social completed, average time ' + LMeanReadBySocialTime.ToString + 'ms');
end;
finally
DatabaseManager.Free;
end;
finally
FreeAndNil(LConnection);
end;
Writeln('-------------------------');
Writeln('Press Enter to exit...');
Readln;
end.

58
__history/Main.dpr.~9~ Normal file
View File

@@ -0,0 +1,58 @@
program Main;
{$APPTYPE CONSOLE}
{$R *.res}
uses
System.SysUtils,
ZConnection,
ZDataset,
DatabaseTestExecutor in 'DatabaseTestExecutor.pas',
DataGenerator in 'DataGenerator.pas';
var
Connection: TZConnection;
Query: TZQuery;
begin
Connection := TZConnection.Create(nil);
Connection.LibraryLocation := ExtractFilePath(ParamStr(0)) + 'libpq.dll';
try
Connection.Protocol := 'postgresql';
Connection.HostName := 'localhost';
Connection.Port := 5433;
Connection.Database := 'test_db';
Connection.User := 'postgres';
Connection.Password := 'postgres';
Writeln('Connecting to PostgreSQL...');
Connection.Connect;
Writeln('Connected successfully!');
Writeln('-------------------------');
var DatabaseManager: TDatabaseManager;
DatabaseManager := TDatabaseManager.Create(Connection, 1234);
var SetupSuccess: Boolean;
SetupSuccess := DatabaseManager.SetupDatabase();
if SetupSuccess then
begin
Writeln('Done!');
end
else
begin
Writeln('Failed to setup database connection!');
end;
finally
end;
Writeln('-------------------------');
Writeln('Press Enter to exit...');
Readln;
end.

58
__history/TestDatabaseManager.pas.~1~ Normal file
View File

@@ -0,0 +1,58 @@
unit TestDatabaseManager;
interface
uses
ZConnection,
ZDataset,
ZExceptions;
type
TDatabaseManager = class
private
FConnection: TZConnection;
public
constructor Create(connection:TZConnection);
function SetupDatabase: Boolean;
end;
implementation
constructor TDatabaseManager.Create(connection:TZConnection);
begin
FConnection := connection;
end;
function TDatabaseManager.SetupDatabase: Boolean;
begin
var Query: TZQuery;
Query := TZQuery.Create(nil);
Query.Sql.Add('DROP TABLE IF EXISTS users');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Query.SQL.Clear;
Query.SQL.Add('CREATE TABLE users IF NOT EXISTS (id INT PRIMARY KEY, first_name VARCHAR(255), last_name VARCHAR(255), social_security_number VARCHAR(255), age INT);');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Result := True;
end;
end.

58
__history/TestDatabaseManager.pas.~2~ Normal file
View File

@@ -0,0 +1,58 @@
unit TestDatabaseManager;
interface
uses
ZConnection,
ZDataset,
ZExceptions;
type
TDatabaseManager = class
private
FConnection: TZConnection;
public
constructor Create(connection:TZConnection);
function SetupDatabase: Boolean;
end;
implementation
constructor TDatabaseManager.Create(connection:TZConnection);
begin
FConnection := connection;
end;
function TDatabaseManager.SetupDatabase: Boolean;
begin
var Query: TZQuery;
Query := TZQuery.Create(nil);
Query.Sql.Add('DROP TABLE IF EXISTS users');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Query.SQL.Clear;
Query.SQL.Add('CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, first_name VARCHAR(255), last_name VARCHAR(255), social_security_number VARCHAR(255), age INT);');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Result := True;
end;
end.

59
__history/TestDatabaseManager.pas.~3~ Normal file
View File

@@ -0,0 +1,59 @@
unit TestDatabaseManager;
interface
uses
ZConnection,
ZDataset,
ZExceptions;
type
TDatabaseManager = class
private
FConnection: TZConnection;
public
constructor Create(connection:TZConnection);
function SetupDatabase: Boolean;
end;
implementation
constructor TDatabaseManager.Create(connection:TZConnection);
begin
FConnection := connection;
end;
function TDatabaseManager.SetupDatabase: Boolean;
begin
var Query: TZQuery;
Query := TZQuery.Create(nil);
Query.Connection := FConnection;
Query.Sql.Add('DROP TABLE IF EXISTS users');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Query.SQL.Clear;
Query.SQL.Add('CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, first_name VARCHAR(255), last_name VARCHAR(255), social_security_number VARCHAR(255), age INT);');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Result := True;
end;
end.

60
__history/TestDatabaseManager.pas.~4~ Normal file
View File

@@ -0,0 +1,60 @@
unit TestDatabaseManager;
interface
uses
System.SysUtils,
ZConnection,
ZDataset,
ZExceptions;
type
TDatabaseManager = class
private
FConnection: TZConnection;
public
constructor Create(connection:TZConnection);
function SetupDatabase: Boolean;
end;
implementation
constructor TDatabaseManager.Create(connection:TZConnection);
begin
FConnection := connection;
end;
function TDatabaseManager.SetupDatabase: Boolean;
begin
var Query: TZQuery;
Query := TZQuery.Create(nil);
Query.Connection := FConnection;
Query.Sql.Add('DROP TABLE IF EXISTS users');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Query.SQL.Clear;
Query.SQL.Add('CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, first_name VARCHAR(255), last_name VARCHAR(255), social_security_number VARCHAR(255), age INT);');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Result := True;
end;
end.

64
__history/TestDatabaseManager.pas.~5~ Normal file
View File

@@ -0,0 +1,64 @@
unit TestDatabaseManager;
interface
uses
System.SysUtils,
ZConnection,
ZDataset,
ZExceptions;
type
TDatabaseManager = class
private
FConnection: TZConnection;
public
constructor Create(connection:TZConnection);
function SetupDatabase: Boolean;
end;
implementation
constructor TDatabaseManager.Create(connection:TZConnection);
begin
FConnection := connection;
end;
function TDatabaseManager.SetupDatabase: Boolean;
begin
var Query: TZQuery;
Query := TZQuery.Create(nil);
Query.Connection := FConnection;
Query.Sql.Add('DROP TABLE IF EXISTS users');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Query.SQL.Clear;
Query.SQL.Add('CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, first_name VARCHAR(255), last_name VARCHAR(255), social_security_number VARCHAR(255), age INT);');
try
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end
end;
finally
FreeAndNil(Query);
end;
Result := True;
end;
end.

64
__history/TestDatabaseManager.pas.~6~ Normal file
View File

@@ -0,0 +1,64 @@
unit TestDatabaseManager;
interface
uses
System.SysUtils,
ZConnection,
ZDataset,
ZExceptions;
type
TDatabaseManager = class
private
FConnection: TZConnection;
public
constructor Create(connection:TZConnection);
function SetupDatabase: Boolean;
end;
implementation
constructor TDatabaseManager.Create(connection:TZConnection);
begin
FConnection := connection;
end;
function TDatabaseManager.SetupDatabase: Boolean;
begin
var Query: TZQuery;
Query := TZQuery.Create(nil);
Query.Connection := FConnection;
Query.Sql.Add('DROP TABLE IF EXISTS users');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Query.SQL.Clear;
Query.SQL.Add('CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, email VARCHAR(255), social_security_number VARCHAR(255), age INT);');
try
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end
end;
finally
FreeAndNil(Query);
end;
Result := True;
end;
end.

62
__history/TestDatabaseManager.pas.~7~ Normal file
View File

@@ -0,0 +1,62 @@
unit TestDatabaseManager;
interface
uses
System.SysUtils,
ZConnection,
ZDataset,
ZExceptions;
type
TDatabaseManager = class
private
FConnection: TZConnection;
public
constructor Create(connection:TZConnection);
function SetupDatabase: Boolean;
end;
implementation
constructor TDatabaseManager.Create(connection:TZConnection);
begin
FConnection := connection;
end;
function TDatabaseManager.SetupDatabase: Boolean;
begin
var Query: TZQuery;
Query := TZQuery.Create(nil);
Query.Connection := FConnection;
Query.Sql.Add('DROP TABLE IF EXISTS users');
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end;
end;
Query.SQL.Clear;
Query.SQL.Add('CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, email VARCHAR(255), social_security_number VARCHAR(255), age INT);');
try
try
Query.ExecSQL;
except
on E: EZSQLException do
begin
Exit(False);
end
end;
finally
FreeAndNil(Query);
end;
Result := True;
end;
end.