diff --git a/.gitignore b/.gitignore index 88b6cbd..3fc13fa 100644 --- a/.gitignore +++ b/.gitignore @@ -152,3 +152,4 @@ backup/ heap.trc log.txt MiniRESTSQLTest.xml +/unittest/SQL/logPool.txt diff --git a/Gruntfile.js b/Gruntfile.js index 6177fcb..ed70ba4 100644 --- a/Gruntfile.js +++ b/Gruntfile.js @@ -59,7 +59,7 @@ module.exports = function(grunt) { tasks: ['bgShell:sql'] }, sql_fpc: { - files: ['**/*.pas'], + files: ['*.pas', 'unittest/SQL/*.pas'], tasks: ['bgShell:sql_fpc'] }, orm: { @@ -74,5 +74,5 @@ module.exports = function(grunt) { grunt.loadNpmTasks('grunt-contrib-watch'); grunt.registerTask('default', ['watch:server']); - + grunt.registerTask('test_sql_fpc', ['bgShell:sql_fpc']); }; \ No newline at end of file diff --git a/MiniREST.SQL.Base.pas b/MiniREST.SQL.Base.pas index 8bb543f..5350776 100644 --- a/MiniREST.SQL.Base.pas +++ b/MiniREST.SQL.Base.pas @@ -18,6 +18,7 @@ TMiniRESTSQLConnectionFactoryBase = class abstract(TInterfacedObject, IMiniRES strict private FConnectionsToNotifyFree: TList; protected + FConnectionFactoryEventLogger: IMiniRESTSQLConnectionFactoryEventLogger; {$IFNDEF FPC} FSemaphore: TLightweightSemaphore; FQueue: TQueue; @@ -35,18 +36,24 @@ TMiniRESTSQLConnectionFactoryBase = class abstract(TInterfacedObject, IMiniRES procedure RemoveConnectionToNotifyFree(AConnection: IMiniRESTSQLConnection); procedure ReleaseConnection(AConnection: IMiniRESTSQLConnection); virtual; function InternalGetconnection: IMiniRESTSQLConnection; virtual; abstract; + procedure LogConnectionPoolEvent(const AMessage: string); public - constructor Create(const AConnectionCount: Integer); + constructor Create(const AConnectionCount: Integer); overload; + constructor Create(AParams: IMiniRESTSQLConnectionFactoryParams); overload; destructor Destroy; override; - function GetConnection: IMiniRESTSQLConnection; + function GetConnection: IMiniRESTSQLConnection; overload; function GetObject: TObject; + function GetConnectionsCount: Integer; virtual; abstract; + function GetQueueCount: Integer; virtual; abstract; + function GetConnection(const AIdentifier: string): IMiniRESTSQLConnection; overload; end; { TMiniRESTSQLConnectionBase } TMiniRESTSQLConnectionBase = class abstract(TInterfacedObject, IMiniRESTSQLConnection) strict private - FOwner : TObject; + FOwner: TObject; + FConnectionID: Integer; protected FName: string; FEstaNoPool: Boolean; @@ -54,7 +61,8 @@ TMiniRESTSQLConnectionBase = class abstract(TInterfacedObject, IMiniRESTSQLCon function GetObject: TObject; virtual; abstract; procedure SetOwner(AOwner: Pointer); public - constructor Create(AOwner : IMiniRESTSQLConnectionFactory); + constructor Create(AOwner: IMiniRESTSQLConnectionFactory); overload; + constructor Create(AParams: IMiniRESTSQLConnectionParams); overload; procedure StartTransaction; virtual; abstract; procedure Commit; virtual; abstract; procedure Rollback; virtual; abstract; @@ -67,6 +75,7 @@ TMiniRESTSQLConnectionBase = class abstract(TInterfacedObject, IMiniRESTSQLCon function Execute(const ACommand: string; AParams: array of IMiniRESTSQLParam): Integer; virtual; abstract; function GetDatabaseInfo: IMiniRESTSQLDatabaseInfo; virtual; abstract; function InTransaction: Boolean; virtual; abstract; + function GetConnectionID: Integer; end; TMiniRESTSQLPrimaryKeyInfo = class(TInterfacedObject, IMiniRESTSQLPrimaryKeyInfo) @@ -105,26 +114,44 @@ TMiniRESTSQLColumnInfo = class(TInterfacedObject, IMiniRESTSQLColumnInfo) function GetName: string; end; + TMiniRESTSQLConnectionParams = class(TInterfacedObject, IMiniRESTSQLConnectionParams) + private + FConnectionFactory: IMiniRESTSQLConnectionFactory; + FConnectionID: Integer; + public + //class function New: IMiniRESTSQLConnectionParams; + function GetConnectionFactory: IMiniRESTSQLConnectionFactory; + procedure SetConnectionFactory(AConnectionFactory: IMiniRESTSQLConnectionFactory); + function GetConnectionID: Integer; + procedure SetConnectionID(const AID: Integer); + end; + + TMiniRESTSQLConnectionFactoryParams = class(TInterfacedObject, IMiniRESTSQLConnectionFactoryParams) + private + FConnectionCount: Integer; + FConnectionFactoryEventLogger: IMiniRESTSQLConnectionFactoryEventLogger; + public + function GetConnectionsCount: Integer; + procedure SetConnectionsCount(const ACount: Integer); + function GetObject: TObject; + function GetConnectionFactoryEventLogger: IMiniRESTSQLConnectionFactoryEventLogger; + procedure SetConnectionFactoryEventLogger(ALogger: IMiniRESTSQLConnectionFactoryEventLogger); + end; + implementation +var + gConnectionIDCounter: Integer; + { TMiniRESTSQLConnectionFactoryBase } constructor TMiniRESTSQLConnectionFactoryBase.Create(const AConnectionCount: Integer); +var + LParams: IMiniRESTSQLConnectionFactoryParams; begin - FConnectionsCount := AConnectionCount; - {$IFNDEF FPC} - FSemaphore := TLightweightSemaphore.Create(AConnectionCount, AConnectionCount); - FQueue := TQueue.Create; - {$ELSE} - FAvailableConnections := AConnectionCount; - FQueue := TFPGInterfacedObjectList.Create; - FConnectionGetEvent := RTLEventCreate; - FConnectionReleaseEvent := RTLEventCreate; - RTLeventSetEvent(FConnectionGetEvent); - RTLeventSetEvent(FConnectionReleaseEvent); - {$ENDIF} - FCriticalSection := TCriticalSection.Create; - FConnectionsToNotifyFree := TList.Create; + LParams := TMiniRESTSQLConnectionFactoryParams.Create; + LParams.SetConnectionsCount(AConnectionCount); + Create(LParams); end; destructor TMiniRESTSQLConnectionFactoryBase.Destroy; @@ -151,56 +178,8 @@ destructor TMiniRESTSQLConnectionFactoryBase.Destroy; end; function TMiniRESTSQLConnectionFactoryBase.GetConnection: IMiniRESTSQLConnection; -var - LConnection: IMiniRESTSQLConnection; begin - {$IFNDEF FPC} - FSemaphore.Acquire; - FCriticalSection.Enter; - try - - if FQueue.Count = 0 then - begin - LConnection := InternalGetconnection.SetName('Connection' + IntToStr(FConnectionCounter)); - Inc(FConnectionCounter); - Result := LConnection; - end - else - begin - Result := FQueue.Dequeue; - end; - TMiniRESTSQLConnectionBase(Result).FEstaNoPool := False; - - finally - FSemaphore.Release(1); - FCriticalSection.Leave; - end; - {$IFEND} - {$IFDEF FPC} - if InterlockedDecrement(FAvailableConnections) < 0 then - begin - RTLeventResetEvent(FConnectionReleaseEvent); - RTLeventWaitFor(FConnectionReleaseEvent); - end; - RTLeventWaitFor(FConnectionGetEvent); - try - if (FConnectionCounter < FConnectionsCount) then - begin - LConnection := InternalGetconnection.SetName('Connection' + IntToStr(FConnectionCounter)); - Inc(FConnectionCounter); - Result := LConnection; - end - else - begin - LConnection := FQueue.Last; - Result := FQueue.Extract(LConnection); - end; - - TMiniRESTSQLConnectionBase(Result.GetObject).FEstaNoPool := False; - finally - RTLeventSetEvent(FConnectionGetEvent); - end; - {$IFEND} + Result := GetConnection(''); end; function TMiniRESTSQLConnectionFactoryBase.GetObject: TObject; @@ -228,12 +207,15 @@ procedure TMiniRESTSQLConnectionFactoryBase.ReleaseConnection( constructor TMiniRESTSQLConnectionBase.Create( AOwner: IMiniRESTSQLConnectionFactory); +var + LID: Integer; + LParams: IMiniRESTSQLConnectionParams; begin - FOwner := nil; - FOwner := AOwner.GetObject; - //TMiniRESTSQLConnectionFactoryBase(AOwner) - //.FConnectionsToNotifyFree.Add(Self); - TMiniRESTSQLConnectionFactoryBase(AOwner.GetObject).AddConnectionToNotifyFree(Self); + LID := InterLockedIncrement(gConnectionIDCounter); + LParams := TMiniRESTSQLConnectionParams.Create; + LParams.SetConnectionFactory(AOwner); + LParams.SetConnectionID(LID); + Create(LParams); end; function TMiniRESTSQLConnectionBase.GetName: string; @@ -349,4 +331,151 @@ procedure TMiniRESTSQLConnectionFactoryBase.RemoveConnectionToNotifyFree(AConnec FConnectionsToNotifyFree.Remove(AConnection.GetObject); end; +procedure TMiniRESTSQLConnectionFactoryBase.LogConnectionPoolEvent(const AMessage: string); +begin + if FConnectionFactoryEventLogger = nil then + Exit; + FConnectionFactoryEventLogger.LogPoolEvent(AMessage); +end; + +function TMiniRESTSQLConnectionFactoryBase.GetConnection(const AIdentifier: string): IMiniRESTSQLConnection; +var + LConnection: IMiniRESTSQLConnection; +begin + {$IFNDEF FPC} + FSemaphore.Acquire; + FCriticalSection.Enter; + try + + if FQueue.Count = 0 then + begin + LConnection := InternalGetconnection.SetName('Connection' + IntToStr(FConnectionCounter)); + Inc(FConnectionCounter); + Result := LConnection; + end + else + begin + Result := FQueue.Dequeue; + end; + TMiniRESTSQLConnectionBase(Result).FEstaNoPool := False; + + finally + FSemaphore.Release(1); + FCriticalSection.Leave; + end; + {$IFEND} + {$IFDEF FPC} + if InterlockedDecrement(FAvailableConnections) < 0 then + begin + RTLeventResetEvent(FConnectionReleaseEvent); + RTLeventWaitFor(FConnectionReleaseEvent); + end; + RTLeventWaitFor(FConnectionGetEvent); + try + if (FConnectionCounter < FConnectionsCount) then + begin + LConnection := InternalGetconnection.SetName('Connection' + IntToStr(FConnectionCounter) + ' ' + AIdentifier); + Inc(FConnectionCounter); + Result := LConnection; + end + else + begin + LConnection := FQueue.Last; + Result := FQueue.Extract(LConnection); + end; + + TMiniRESTSQLConnectionBase(Result.GetObject).FEstaNoPool := False; + LogConnectionPoolEvent(Format('GET CONNECTION %d - %s', [Result.GetConnectionID, Result.GetName])); + finally + RTLeventSetEvent(FConnectionGetEvent); + end; + {$IFEND} +end; + +function TMiniRESTSQLConnectionBase.GetConnectionID: Integer; +begin + Result := FConnectionID; +end; + +procedure TMiniRESTSQLConnectionParams.SetConnectionFactory(AConnectionFactory: IMiniRESTSQLConnectionFactory); +begin + FConnectionFactory := AConnectionFactory; +end; + +function TMiniRESTSQLConnectionParams.GetConnectionFactory: IMiniRESTSQLConnectionFactory; +begin + Result := FConnectionFactory; +end; + +function TMiniRESTSQLConnectionParams.GetConnectionID: Integer; +begin + Result := FConnectionID; +end; + +procedure TMiniRESTSQLConnectionParams.SetConnectionID(const AID: Integer); +begin + FConnectionID := AID; +end; + +constructor TMiniRESTSQLConnectionBase.Create(AParams: IMiniRESTSQLConnectionParams); +begin + FOwner := nil; + FOwner := AParams.GetConnectionFactory.GetObject; + FConnectionID := AParams.GetConnectionID; + + TMiniRESTSQLConnectionFactoryBase(FOwner).AddConnectionToNotifyFree(Self); +end; + +function TMiniRESTSQLConnectionFactoryParams.GetConnectionsCount: Integer; +begin + Result := FConnectionCount; +end; + +procedure TMiniRESTSQLConnectionFactoryParams.SetConnectionsCount(const ACount: Integer); +begin + FConnectionCount := ACount; +end; + +// class function TMiniRESTSQLConnectionFactoryParams.New: IMiniRESTSQLConnectionFactoryParams; +// begin +// Result := Create; +// end; + +constructor TMiniRESTSQLConnectionFactoryBase.Create(AParams: IMiniRESTSQLConnectionFactoryParams); +begin + FConnectionsCount := AParams.GetConnectionsCount; + {$IFNDEF FPC} + FSemaphore := TLightweightSemaphore.Create(FConnectionsCount, FConnectionsCount); + FQueue := TQueue.Create; + {$ELSE} + FAvailableConnections := FConnectionsCount; + FQueue := TFPGInterfacedObjectList.Create; + FConnectionGetEvent := RTLEventCreate; + FConnectionReleaseEvent := RTLEventCreate; + RTLeventSetEvent(FConnectionGetEvent); + RTLeventSetEvent(FConnectionReleaseEvent); + {$ENDIF} + FCriticalSection := TCriticalSection.Create; + FConnectionsToNotifyFree := TList.Create; + FConnectionFactoryEventLogger := AParams.GetConnectionFactoryEventLogger; +end; + +function TMiniRESTSQLConnectionFactoryParams.GetObject: TObject; +begin + Result := Self; +end; + +function TMiniRESTSQLConnectionFactoryParams.GetConnectionFactoryEventLogger: IMiniRESTSQLConnectionFactoryEventLogger; +begin + Result := FConnectionFactoryEventLogger; +end; + +procedure TMiniRESTSQLConnectionFactoryParams.SetConnectionFactoryEventLogger(ALogger: IMiniRESTSQLConnectionFactoryEventLogger); +begin + FConnectionFactoryEventLogger := ALogger; +end; + +initialization + gConnectionIDCounter := 0; + end. diff --git a/MiniREST.SQL.Intf.pas b/MiniREST.SQL.Intf.pas index c5684f0..bba6b3d 100644 --- a/MiniREST.SQL.Intf.pas +++ b/MiniREST.SQL.Intf.pas @@ -8,6 +8,8 @@ interface uses SysUtils, MiniREST.SQL.Common, DB; type + //TLoggerMethod = procedure (const ALog: string) of object; + IMiniRESTSQLDatabaseInfo = interface; IMiniRESTSQLQuery = interface @@ -52,13 +54,19 @@ interface function GetName: string; function SetName(const AName: string): IMiniRESTSQLConnection; function GetDatabaseInfo: IMiniRESTSQLDatabaseInfo; + function GetConnectionID: Integer; end; IMiniRESTSQLConnectionFactory = interface ['{6E405916-A78D-4C75-BCE7-07378517AB2D}'] - function GetConnection : IMiniRESTSQLConnection; - procedure ReleaseConnection(AConnection : IMiniRESTSQLConnection); + function GetConnection: IMiniRESTSQLConnection; overload; + function GetConnection(const AIdentifier: string): IMiniRESTSQLConnection; overload; + procedure ReleaseConnection(AConnection: IMiniRESTSQLConnection); function GetObject: TObject; + function GetConnectionsCount: Integer; + function GetQueueCount: Integer; + property ConnectionsCount: Integer read GetConnectionsCount; + property QueueCount: Integer read GetQueueCount; end; IMiniRESTSQLConnectionExecute = interface @@ -108,6 +116,28 @@ interface function GetColumns(const ATableName: string): TArray; end; + IMiniRESTSQLConnectionParams = interface + ['{9038DB7F-FED8-4F77-9891-428243AF6CEA}'] + function GetConnectionFactory: IMiniRESTSQLConnectionFactory; + procedure SetConnectionFactory(AConnectionFactory: IMiniRESTSQLConnectionFactory); + function GetConnectionID: Integer; + procedure SetConnectionID(const AID: Integer); + end; + + IMiniRESTSQLConnectionFactoryEventLogger = interface + ['{0AA5BDBA-4294-4364-B0B9-2AF647109B93}'] + procedure LogPoolEvent(const AMessage: string); + end; + + IMiniRESTSQLConnectionFactoryParams = interface + ['{F683E0BC-0F65-4E4A-9D52-43EBE4FA5DCD}'] + function GetConnectionFactoryEventLogger: IMiniRESTSQLConnectionFactoryEventLogger; + procedure SetConnectionFactoryEventLogger(ALogger: IMiniRESTSQLConnectionFactoryEventLogger); + function GetConnectionsCount: Integer; + procedure SetConnectionsCount(const ACount: Integer); + function GetObject: TObject; + end; + implementation end. diff --git a/MiniREST.SQL.SQLDb.pas b/MiniREST.SQL.SQLDb.pas index 6d9dfc9..539e2df 100644 --- a/MiniREST.SQL.SQLDb.pas +++ b/MiniREST.SQL.SQLDb.pas @@ -8,27 +8,24 @@ interface type TLogEvent = procedure (Sender : TSQLConnection; EventType : TDBEventType; Const Msg : String); - IMiniRESTSQLConnectionParamsSQLDb = interface - ['{F2FB358A-6369-4FCE-AA9B-75FFECA18E88}'] - function GetConnectionsCount: Integer; - function SetConnectionsCount(const AConnectionsCount: Integer): IMiniRESTSQLConnectionParamsSQLDb; + IMiniRESTSQLConnectionFactoryParamsSQLDb = interface(IMiniRESTSQLConnectionFactoryParams) + ['{F2FB358A-6369-4FCE-AA9B-75FFECA18E88}'] function GetConnectionString: string; - function SetConnectionString(const AConnectionString: string): IMiniRESTSQLConnectionParamsSQLDb; + procedure SetConnectionString(const AConnectionString: string); function GetUserName: string; - function SetUserName(const AUserName: string): IMiniRESTSQLConnectionParamsSQLDb; + procedure SetUserName(const AUserName: string); function GetPassword: string; - function SetPassword(const APassword: string): IMiniRESTSQLConnectionParamsSQLDb; + procedure SetPassword(const APassword: string); function GetDatabaseType: TMiniRESTSQLDatabaseType; - function SetDatabseType(const ADatabaseType: TMiniRESTSQLDatabaseType): IMiniRESTSQLConnectionParamsSQLDb; + procedure SetDatabseType(const ADatabaseType: TMiniRESTSQLDatabaseType); function GetDatabaseName: string; - function SetDatabaseName(const ADatabaseName: string): IMiniRESTSQLConnectionParamsSQLDb; + procedure SetDatabaseName(const ADatabaseName: string); function GetLogEvent: TLogEvent; - function SetLogEvent(const ALogEvent: TLogEvent): IMiniRESTSQLConnectionParamsSQLDb; + procedure SetLogEvent(const ALogEvent: TLogEvent); end; - TMiniRESTSQLConnectionParamsSQLDb = class(TInterfacedObject, IMiniRESTSQLConnectionParamsSQLDb) + TMiniRESTSQLConnectionParamsSQLDb = class(TMiniRESTSQLConnectionFactoryParams, IMiniRESTSQLConnectionFactoryParamsSQLDb) private - FConnectionsCount: Integer; FConnectionString: string; FUserName: string; FPassword: string; @@ -36,31 +33,30 @@ TMiniRESTSQLConnectionParamsSQLDb = class(TInterfacedObject, IMiniRESTSQLConne FDatabaseName: string; FLogEvent: TLogEvent; public - class function New: IMiniRESTSQLConnectionParamsSQLDb; - function GetConnectionsCount: Integer; - function SetConnectionsCount(const AConnectionsCount: Integer): IMiniRESTSQLConnectionParamsSQLDb; function GetConnectionString: string; - function SetConnectionString(const AConnectionString: string): IMiniRESTSQLConnectionParamsSQLDb; + procedure SetConnectionString(const AConnectionString: string); function GetUserName: string; - function SetUserName(const AUserName: string): IMiniRESTSQLConnectionParamsSQLDb; + procedure SetUserName(const AUserName: string); function GetPassword: string; - function SetPassword(const APassword: string): IMiniRESTSQLConnectionParamsSQLDb; + procedure SetPassword(const APassword: string); function GetDatabaseType: TMiniRESTSQLDatabaseType; - function SetDatabseType(const ADatabaseType: TMiniRESTSQLDatabaseType): IMiniRESTSQLConnectionParamsSQLDb; + procedure SetDatabseType(const ADatabaseType: TMiniRESTSQLDatabaseType); function GetDatabaseName: string; - function SetDatabaseName(const ADatabaseName: string): IMiniRESTSQLConnectionParamsSQLDb; + procedure SetDatabaseName(const ADatabaseName: string); function GetLogEvent: TLogEvent; - function SetLogEvent(const ALogEvent: TLogEvent): IMiniRESTSQLConnectionParamsSQLDb; + procedure SetLogEvent(const ALogEvent: TLogEvent); end; TMiniRESTSQLConnectionFactorySQLDb = class(TMiniRESTSQLConnectionFactoryBase) protected FConnectionString: string; - FConnectionParams: IMiniRESTSQLConnectionParamsSQLDb; + FConnectionParams: IMiniRESTSQLConnectionFactoryParamsSQLDb; procedure ReleaseConnection(AConnection: IMiniRESTSQLConnection); override; function InternalGetconnection: IMiniRESTSQLConnection; override; public - constructor Create(AParams: IMiniRESTSQLConnectionParamsSQLDb); overload; + constructor Create(AParams: IMiniRESTSQLConnectionFactoryParamsSQLDb); reintroduce; + function GetConnectionsCount: Integer; override; + function GetQueueCount: Integer; override; end; { TMiniRESTSQLConnectionSQLDb } @@ -71,7 +67,7 @@ TMiniRESTSQLConnectionSQLDb = class(TMiniRESTSQLConnectionBase) protected FSQLConnection: TSQLConnector; //FTransaction: TDBXTransaction; - FConnectionParams: IMiniRESTSQLConnectionParamsSQLDb; + FConnectionParams: IMiniRESTSQLConnectionFactoryParamsSQLDb; FTransaction: TSQLTransaction; FInExplicitTransaction: Boolean; FLogEvent: TLogEvent; @@ -80,7 +76,7 @@ TMiniRESTSQLConnectionSQLDb = class(TMiniRESTSQLConnectionBase) procedure Log(Sender : TSQLConnection; EventType : TDBEventType; Const Msg : String); procedure SetMiniRESTSQLParamToSQLParam(AMiniRESTSQLParam: IMiniRESTSQLParam; ASQLParam: TParam); public - constructor Create(AOwner: IMiniRESTSQLConnectionFactory; AParams: IMiniRESTSQLConnectionParamsSQLDb); + constructor Create(AOwner: IMiniRESTSQLConnectionFactory; AParams: IMiniRESTSQLConnectionFactoryParamsSQLDb); destructor Destroy; override; procedure Connect; override; procedure StartTransaction; override; @@ -125,30 +121,13 @@ implementation type TMiniRESTSQLConnectionBaseCrack = class(TMiniRESTSQLConnectionBase); -class function TMiniRESTSQLConnectionParamsSQLDb.New: IMiniRESTSQLConnectionParamsSQLDb; -begin - Result := Create; -end; - -function TMiniRESTSQLConnectionParamsSQLDb.GetConnectionsCount: Integer; -begin - Result := FConnectionsCount; -end; - -function TMiniRESTSQLConnectionParamsSQLDb.SetConnectionsCount(const AConnectionsCount: Integer): IMiniRESTSQLConnectionParamsSQLDb; -begin - Result := Self; - FConnectionsCount := AConnectionsCount; -end; - function TMiniRESTSQLConnectionParamsSQLDb.GetConnectionString: string; begin Result := FConnectionString; end; -function TMiniRESTSQLConnectionParamsSQLDb.SetConnectionString(const AConnectionString: string): IMiniRESTSQLConnectionParamsSQLDb; +procedure TMiniRESTSQLConnectionParamsSQLDb.SetConnectionString(const AConnectionString: string); begin - Result := Self; FConnectionString := AConnectionString; end; @@ -157,9 +136,8 @@ function TMiniRESTSQLConnectionParamsSQLDb.GetUserName: string; Result := FUserName; end; -function TMiniRESTSQLConnectionParamsSQLDb.SetUserName(const AUserName: string): IMiniRESTSQLConnectionParamsSQLDb; +procedure TMiniRESTSQLConnectionParamsSQLDb.SetUserName(const AUserName: string); begin - Result := Self; FUserName := AUserName; end; @@ -168,9 +146,8 @@ function TMiniRESTSQLConnectionParamsSQLDb.GetPassword: string; Result := FPassword; end; -function TMiniRESTSQLConnectionParamsSQLDb.SetPassword(const APassword: string): IMiniRESTSQLConnectionParamsSQLDb; +procedure TMiniRESTSQLConnectionParamsSQLDb.SetPassword(const APassword: string); begin - Result := Self; FPassword := APassword; end; @@ -179,9 +156,8 @@ function TMiniRESTSQLConnectionParamsSQLDb.GetDatabaseType: TMiniRESTSQLDatabase Result := FDatabaseType; end; -function TMiniRESTSQLConnectionParamsSQLDb.SetDatabseType(const ADatabaseType: TMiniRESTSQLDatabaseType): IMiniRESTSQLConnectionParamsSQLDb; +procedure TMiniRESTSQLConnectionParamsSQLDb.SetDatabseType(const ADatabaseType: TMiniRESTSQLDatabaseType); begin - Result := Self; FDatabaseType := ADatabaseType; end; @@ -190,15 +166,17 @@ function TMiniRESTSQLConnectionFactorySQLDb.InternalGetconnection: IMiniRESTSQLC Result := TMiniRESTSQLConnectionSQLDb.Create(Self, FConnectionParams); end; -constructor TMiniRESTSQLConnectionFactorySQLDb.Create(AParams: IMiniRESTSQLConnectionParamsSQLDb); +constructor TMiniRESTSQLConnectionFactorySQLDb.Create(AParams: IMiniRESTSQLConnectionFactoryParamsSQLDb); begin - inherited Create(AParams.GetConnectionsCount); + inherited Create(AParams); FConnectionParams := AParams; FConnectionsCount := AParams.GetConnectionsCount; end; -constructor TMiniRESTSQLConnectionSQLDb.Create(AOwner: IMiniRESTSQLConnectionFactory; AParams: IMiniRESTSQLConnectionParamsSQLDb); +constructor TMiniRESTSQLConnectionSQLDb.Create(AOwner: IMiniRESTSQLConnectionFactory; AParams: IMiniRESTSQLConnectionFactoryParamsSQLDb); begin + if AParams = nil then + raise Exception.Create('Não foram passados os parâmetros'); FSQLConnection := TSQLConnector.Create(nil); FTransaction := TSQLTransaction.Create(nil); if (AParams.GetDatabaseType = dbtFirebird) then @@ -472,9 +450,8 @@ function TMiniRESTSQLConnectionParamsSQLDb.GetDatabaseName: string; Result := FDatabaseName; end; -function TMiniRESTSQLConnectionParamsSQLDb.SetDatabaseName(const ADatabaseName: string): IMiniRESTSQLConnectionParamsSQLDb; +procedure TMiniRESTSQLConnectionParamsSQLDb.SetDatabaseName(const ADatabaseName: string); begin - Result := Self; FDatabaseName := ADatabaseName; end; @@ -485,6 +462,8 @@ procedure TMiniRESTSQLConnectionFactorySQLDb.ReleaseConnection(AConnection: IMin FQueue.Add(AConnection); TMiniRESTSQLConnectionBaseCrack(AConnection.GetObject).FEstaNoPool := True; Inc(FAvailableConnections); + LogConnectionPoolEvent(Format('RELEASE CONNECTION %d - %s', [AConnection.GetConnectionID, + AConnection.GetName])); finally RTLeventSetEvent(FConnectionReleaseEvent); RTLeventSetEvent(FConnectionGetEvent); @@ -496,10 +475,9 @@ function TMiniRESTSQLConnectionParamsSQLDb.GetLogEvent: TLogEvent; Result := FLogEvent; end; -function TMiniRESTSQLConnectionParamsSQLDb.SetLogEvent(const ALogEvent: TLogEvent): IMiniRESTSQLConnectionParamsSQLDb; +procedure TMiniRESTSQLConnectionParamsSQLDb.SetLogEvent(const ALogEvent: TLogEvent); begin FLogEvent := ALogEvent; - Result := Self; end; procedure TMiniRESTSQLConnectionSQLDb.SetMiniRESTSQLParamToSQLParam(AMiniRESTSQLParam: IMiniRESTSQLParam; ASQLParam: TParam); @@ -520,4 +498,16 @@ function TMiniRESTSQLConnectionSQLDb.InTransaction: Boolean; Result := FSQLConnection.Transaction.Active; end; +function TMiniRESTSQLConnectionFactorySQLDb.GetConnectionsCount: Integer; +begin + Result := FConnectionsCount; +end; + +function TMiniRESTSQLConnectionFactorySQLDb.GetQueueCount: Integer; +begin + Result := FAvailableConnections; + if Result < 0 then + Result := 0; +end; + end. diff --git a/unittest/SQL/MiniRESTSQLTest.lps b/unittest/SQL/MiniRESTSQLTest.lps index f1cb891..11a08bc 100644 --- a/unittest/SQL/MiniRESTSQLTest.lps +++ b/unittest/SQL/MiniRESTSQLTest.lps @@ -4,7 +4,7 @@ - + @@ -16,26 +16,25 @@ - - - + + - - - + + + - + @@ -60,17 +59,18 @@ - - - + + + - - + + + @@ -79,14 +79,14 @@ - + - + @@ -94,192 +94,209 @@ - + - + - - - - + + + + + - + - + - + - + - + - + - + + + + + + + + + + + + + + + + + - - + + - + - + - + - + - + - - + + - - + + - - + + - + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - + - - + + - - + + - - + + - - + + - - + + - + - - + + - - + + - - + + - - + + - - + + - - + + @@ -288,71 +305,57 @@ - + - - - + + - + - + - - - + + - - - + + - - - + + - - - + + - - + - - - - - - - - diff --git a/unittest/SQL/Test.SQL.Default.pas b/unittest/SQL/Test.SQL.Default.pas index a4c162b..de00bcd 100644 --- a/unittest/SQL/Test.SQL.Default.pas +++ b/unittest/SQL/Test.SQL.Default.pas @@ -9,10 +9,15 @@ interface TLogMessageProc = procedure (const AMessage: string) of object; TMiniRESTSQLTest = class({$IFNDEF FPC}TObject{$ELSE}TTestCase{$IFEND}) protected + FConnectionCount: Integer; FConnectionFactory: IMiniRESTSQLConnectionFactory; - function GetConnectionFactory: IMiniRESTSQLConnectionFactory; virtual; abstract; + FConnectionPoolEvents: TStringList; + function GetConnectionFactory: IMiniRESTSQLConnectionFactory; virtual; abstract; overload; + function GetConnectionFactory(AParams: IMiniRESTSQLConnectionFactoryParams): IMiniRESTSQLConnectionFactory; virtual; abstract; overload; + function GetConnectionFactoryParams: IMiniRESTSQLConnectionFactoryParams; virtual; abstract; procedure LogMessage(const AMessage: string); virtual; function GetSequenceValue(const ASequenceName: string): Integer; + procedure LogConnectionPoolEvent(const AMessage: string); public {$IFNDEF FPC} [SetupFixture] @@ -75,6 +80,22 @@ TMiniRESTSQLTest = class({$IFNDEF FPC}TObject{$ELSE}TTestCase{$IFEND}) [Test] {$IFEND} procedure TestClearParamsOnSetSQL; + {$IFNDEF FPC} + [Test] + {$IFEND} + procedure TestConnectionCount; + {$IFNDEF FPC} + [Test] + {$IFEND} + procedure TestQueueCount; + {$IFNDEF FPC} + [Test] + {$IFEND} + procedure TestQueueCount2; + {$IFNDEF FPC} + [Test] + {$IFEND} + procedure TestConnectionPoolEventLogger; (* {$IFNDEF FPC} [Test] {$IFEND} @@ -97,6 +118,17 @@ TThreadTesteInsert2 = class(TThread) constructor Create(const AID: Integer; ACreateSuspended: Boolean; AFactory: IMiniRESTSQLConnectionFactory; ALogMessageProc: TLogMessageProc); end; + { TConnectionFactoryEventLogger } + + TConnectionFactoryEventLogger = class(TInterfacedObject, IMiniRESTSQLConnectionFactoryEventLogger) + private + FList: TStringList; + public + constructor Create(AList: TStringList); + destructor Destroy; override; + procedure LogPoolEvent(const AMessage: string); + end; + var gLogHabilitado: Boolean; implementation @@ -106,6 +138,7 @@ implementation procedure TMiniRESTSQLTest.SetupFixture; begin + FConnectionCount := 3; FConnectionFactory := GetConnectionFactory; end; @@ -115,6 +148,7 @@ procedure TMiniRESTSQLTest.TearDown; begin LConnection := FConnectionFactory.GetConnection; LConnection.Execute('DELETE FROM CUSTOMER', []); + FConnectionPoolEvents.Free; end; procedure TMiniRESTSQLTest.TestInsert; @@ -155,6 +189,7 @@ procedure TMiniRESTSQLTest.Setup; var LConnection: IMiniRESTSQLConnection; begin + FConnectionPoolEvents := TStringList.Create; LConnection := FConnectionFactory.GetConnection; LConnection.Execute('DELETE FROM CUSTOMER', []); end; @@ -572,4 +607,88 @@ procedure TMiniRESTSQLTest.TestClearParamsOnSetSQL; {$IFEND} end; +procedure TMiniRESTSQLTest.TestConnectionCount; +begin + {$IFNDEF FPC} + Assert.AreEqual(FConnectionCount, FConnectionFactory.ConnectionsCount); + {$ELSE} + CheckEquals(FConnectionCount, FConnectionFactory.ConnectionsCount); + {$IFEND} +end; + +procedure TMiniRESTSQLTest.TestQueueCount; +var + LConn1: IMiniRESTSQLConnection; + LConn2: IMiniRESTSQLConnection; +begin + LConn1 := FConnectionFactory.GetConnection; + LConn2 := FConnectionFactory.GetConnection; + {$IFNDEF FPC} + Assert.AreEqual(FConnectionCount - 2, FConnectionFactory.QueueCount); + {$ELSE} + CheckEquals(FConnectionCount - 2, FConnectionFactory.QueueCount); + {$IFEND} +end; + +procedure TMiniRESTSQLTest.TestQueueCount2; +var + LConn1: IMiniRESTSQLConnection; + LConn2: IMiniRESTSQLConnection; +begin + LConn1 := FConnectionFactory.GetConnection; + LConn2 := FConnectionFactory.GetConnection; + LConn2 := nil; + {$IFNDEF FPC} + Assert.AreEqual(FConnectionCount - 1, FConnectionFactory.QueueCount); + {$ELSE} + CheckEquals(FConnectionCount - 1, FConnectionFactory.QueueCount); + {$IFEND} +end; + +procedure TMiniRESTSQLTest.TestConnectionPoolEventLogger; +var + LConnectionFactory: IMiniRESTSQLConnectionFactory; + LParams: IMiniRESTSQLConnectionFactoryParams; + LConn1: IMiniRESTSQLConnection; + LConn2: IMiniRESTSQLConnection; + LLogger: IMiniRESTSQLConnectionFactoryEventLogger; +begin + LParams := GetConnectionFactoryParams; + LLogger := TConnectionFactoryEventLogger.Create(FConnectionPoolEvents); + LParams.SetConnectionFactoryEventLogger(LLogger); + LConnectionFactory := GetConnectionFactory(LParams); + LConn1 := LConnectionFactory.GetConnection('teste1'); + LConn2 := LConnectionFactory.GetConnection('teste2'); + LConn1 := nil; + LConn2 := nil; + {$IFNDEF FPC} + Assert.AreEqual(4, FConnectionPoolEvents.Count); + {$ELSE} + CheckEquals(4, FConnectionPoolEvents.Count); + {$IFEND} + FConnectionPoolEvents.SaveToFile(ExtractFilePath(ParamStr(0)) + 'logPool.txt'); +end; + +procedure TMiniRESTSQLTest.LogConnectionPoolEvent(const AMessage: string); +begin + FConnectionPoolEvents.Add(AMessage); +end; + +procedure TConnectionFactoryEventLogger.LogPoolEvent(const AMessage: string); +begin + FList.Add(AMessage); +end; + +constructor TConnectionFactoryEventLogger.Create(AList: TStringList); +begin + inherited Create; + FList := AList; +end; + +destructor TConnectionFactoryEventLogger.Destroy; +begin + FList := nil; + inherited Destroy; +end; + end. diff --git a/unittest/SQL/Test.SQL.Firedac.pas b/unittest/SQL/Test.SQL.Firedac.pas index 5a505fc..573a959 100644 --- a/unittest/SQL/Test.SQL.Firedac.pas +++ b/unittest/SQL/Test.SQL.Firedac.pas @@ -29,7 +29,7 @@ function TMiniRESTSQLTestFiredac.GetConnectionFactory: IMiniRESTSQLConnectionFac LConnectionInfo.Values['Server'] := 'localhost'; Result := TMiniRESTSQLConnectionFactoryFiredac.Create( TMiniRESTSQLConnectionParamsFiredac.New - .SetConnectionsCount(5) + .SetConnectionsCount(FConnectionCount) .SetConnectionString(LConnectionInfo.Text) .SetDatabseType(dbtFirebird) .SetUserName('SYSDBA') diff --git a/unittest/SQL/test.sql.sqldb.pas b/unittest/SQL/test.sql.sqldb.pas index de2148d..17f0702 100644 --- a/unittest/SQL/test.sql.sqldb.pas +++ b/unittest/SQL/test.sql.sqldb.pas @@ -12,9 +12,13 @@ interface { TMiniRESTSQLTestSQLDbFPC } TMiniRESTSQLTestSQLDbFPC= class(TMiniRESTSQLTest) + private + function InternalGetConnectionFactoryParams: IMiniRESTSQLConnectionFactoryParamsSQLDb; protected procedure SetUpOnce; override; - function GetConnectionFactory: IMiniRESTSQLConnectionFactory; override; + function GetConnectionFactory: IMiniRESTSQLConnectionFactory; override; overload; + function GetConnectionFactory(AParams: IMiniRESTSQLConnectionFactoryParams): IMiniRESTSQLConnectionFactory; override; overload; + function GetConnectionFactoryParams: IMiniRESTSQLConnectionFactoryParams; override; procedure LogMessage(const AMessage: string); override; published procedure TestSQLDB1; @@ -56,6 +60,38 @@ procedure TMiniRESTSQLTestSQLDbFPC.SetUpOnce; end; function TMiniRESTSQLTestSQLDbFPC.GetConnectionFactory: IMiniRESTSQLConnectionFactory; +begin + Result := GetConnectionFactory(GetConnectionFactoryParams); +end; + +procedure TMiniRESTSQLTestSQLDbFPC.TestSQLDB1; +var + LConn1: IMiniRESTSQLConnection; +begin + LConn1 := FConnectionFactory.GetConnection; + Check(Assigned(LConn1)); +end; + +procedure TMiniRESTSQLTestSQLDbFPC.LogMessage(const AMessage: string); +begin + LogEvent(AMessage); +end; + +function TMiniRESTSQLTestSQLDbFPC.GetConnectionFactory(AParams: IMiniRESTSQLConnectionFactoryParams): IMiniRESTSQLConnectionFactory; +var + LParams: IMiniRESTSQLConnectionFactoryParamsSQLDb; +begin + if not AParams.GetObject.GetInterface(IMiniRESTSQLConnectionFactoryParamsSQLDb, LParams) then + raise Exception.Create('AParams não implementa a interface IMiniRESTSQLConnectionFactoryParamsSQLDb'); + Result := TMiniRESTSQLConnectionFactorySQLDb.Create(LParams); +end; + +function TMiniRESTSQLTestSQLDbFPC.GetConnectionFactoryParams: IMiniRESTSQLConnectionFactoryParams; +begin + Result := InternalGetConnectionFactoryParams; +end; + +function TMiniRESTSQLTestSQLDbFPC.InternalGetConnectionFactoryParams: IMiniRESTSQLConnectionFactoryParamsSQLDb; var LConnectionInfo: TStringList; LDBFilePath: string; @@ -68,34 +104,19 @@ function TMiniRESTSQLTestSQLDbFPC.GetConnectionFactory: IMiniRESTSQLConnectionFa LDBFilePath := ExpandFileName(LPathAux); LConnectionInfo.Values['DatabaseName'] := LDBFilePath; LConnectionInfo.Values['Server'] := 'localhost'; - Result := TMiniRESTSQLConnectionFactorySQLDb.Create( - TMiniRESTSQLConnectionParamsSQLDb.New - .SetConnectionsCount(3) - .SetConnectionString(LConnectionInfo.Text) - .SetDatabseType(dbtFirebird) - .SetDatabaseName(LDBFilePath) - .SetUserName('SYSDBA') - .SetPassword('masterkey') - .SetLogEvent(@LogEvent) - ); + Result := TMiniRESTSQLConnectionParamsSQLDb.Create; + Result.SetConnectionsCount(FConnectionCount); + Result.SetConnectionString(LConnectionInfo.Text); + Result.SetDatabseType(dbtFirebird); + Result.SetDatabaseName(LDBFilePath); + Result.SetUserName('SYSDBA'); + Result.SetPassword('masterkey'); + Result.SetLogEvent(@LogEvent); finally LConnectionInfo.Free; end; end; -procedure TMiniRESTSQLTestSQLDbFPC.TestSQLDB1; -var - LConn1: IMiniRESTSQLConnection; -begin - LConn1 := FConnectionFactory.GetConnection; - Check(Assigned(LConn1)); -end; - -procedure TMiniRESTSQLTestSQLDbFPC.LogMessage(const AMessage: string); -begin - LogEvent(AMessage); -end; - initialization RegisterTest(TMiniRESTSQLTestSQLDbFPC.Suite); if FileExists('log.txt') then diff --git a/unittest/TEST.FDB b/unittest/TEST.FDB index 922d4a2..472054a 100644 Binary files a/unittest/TEST.FDB and b/unittest/TEST.FDB differ