public MatchingEngine(IPriceRestClient priceRestClient, IDbAccess dbAccess, IPublisherMessageBroker publisherMessageBroker)
{
_priceRestClient = priceRestClient;
_dbAccess = dbAccess;
_publisherMessageBroker = publisherMessageBroker;
_cancel = new CancellationTokenSource();
}
/// <summary>Upgrades the Category table.</summary>
/// <param name="repository">The repository.</param>
/// <param name="dbAccess">The database access.</param>
/// <param name="dbCommand">The database command.</param>
private void UpgradeTable(IRepository <Category> repository, IDbAccess dbAccess, IDbCommand dbCommand)
{
if (!dbCommand.Connection.ColumnExists <Category>(x => x.Flags))
{
dbCommand.Connection.AddColumn <Category>(x => x.Flags);
}
}
/// <summary>
/// The execute scalar.
/// </summary>
/// <param name="dbAccess">
/// The db access.
/// </param>
/// <param name="cmd">
/// The cmd.
/// </param>
/// <returns>
/// The execute scalar.
/// </returns>
public static object ExecuteScalar([NotNull] this IDbAccess dbAccess, [NotNull] IDbCommand cmd)
{
CodeContracts.ArgumentNotNull(dbAccess, "dbAccess");
CodeContracts.ArgumentNotNull(cmd, "cmd");
return(dbAccess.ExecuteScalar(cmd, false));
}
/// <summary>
/// The get data.
/// </summary>
/// <param name="dbAccess">
/// The db access.
/// </param>
/// <param name="cmd">
/// The cmd.
/// </param>
/// <returns>
/// </returns>
public static DataTable GetData([NotNull] this IDbAccess dbAccess, [NotNull] IDbCommand cmd)
{
CodeContracts.ArgumentNotNull(dbAccess, "dbAccess");
CodeContracts.ArgumentNotNull(cmd, "cmd");
return(dbAccess.GetData(cmd, false));
}
private void UpgradeTable(IRepository <ProfileDefinition> repository, IDbAccess dbAccess, IDbCommand dbCommand)
{
if (!dbCommand.Connection.ColumnExists <ProfileDefinition>(x => x.ShowOnRegisterPage))
{
dbCommand.Connection.AddColumn <ProfileDefinition>(x => x.ShowOnRegisterPage);
}
}
/// <summary>
/// The execute non query.
/// </summary>
/// <param name="dbAccess">
/// The db access.
/// </param>
/// <param name="cmd">
/// The cmd.
/// </param>
public static void ExecuteNonQuery([NotNull] this IDbAccess dbAccess, [NotNull] IDbCommand cmd)
{
CodeContracts.ArgumentNotNull(dbAccess, "dbAccess");
CodeContracts.ArgumentNotNull(cmd, "cmd");
dbAccess.ExecuteNonQuery(cmd, false);
}
/// <summary>
/// Insert the entity using the model provided.
/// </summary>
/// <param name="dbAccess">
/// The db access.
/// </param>
/// <param name="insert">
/// The insert.
/// </param>
/// <param name="transaction">
/// The transaction.
/// </param>
/// <returns>
/// The <see cref="int"/>.
/// </returns>
public static int Insert <T>([NotNull] this IDbAccess dbAccess, [NotNull] T insert, [CanBeNull] IDbTransaction transaction = null)
where T : IEntity
{
CodeContracts.VerifyNotNull(dbAccess, "dbAccess");
if (transaction != null && transaction.Connection != null)
{
using (var command = OrmLiteConfig.DialectProvider.CreateParameterizedInsertStatement(insert, transaction.Connection))
{
command.Populate(transaction);
dbAccess.ExecuteNonQuery(command, transaction);
return((int)OrmLiteConfig.DialectProvider.GetLastInsertId(command));
}
}
// no transaction
using (var connection = dbAccess.CreateConnectionOpen())
{
using (var command = OrmLiteConfig.DialectProvider.CreateParameterizedInsertStatement(insert, connection))
{
command.Connection = connection;
dbAccess.ExecuteNonQuery(command, transaction);
return((int)OrmLiteConfig.DialectProvider.GetLastInsertId(command));
}
}
}
/// <summary>
/// The db_runsql.
/// </summary>
/// <param name="sql">
/// The sql.
/// </param>
/// <param name="connectionManager">
/// The conn man.
/// </param>
/// <param name="useTransaction">
/// The use Transaction.
/// </param>
/// <returns>
/// The db_runsql.
/// </returns>
public static string RunSQL(this IDbAccess dbAccess, [NotNull] string sql, bool useTransaction)
{
try
{
using (var trans = dbAccess.CreateConnectionOpen().BeginTransaction())
{
sql = CommandTextHelpers.GetCommandTextReplaced(sql.Trim());
using (var cmd = trans.Connection.CreateCommand())
{
// added so command won't timeout anymore...
cmd.CommandTimeout = int.Parse(Config.SqlCommandTimeout);
cmd.Transaction = trans;
cmd.CommandType = CommandType.Text;
cmd.CommandText = sql;
return(InnerRunSqlExecuteReader(cmd as SqlCommand, useTransaction));
}
}
}
finally
{
messageRunSql = string.Empty;
}
}
public CustomerBusinessModel(IDbAccess dbAccess, int customerId)
{
this.dbAccess = dbAccess;
this.customerId = customerId;
Data = CustomerModel.Load(dbAccess, customerId);
}
/// <summary>
/// Gets the database size
/// </summary>
/// <param name="dbAccess">The database access.</param>
/// <returns>
/// integer value for database size
/// </returns>
public static int DBSize(this IDbAccess dbAccess)
{
CodeContracts.VerifyNotNull(dbAccess, "dbAccess");
return(dbAccess.Execute(
db => db.Connection.Scalar <int>("SELECT sum(reserved_page_count) * 8.0 / 1024 FROM sys.dm_db_partition_stats")));
}
/// <summary>使用程序锁直接从表的字段里面算得递增值,频率低时使用</summary>
/// <param name="tableName">表名</param>
/// <param name="colName">列名</param>
/// <returns></returns>
public int NewIDForce(IDbAccess iDb, string tableName, string colName)
{
string key = GeneKey(tableName, colName);
object lockObj = GetLock(tableName, colName);
lock (lockObj)
{
string str = iDb.GetFirstColumnString(string.Format("select max({0}) from {1}", colName, tableName));
if (str == "")
{
str = "0";
}
int id = int.Parse(str) + 1;
object obj;
if (ht_ids.TryGetValue(key, out obj))
{
ht_ids[key] = id;
}
else
{
ht_ids.TryAdd(key, id);
}
return(id);
}
}
/// <summary>根据表名和列名生成ID,第一次生成后就不需要再访问数据库,频率高时使用</summary>
/// <param name="tableName">表名</param>
/// <param name="colName">列名</param>
/// <returns></returns>
public int NewID(IDbAccess iDb, string tableName, string colName)
{
string key = GeneKey(tableName, colName);
object lockobj = GetLock(tableName, colName);
lock (lockobj)
{
object obj;
if (!ht_ids.TryGetValue(key, out obj))
{
string str = iDb.GetFirstColumnString(string.Format("select max({0}) from {1}", colName, tableName));
if (string.IsNullOrWhiteSpace(str))
{
obj = 1;
}
else
{
obj = int.Parse(str) + 1;
}
ht_ids.TryAdd(key, obj);
}
else
{
obj = int.Parse(obj.ToString()) + 1;
ht_ids[key] = obj;
}
return(int.Parse(obj.ToString()));
}
}
public EmailerFirst(IDbAccess repo)
{
this.repo = repo;
client = new SmtpClient {
Host = "mail.carsales.com.au"
};
}
public static void ShrinkDatabase(this IDbAccess dbAccess)
{
CodeContracts.VerifyNotNull(dbAccess, "dbAccess");
dbAccess.Execute(
db => db.Connection.ExecuteSql("DBCC SHRINKDATABASE(N'{0}')".FormatWith(db.Connection.Database)));
}
private void UpgradeTable(IRepository <User> repository, IDbAccess dbAccess, IDbCommand dbCommand)
{
if (dbCommand.Connection.ColumnExists <User>("Password"))
{
dbCommand.Connection.DropColumn <User>("Password");
}
}
public static string ReIndexDatabase(this IDbAccess dbAccess)
{
CodeContracts.VerifyNotNull(dbAccess, "dbAccess");
var sb = new StringBuilder();
sb.AppendLine("DECLARE @MyTable VARCHAR(255)");
sb.AppendLine("DECLARE myCursor");
sb.AppendLine("CURSOR FOR");
sb.AppendFormat(
"SELECT table_name FROM information_schema.tables WHERE table_type = 'base table' AND table_name LIKE '{0}%'",
Config.DatabaseObjectQualifier);
sb.AppendLine("OPEN myCursor");
sb.AppendLine("FETCH NEXT");
sb.AppendLine("FROM myCursor INTO @MyTable");
sb.AppendLine("WHILE @@FETCH_STATUS = 0");
sb.AppendLine("BEGIN");
sb.AppendLine("PRINT 'Reindexing Table: ' + @MyTable");
sb.AppendLine("DBCC DBREINDEX(@MyTable, '', 80)");
sb.AppendLine("FETCH NEXT");
sb.AppendLine("FROM myCursor INTO @MyTable");
sb.AppendLine("END");
sb.AppendLine("CLOSE myCursor");
sb.AppendLine("DEALLOCATE myCursor");
using (var cmd = dbAccess.GetCommand(sb.ToString(), CommandType.Text))
{
return(dbAccess.ExecuteScalar(cmd).ToType <string>());
}
}
public static void updateAndAddTransaction()
{
IDbAccess db = IDbFactory.CreateIDb(connStr, dbType);
try
{
db.IsTran = true;
db.BeginTransaction();
//add
string tableName = "templjqfortest";
Hashtable ht = new Hashtable();
ht.Add("name", "hello db11");
ht.Add("createtime", new DateTime(2011, 2, 1, 2, 2, 2, 11));
ht.Add("supertiem", null);
Console.WriteLine("" + db.AddData(tableName, ht));
//delete
string filterStr = "and name >='hello db7'";
Console.WriteLine("delete is " + db.DeleteRow(tableName, filterStr));
db.Commit();
}
catch (Exception e)
{
db.Rollback();
db.Close();
}
}
public void Z__EmbedIOCSharedPerThread()
{
EmbedIOC.Register<IDbAccess>(() => _threadStatic ?? (_threadStatic = new SqlDb("SqlDb:" + Thread.CurrentThread.Name)));
var threadList = new List<Thread>();
for (int threadCounter = 1; threadCounter <= 10; threadCounter++)
{
var newThread = new Thread(new ThreadStart(EmbedIOCSharedPerThread_Worker))
{
Name= threadCounter.ToString()
};
threadList.Add(newThread);
}
// start threads
threadList.ForEach(t => t.Start());
// wait for all thread completion
threadList.ForEach(t => t.Join());
_threadReferenceList.ForEach(x =>
{
// assert that 10 different instances were created, one for each thread
Assert.AreEqual(1, _threadReferenceList.Count(v => v == x));
});
}
/// <summary>
/// Insert the entity using the model provided.
/// </summary>
/// <typeparam name="T">The type parameter</typeparam>
/// <param name="dbAccess">The DB access.</param>
/// <param name="insert">The insert.</param>
/// <param name="transaction">The transaction.</param>
/// <param name="selectIdentity">if set to <c>true</c> [select identity].</param>
/// <returns>
/// The <see cref="int" />.
/// </returns>
public static long Insert <T>(
[NotNull] this IDbAccess dbAccess,
[NotNull] T insert,
[CanBeNull] IDbTransaction transaction = null,
bool selectIdentity = false) where T : IEntity
{
CodeContracts.VerifyNotNull(dbAccess, "dbAccess");
if (transaction != null && transaction.Connection != null)
{
using (var command = transaction.Connection.CreateCommand())
{
OrmLiteConfig.DialectProvider.PrepareParameterizedInsertStatement <T>(command);
OrmLiteConfig.DialectProvider.SetParameterValues <T>(command, insert);
return(selectIdentity
? OrmLiteConfig.DialectProvider.InsertAndGetLastInsertId <T>(command)
: dbAccess.ExecuteNonQuery(command, transaction));
}
}
// no transaction
using (var connection = dbAccess.CreateConnectionOpen())
{
using (var command = connection.CreateCommand())
{
OrmLiteConfig.DialectProvider.PrepareParameterizedInsertStatement <T>(command);
OrmLiteConfig.DialectProvider.SetParameterValues <T>(command, insert);
return(selectIdentity
? OrmLiteConfig.DialectProvider.InsertAndGetLastInsertId <T>(command)
: dbAccess.ExecuteNonQuery(command, transaction));
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BasicRepository{T}"/> class.
/// </summary>
/// <param name="dbFunction">
/// The db function.
/// </param>
/// <param name="dbAccess">
/// The db Access.
/// </param>
/// <param name="raiseEvent">
/// The raise Event.
/// </param>
/// <param name="haveBoardId">
/// The have Board Id.
/// </param>
public BasicRepository(IDbFunction dbFunction, IDbAccess dbAccess, IRaiseEvent raiseEvent, IHaveBoardID haveBoardId)
{
this.DbFunction = dbFunction;
this.DbAccess = dbAccess;
this.DbEvent = raiseEvent;
this.BoardID = haveBoardId.BoardID;
}
private static RecordTable CreateDataSource(GridColumnInfo info, IDbAccess dataAccess)
{
SqlQuery query = new SqlQuery();
StringBuilder text = query.Text;
text.Append("SELECT ");
text.Append(info.ParentValueField);
text.Append(',');
text.Append(info.ParentTextField);
text.Append(" FROM ");
text.Append(info.ParentTable);
if (!String.IsNullOrEmpty(info.FilterExpression))
{
text.Append(" WHERE ");
text.Append(info.FilterExpression);
}
if (!String.IsNullOrEmpty(info.SortExpression))
{
text.Append(" ORDER BY ");
text.Append(info.SortExpression);
}
RecordTable table = new RecordTable(info.ParentTable);
using(IDataReader dr = dataAccess.CreateDataReader(query, CommandBehavior.Default))
{
table.Load(dr, false, new UISchemaTableReader(info.ParentValueField));
}
return table;
}
protected CommandFactoryBase(IDbAccess dataAccess)
{
if (null == dataAccess)
throw new ArgumentNullException(nameof(dataAccess));
this.DataAccess = dataAccess;
}
public void SetupAutoDataBind(IDbAccess dataAccess)
{
if (null == dataAccess)
throw new ArgumentNullException("dataAccess");
this.dataAccess = dataAccess;
}
public static string RenameObjectToRunAsAutonomousTransaction(this IDbAccess access, string schema, object objectName)
{
var builder = new SqlConnectionStringBuilder(access.Session.Database.ConnectionString);
var initialCatalog = builder.InitialCatalog;
return($"loopback.[{initialCatalog}].[{schema}].[{objectName}]");
}
/// <summary>
/// Gets the current SQL Engine Edition.
/// </summary>
/// <param name="dbAccess">The database access.</param>
/// <returns>
/// Returns the current SQL Engine Edition.
/// </returns>
public static string GetSQLEngine(this IDbAccess dbAccess)
{
CodeContracts.VerifyNotNull(dbAccess, "dbAccess");
try
{
using (var cmd = dbAccess.GetCommand("select SERVERPROPERTY('EngineEdition')", CommandType.Text))
{
switch (dbAccess.ExecuteScalar(cmd).ToType <int>())
{
case 1:
return("Personal");
case 2:
return("Standard");
case 3:
return("Enterprise");
case 4:
return("Express");
case 5:
return("Azure");
default:
return("Unknown");
}
}
}
catch
{
return("Unknown");
}
}
public static void GetDatasetByStoreProcedure()
{
IDbAccess db = IDbFactory.CreateIDb(connStr, dbType);
//IDataParameter[] paraArr = new OracleParameter[3];
//paraArr[0] = new OracleParameter()
//{
// ParameterName = "a",
// Value=null,
// Direction = ParameterDirection.ReturnValue
//};
//paraArr[1] = new OracleParameter()
//{
// ParameterName = "b",
// Value = 12
//};
//paraArr[2] = new OracleParameter()
//{
// ParameterName = "c",
// Value = 13
//};
IDataParameter[] paraArr = new OracleParameter[1];
paraArr[0] = new OracleParameter()
{
ParameterName = "EMPS",
Value = null,
Direction = ParameterDirection.Output,
OracleType = OracleType.Cursor
};
DataSet ds = db.GetDatasetByStoreProcedure("GetTableInfo", paraArr);
}
//use non transactional operations only.
internal static TRepository CreateRepository <TRepository>(IDbAccess dataAccess)
where TRepository : IDisposable
{
var cmd = CreateCommand(dataAccess);
return((TRepository)Activator.CreateInstance(typeof(TRepository), cmd));
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseReflectedSpecificFunctions"/> class.
/// </summary>
/// <param name="staticReflectedClass">
/// The static reflected class.
/// </param>
/// <param name="access">
/// The DB Access.
/// </param>
protected BaseReflectedSpecificFunctions(IReflect staticReflectedClass, IDbAccess access)
: base(access)
{
this.Methods = staticReflectedClass.GetMethods(BindingFlags.Static | BindingFlags.Public)
.ToDictionary(k => k, k => k.GetParameters());
this.SupportedOperations = this.Methods.Select(x => x.Key.Name).ToList();
}
protected CommandFactoryBase(IDbAccess dataAccess)
{
if (null == dataAccess)
throw new ArgumentNullException("IDbAccess is null");
this.dataAccess = dataAccess;
}
/// <summary>
/// Gets the reader.
/// </summary>
/// <param name="dbAccess">The DB access.</param>
/// <param name="cmd">The command.</param>
/// <param name="dbTransaction">The DB transaction.</param>
/// <returns>
/// The <see cref="IDataReader" /> .
/// </returns>
public static IDataReader GetReader([NotNull] this IDbAccess dbAccess, [NotNull] IDbCommand cmd, [NotNull] IDbTransaction dbTransaction)
{
CodeContracts.VerifyNotNull(dbAccess, "dbAccess");
CodeContracts.VerifyNotNull(cmd, "cmd");
CodeContracts.VerifyNotNull(dbTransaction, "dbTransaction");
return(dbAccess.Execute(c => c.ExecuteReader(), cmd, dbTransaction));
}
public EntitySqlQueryBuilderInsert(IDbAccess dataAccess, bool isUpsert)
{
if (null == dataAccess)
throw new ArgumentNullException(nameof(dataAccess));
this.dataAccess = dataAccess;
this.isUpsert = isUpsert;
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseReflectedSpecificFunctions"/> class.
/// </summary>
/// <param name="staticReflectedClass">
/// The static reflected class.
/// </param>
protected BaseReflectedSpecificFunctions(Type staticReflectedClass, IDbAccess dbAccess)
:base(dbAccess)
{
this._methods = staticReflectedClass
.GetMethods(BindingFlags.Static | BindingFlags.Public)
.ToDictionary(k => k, k => k.GetParameters());
this._supportedOperations = this._methods.Select(x => x.Key.Name).ToList();
}
public EntitySqlQueryBuilderInsert(IDbAccess dataAccess, bool isUpsert)
{
if (null == dataAccess)
throw new ArgumentNullException("dataAccess");
this.dataAccess = dataAccess;
this.isUpsert = isUpsert;
this.ParameterIndex = -1;
}
internal GridComboBoxColumn(GridColumnInfo info, IDbAccess dataAccess)
{
base.DataMemberBinding = new Binding(info.PropertyName);
base.SelectedValueMemberPath = info.ParentValueField;
base.DisplayMemberPath = info.ParentTextField;
base.ItemsSource = CreateDataSource(info, dataAccess);
base.IsComboBoxEditable = true;
}
internal static string GetSequenceName(IDbAccess dataAccess, string tableName, string pkColumn)
{
lock (SyncRoot)
{
tableName = tableName.ToUpper(EnCulture);//Oracle Büyük Harf istiyor.
string sequenceName;
if (!dic.TryGetValue(tableName, out sequenceName))
{
sequenceName = SequenceManager.GetSequenceName(dataAccess, tableName, pkColumn, true).ToString();
dic.Add(tableName, sequenceName);
}
return sequenceName;
}
}
public CommandFactory(IDbAccess dataAccess)
: base(dataAccess) { }
public EntityCollectionCommand(IDbAccess dataAccess)
: base(dataAccess) { }
private static string GetSequenceName(IDbAccess dataAccess, string tableName, string pkColumnName, bool checkSequence)
{
if (dataAccess == null)
throw new ArgumentNullException(nameof(dataAccess));
if (String.IsNullOrEmpty(tableName))
throw new ArgumentNullException(nameof(tableName));
if (String.IsNullOrEmpty(pkColumnName))
throw new ArgumentNullException(nameof(pkColumnName));
string[] arr = tableName.Split('.');
bool withUser = arr.Length > 1;
string sequenceName = null;
if (withUser)
sequenceName = arr[0] + ".SQE_" + arr[1];
else
sequenceName = "SQE_" + tableName;
if (checkSequence)
{
object temp = null;
decimal ret = 0M, minVal = 1M, curVal = 0M;
SqlQuery query = new SqlQuery();
StringBuilder text = query.Text;
try
{
text.Append("SELECT MAX(");
text.Append(tableName);
text.Append('.');
text.Append(pkColumnName);
text.Append(") FROM ");
text.Append(tableName);
temp = dataAccess.ExecuteScalar(query);
if (temp != null && temp.GetType() != CachedTypes.DBNull)
{
minVal = ((Decimal)temp) + 1M;
}
query.Clear();
text = query.Text;
text.Append(" SELECT COUNT(*) FROM");
if (withUser)
{
text.Append(" ALL_SEQUENCES T WHERE T.SEQUENCE_OWNER = :SEQUENCE_OWNER AND");
query.Parameters.Add("SEQUENCE_OWNER", arr[0]);
query.Parameters.Add("SEQUENCE_NAME", "SQE_" + arr[1]);
}
else
{
text.Append(" USER_SEQUENCES T WHERE");
query.Parameters.Add("SEQUENCE_NAME", sequenceName);
}
text.Append(" T.SEQUENCE_NAME = :SEQUENCE_NAME");
ret = (Decimal)dataAccess.ExecuteScalar(query);
if (ret == 0M)
{
query.Clear();
text = query.Text;
text.Append("CREATE SEQUENCE ");
text.Append(sequenceName);
text.AppendLine();
text.Append("MINVALUE 0");
text.AppendLine();
text.Append("MAXVALUE 9999999999999999999999999");
text.AppendLine();
text.Append("START WITH ");
text.Append(minVal);
text.AppendLine();
text.Append("INCREMENT BY 1");
text.AppendLine();
text.Append("CACHE 20");
text.AppendLine();
dataAccess.ExecuteNonQuery(query);
}
else
{
query.Clear();
text = query.Text;
text.Append("SELECT T.LAST_NUMBER FROM");
if (withUser)
{
text.Append(" ALL_SEQUENCES T WHERE T.SEQUENCE_OWNER = :SEQUENCE_OWNER AND T.SEQUENCE_NAME = :SEQUENCE_NAME");
query.Parameters.Add("SEQUENCE_OWNER", arr[0]);
query.Parameters.Add("SEQUENCE_NAME", "SQE_" + arr[1]);
}
else
{
text.Append(" USER_SEQUENCES T WHERE T.SEQUENCE_NAME = :SEQUENCE_NAME");
query.Parameters.Add("SEQUENCE_NAME", sequenceName);
}
curVal = (Decimal)dataAccess.ExecuteScalar(query);
if (minVal > curVal)
{
query.Clear();
text = query.Text;
text.Append("ALTER SEQUENCE ");
text.Append(sequenceName);
text.Append(" INCREMENT BY :INC;");
query.Parameters.Add("INC", minVal - curVal);
text.AppendLine();
text.Append("SELECT ");
text.Append(sequenceName);
text.Append(".NEXTVAL FROM DUAL;");
text.AppendLine();
text.Append("ALTER SEQUENCE ");
text.Append(sequenceName);
text.Append(" INCREMENT BY 1;");
dataAccess.ExecuteScalar(query);
}
}
}
catch (Exception ex)
{
throw new InvalidOperationException(
$"An error occurred while creating a sequence for '{tableName}' Oracle table. Error detail: '{ex.Message}'");
}
}
return sequenceName;
}
/// <summary>
/// Initializes a new instance of the <see cref="InitDatabaseProviderEvent"/> class.
/// </summary>
/// <param name="providerName">
/// The provider name.
/// </param>
/// <param name="dbAccess">
/// The db access.
/// </param>
public InitDatabaseProviderEvent(string providerName, IDbAccess dbAccess)
{
this.ProviderName = providerName;
this.DbAccess = dbAccess;
}
public static DataTable GetSchemaTable(string selectSql, IDbAccess dataAccess)
{
if (String.IsNullOrEmpty(selectSql)) return null;
DataTable schemaTable;
Dictionary<string, DataTable> schemaDic = SchemaDic;
if (!schemaDic.TryGetValue(selectSql, out schemaTable))
{
string schemaSql = "SELECT TOP 0 * FROM (" + selectSql + ") T";
schemaTable = dataAccess.QueryDataTable(schemaSql.ToQuery());
schemaDic.Add(selectSql, schemaTable);
}
return schemaTable;
}
/// <summary>
/// Initializes a new instance of the <see cref="InstallUpgradeService" /> class.
/// </summary>
/// <param name="serviceLocator">The service locator.</param>
/// <param name="raiseEvent">The raise Event.</param>
/// <param name="dbAccess">The database access.</param>
public InstallUpgradeService(IServiceLocator serviceLocator, IRaiseEvent raiseEvent, IDbAccess dbAccess)
{
this.RaiseEvent = raiseEvent;
this.DbAccess = dbAccess;
this.ServiceLocator = serviceLocator;
}
/// <summary>
/// Initializes a new instance of the <see cref="ReflectMsSqlSpecificFunctions"/> class.
/// </summary>
/// <param name="dbAccess">The db access.</param>
public ReflectMsSqlSpecificFunctions(IDbAccess dbAccess)
: base(typeof(MsSqlSpecificFunctions), dbAccess)
{
}
