public void have_an_empty_session_cache_if_not_set()
{
_services = ObjectFactory.GetInstance <IDatabaseServices>();
var cache = _services.SessionStateCache;
Assert.IsInstanceOfType(cache, typeof(EmptySessionStateCache));
}
public IDbTransaction CreateTransaction(string connectionName, string connectionString)
{
try {
if (!String.IsNullOrEmpty(connectionName))
{
IDatabaseServices databaseServices = AdaptersUtils.GetDatabaseServices(GetDatabaseKind(connectionName),
new ConnectionString(connectionString));
ITransactionManager baseTransactionManager = GetProviderFromConnectionNameOrMain(connectionName).TransactionManager;
ITransactionService transactionService = databaseServices.TransactionService;
IDbConnection connection = transactionService.CreateConnection();
return(ADOAdaptersUtils.AdapterTransaction(transactionService.CreateTransaction(connection)));
}
else
{
return(CreateTransaction(connectionString));
}
} catch (ConnectionNotFoundException e) {
throw new DBConnectionNotFoundException(e.Message);
} catch (InvalidDatabaseAccessException e) {
throw new InvalidDBTransactionManagerAccess(e.Message);
} catch (InvalidTransactionReleaseException e) {
throw new InvalidReleaseException(e.Message);
}
}
public void CloseTransaction(IDbTransaction transaction)
{
IDbTransaction trans = ADOAdaptersUtils.GetADOTransaction(transaction);
IDatabaseServices databaseServices = DBHelper.GetDatabaseServicesForConnection(trans.Connection);
databaseServices.TransactionService.CloseTransaction(trans);
}
public static bool isConnectedUser(IDbTransaction transaction, string userName)
{
IDbTransaction trans = ADOAdaptersUtils.GetADOTransaction(transaction);
IDatabaseServices databaseServices = DBHelper.GetDatabaseServicesForConnection(trans.Connection);
return(DBCompatibilityReflectionUtils.IsConnectedUser(transaction.Connection, userName, databaseServices.ExecutionService));
}
/// <summary>
/// Initializes a new instance of the <see cref="DatabaseRepository"/> class.
/// </summary>
public SnapshotRepository(IDatabaseServices databaseServices)
{
ArgumentChecks.AssertNotNull(databaseServices, nameof(databaseServices));
this._databaseServices = databaseServices;
this._snapshotsPerDatabaseDict = new Dictionary <DatabaseInfo, IEnumerable <SnapshotInfo> >();
}
public void have_an_empty_session_cache_if_not_set()
{
_services = ObjectFactory.GetInstance<IDatabaseServices>();
var cache = _services.SessionStateCache;
Assert.IsInstanceOfType(cache, typeof(EmptySessionStateCache));
}
protected BaseTableSourceInfo(IDatabaseServices databaseServices, IDatabaseInfo database, string name, string qualifiedName)
{
DatabaseServices = databaseServices;
Database = database;
Name = name;
QualifiedName = qualifiedName;
}
/// <summary>
/// Initializes a new instance of the <see cref="DatabaseRepository"/> class.
/// </summary>
public DatabaseRepository(IDatabaseServices databaseServices)
{
ArgumentChecks.AssertNotNull(databaseServices, nameof(databaseServices));
this._databaseServices = databaseServices;
this._databasesPerConnectionDict = new Dictionary <ConnectionInfo, IEnumerable <DatabaseInfo> >();
}
public PumpController(IDatabaseServices DatabaseService, IEmployeeServices EmployeeServices, IApplicationServices ApplicationServices, ICallDataServices CallDataServices, ICallTreeServices CallTreeServices)
{
_databaseServices = DatabaseService;
_employeeServices = EmployeeServices;
_applicationServices = ApplicationServices;
_callDataServices = CallDataServices;
_callTreeServices = CallTreeServices;
}
internal static DBSqlServerVersion GetSqlServerVersion(IDatabaseServices databaseServices)
{
#if JAVA
return(DBSqlServerVersion.Unknown);
#else
return(DBCompatibilityReflectionUtils.GetSqlServerVersion(databaseServices.ExecutionService));
#endif
}
private void AssertValue <T>(IDatabaseServices services, string defaultValueName, string defaultValue, object expectedValue)
{
var sqlExecutor = new SQLExecutor(services);
string sql = "SELECT " + defaultValue + " o1 FROM DUMMY" + MachineName;
object result = sqlExecutor.ExecuteScalar(sql).RuntimeValue <T>();
AssertEqual(expectedValue, result, string.Format(errorMessageFormat, defaultValueName, sql));
}
private static void AssertValues <T>(IDatabaseServices services, string sqlFunctionFragment, T expectedValue)
{
var sqlExecutor = new SQLExecutor(services);
string sql = string.Format(SQL_FORMAT, sqlFunctionFragment, MachineName);
T result = sqlExecutor.ExecuteScalar(sql).RuntimeValue <T>();
AssertEqual(expectedValue, result, string.Format(ERROR_MESSAGE_FORMAT, sqlFunctionFragment, sql));
}
internal Transaction(IDatabaseServices databaseServices, IDbTransaction transaction)
{
if (databaseServices == null || transaction == null)
{
throw new ArgumentNullException();
}
DriverTransaction = transaction;
DatabaseServices = databaseServices;
}
public IDbTransaction CreateTransaction(ConnectionString connectionString)
{
try {
IDatabaseServices databaseServices = AdaptersUtils.GetDatabaseServices(DatabaseKind, connectionString);
return(ADOAdaptersUtils.AdapterTransaction(databaseServices.TransactionService.CreateTransaction(GetConnection(connectionString))));
} catch (InvalidDatabaseAccessException e) {
throw new InvalidDBTransactionManagerAccess(e.Message);
}
}
/// <summary>
/// Returns a name that can be used as a primary key identifier name.
/// </summary>
/// <param name="objectFactory">The introspection object factory</param>
/// <param name="databaseServices">The database services</param>
/// <param name="tableName">Name of the table for which we want to create a primary key</param>
/// <returns>A name that can be used as a sql identifier name</returns>
public static string GetNewPrimaryKeyName(this IPlatformDatabaseObjectFactory objectFactory,
IDatabaseServices databaseServices, string tableName)
{
string baseName = (IsSystemTable(tableName)
? PlatformDatabaseObjectConstants.PrimarySysConstPrefix
: PlatformDatabaseObjectConstants.PrimaryConstPrefix) + tableName;
return(objectFactory.GetNewUniqueIdentifer(databaseServices, baseName));
}
/// <summary>
/// Returns a name that can be used as a foreign key identifier name.
/// </summary>
/// <param name="objectFactory">The introspection object factory</param>
/// <param name="databaseServices">The database services</param>
/// <param name="tableName">Name of the table for which we want to create a foreign key</param>
/// <param name="referencedTableName">Name of the referenced table</param>
/// <param name="columnName">Name of the column</param>
/// <returns>A name that can be used as a sql identifier name</returns>
public static string GetNewForeignKeyName(this IPlatformDatabaseObjectFactory objectFactory,
IDatabaseServices databaseServices, string tableName, string referencedTableName,
string columnName)
{
string baseName = PlatformDatabaseObjectConstants.ForeignConstPrefix +
tableName + "_" + referencedTableName + "_" + columnName;
return(objectFactory.GetNewUniqueIdentifer(databaseServices, baseName));
}
internal DatabaseConnection(IDatabaseServices databaseServices, IDbConnection connection)
{
if (databaseServices == null || connection == null)
{
throw new ArgumentNullException();
}
this.DatabaseServices = databaseServices;
this.DriverConnection = connection;
}
/// <summary>
/// Initializes a new instance of the <see cref="DMLService"/> class.
/// </summary>
/// <param name="databaseServices">The database services.</param>
public DMLService(IDatabaseServices databaseServices)
: base(databaseServices)
{
_queries = new DMLQueries(this);
_identifiers = new DMLIdentifiers(this);
_operators = new DMLOperators(this);
_functions = new DMLFunctions(this);
_aggregateFunctions = new DMLAggregateFunctions(this);
_defaultValues = new DMLDefaultValues(this);
}
public Transaction(IDatabaseServices databaseServices, IDbTransaction transaction, IExecutionBehaviours dbBehaviours)
{
if (databaseServices == null || transaction == null)
{
throw new ArgumentNullException();
}
DriverTransaction = transaction;
DatabaseServices = databaseServices;
DatabaseBehaviours = dbBehaviours;
}
// TODO JMR REFACTOR: Review public/internal
public DatabaseConnection(IDatabaseServices databaseServices, IDbConnection connection, IExecutionBehaviours behaviours)
{
if (databaseServices == null || connection == null)
{
throw new ArgumentNullException();
}
this.DatabaseServices = databaseServices;
this.DriverConnection = connection;
this.DatabaseBehaviours = behaviours;
}
/// <summary>
/// Initializes a new instance of the <see cref="DbServerPluginServiceFacade"/> class.
/// </summary>
public DbServerPluginServiceFacade(
IDatabaseServices databases,
ISnapshotServices snapshots)
{
ArgumentChecks.AssertNotNull(databases, nameof(databases));
ArgumentChecks.AssertNotNull(snapshots, nameof(snapshots));
this.Databases = databases;
this.Snapshots = snapshots;
}
internal static DBAuthenticationType GetAuthenticationType(IDatabaseServices databaseServices)
{
#if JAVA
return(DBAuthenticationType.DBAuth);
#else
return(DBCompatibilityReflectionUtils.GetIsIntegratedSecurityOnly(databaseServices.ExecutionService)
? DBAuthenticationType.IntegratedAuth
: DBAuthenticationType.DBAuth);
#endif
}
public DMLService(IDatabaseServices databaseServices) : base(databaseServices)
{
queries = new DMLQueries(this);
identifiers = new DMLIdentifiers(this);
operators = new DMLOperators(this);
functions = new DMLFunctions(this);
aggregateFunctions = new DMLAggregateFunctions(this);
defaultValues = new DMLDefaultValues(this);
syntaxHighlightDefinitions = new DMLSyntaxHighlightDefinitions(this);
}
public PGFKInfo(IDatabaseServices dbServices, ITableSourceInfo source, IDataReader reader)
{
TableSource = source;
Name = (string)reader["constraint_name"];
ColumnName = (string)reader["source_column_name"];
IsCascadeDelete = "DELETE".Equals(((string)reader["delete_rule"]).ToUpper());
ReferencedColumnName = (string)reader["dest_column_name"];
ReferencedTableSource = new PGTableSource(dbServices, source.Database, (string)reader["dest_table_name"]);
}
private static void AssertValue <T>(IDatabaseServices services, string funcName, string sql, T expectedValue, params object[] parameters)
{
var sqlExecutor = new SQLExecutor(services);
if (parameters.Length != 0)
{
sql = string.Format(sql, parameters.Select <object, object>((o, i) => sqlExecutor.GetParameterName(i, o.GetType())).ToArray());
}
T result = sqlExecutor.ExecuteScalar(sql, parameters).RuntimeValue <T>();
AssertEqual(expectedValue, result, string.Format(ERROR_MESSAGE_FORMAT, funcName, string.Join(", ", parameters.Select <object, string>(o => o.ToString()).ToArray()), sql));
}
/// <summary>
/// Construct the select that gather which are the actual processes that will be deleted
/// </summary>
private string ProcessesToDeleteQuery(IDatabaseServices databaseServices, bool isDeletingTopProcesses)
{
string processesFilter;
if (IsBulkDeletion)
{
// Construct the select to gather the list of 1st level (Processes that have no parent process) ProcessIds to delete
string topLevelProcessesQuery;
if (bulkSizeLimit.HasValue)
{
var maxRecordsPlaceholders = databaseServices.DMLService.Queries.SQLPlaceholderValuesForMaxRecords("@bulkSizeLimit");
topLevelProcessesQuery =
maxRecordsPlaceholders.GetPlaceholderValue(SelectPlaceholder.BeforeStatement) +
" SELECT " +
maxRecordsPlaceholders.GetPlaceholderValue(SelectPlaceholder.AfterSelectKeyword) +
" p.ID " +
maxRecordsPlaceholders.GetPlaceholderValue(SelectPlaceholder.BeforeFromKeyword) +
" FROM " +
maxRecordsPlaceholders.GetPlaceholderValue(SelectPlaceholder.AfterFromKeyword) +
" OSSYS_BPM_PROCESS p INNER JOIN OSSYS_BPM_PROCESS_STATUS status ON p.STATUS_ID = status.ID " +
maxRecordsPlaceholders.GetPlaceholderValue(SelectPlaceholder.BeforeWhereKeyword) +
" WHERE " +
maxRecordsPlaceholders.GetPlaceholderValue(SelectPlaceholder.AfterWhereKeyword) +
" status.IS_TERMINAL = 1 AND p.PARENT_PROCESS_ID IS NULL AND p.LAST_MODIFIED < @olderThan " +
(processDefinitionId.HasValue ? " AND p.PROCESS_DEF_ID = @processDefinitionId" : "") +
" ORDER BY LAST_MODIFIED " +
maxRecordsPlaceholders.GetPlaceholderValue(SelectPlaceholder.AfterStatement);
// Due to MySQL limitations using IN with subqueries we have to use an outer query in the statement
topLevelProcessesQuery = String.Format("SELECT * FROM ({0}) TopProcIds", topLevelProcessesQuery);
}
else
{
topLevelProcessesQuery = @"select p.ID
from OSSYS_BPM_PROCESS p inner join OSSYS_BPM_PROCESS_STATUS status on p.STATUS_ID = status.ID
where status.IS_TERMINAL = 1 and p.PARENT_PROCESS_ID is null and p.LAST_MODIFIED < @olderThan" ;
if (processDefinitionId.HasValue)
{
topLevelProcessesQuery += " and p.PROCESS_DEF_ID = @processDefinitionId";
}
}
processesFilter = String.Format("{0} IN ({1})", isDeletingTopProcesses ? "ID" : "TOP_PROCESS_ID", topLevelProcessesQuery);
}
else
{
processesFilter = String.Format("{0} = @processId", isDeletingTopProcesses ? "ID" : "TOP_PROCESS_ID");
}
// Due to MySQL limitations using IN with subqueries we have to use an outer query in the statement
return(String.Format("SELECT ProcId FROM (SELECT ID as ProcId FROM OSSYS_BPM_PROCESS WHERE {0}) ProcIds", processesFilter));
}
public MySQLDatabaseInfo(IDatabaseServices databaseServices, string name)
: base(databaseServices)
{
//TODO: needs review
if (string.IsNullOrEmpty(name))
{
Name = databaseServices.DatabaseConfiguration.DatabaseIdentifier;
}
else
{
Name = name;
}
}
internal static ITableSourceInfo GetTableSourceInfo(IDatabaseServices databaseServices, string tableName, bool assertExists)
{
IDatabaseInfo db = databaseServices.ObjectFactory.CreateDatabaseInfo(GetDatabaseIdentifier(databaseServices));
var tables = databaseServices.IntrospectionService.ListTableSourcesWithoutFilter(db);
ITableSourceInfo result = tables.FirstOrDefault(ts => ts.Name.EqualsIgnoreCase(tableName));
if (assertExists)
{
Assert.IsNotNull(result, "Table source named '" + tableName + "' not found in the database");
}
return(result);
}
public DatabaseInfo(IDatabaseServices databaseServices, string catalog, string linkedServer) : base(databaseServices)
{
Catalog = catalog;
if (string.IsNullOrEmpty(Catalog))
{
DatabaseServices sqlServices = databaseServices as DatabaseServices;
if (sqlServices != null)
{
Catalog = ((RuntimeDatabaseConfiguration)sqlServices.DatabaseConfiguration).Catalog;
}
}
LinkedServer = linkedServer ?? string.Empty;
}
public DatabaseInfo(IDatabaseServices databaseServices, string schema, string databaseLink) : base(databaseServices)
{
Schema = schema;
if (string.IsNullOrEmpty(Schema))
{
DatabaseServices sqlServices = databaseServices as DatabaseServices;
if (sqlServices != null)
{
Schema = ((RuntimeDatabaseConfiguration)sqlServices.DatabaseConfiguration).Schema;
}
}
DatabaseLink = databaseLink ?? string.Empty;
}
public IDbConnection GetConnectionByName(string connectionName)
{
try {
IDatabaseServices databaseServices = GetProviderFromConnectionNameOrMain(connectionName).DatabaseServices;
return(databaseServices.TransactionService.CreateConnection());
} catch (ConnectionNotFoundException e) {
throw new DBConnectionNotFoundException(e.Message);
} catch (InvalidDatabaseAccessException e) {
throw new InvalidDBTransactionManagerAccess(e.Message);
} catch (InvalidTransactionReleaseException e) {
throw new InvalidReleaseException(e.Message);
}
}
public LoginController(IDatabaseServices databaseServices)
{
DatabaseServices = databaseServices;
}
public void Init()
{
_sessionState = Isolate.Fake.Instance<HttpSessionStateBase>();
_factory = Isolate.Fake.Instance<ISessionFactory>();
Isolate.WhenCalled(() => _sessionState[HttpSessionStateCache.SessionFactorySetting]).WillReturn(_factory);
_stateCache = new HttpSessionStateCache(_sessionState);
ObjectFactory.Configure(x => x.For<ISessionStateCache>().Use(_stateCache));
Isolate.Fake.StaticMethods(typeof(UserServices));
// ReSharper disable UnusedVariable, otherwise ConfigurationManager will not be faked
var confMan = ConfigurationManager.Instance;
// ReSharper restore UnusedVariable
Isolate.Fake.StaticMethods<ConfigurationManager>();
ObjectFactory.Configure(x => x.For<IDatabaseServices>().Use<DatabaseServices>());
_services = ObjectFactory.GetInstance<IDatabaseServices>();
_services.SessionStateCache = _stateCache;
}
public SessionFactoryProvider(IDatabaseServices databaseServices, IEnumerable<IDatabaseInitializer> initializers)
{
_databaseServices = databaseServices;
_initializers = initializers;
}
