private static int ExecuteBatchStoreCommand(DatabaseEngine db, StoreCommand[] storeCommandList, int maxExecuteCount = 100)
{
int totalCount = 0;//总影响记录数
if (maxExecuteCount <= 1)
{
foreach (var sc in storeCommandList)
{
DbCommand dbCmd = ConvertStoreCommandToDbCommand(db, sc);
totalCount += db.ExecuteNonQuery(dbCmd);
}
}
else
{
List <StoreCommand> storeCommandListTemp = new List <StoreCommand>();
int paramerCount = 0;//参数数量
for (int i = 0; i < storeCommandList.Length; i++)
{
storeCommandListTemp.Add(storeCommandList[i]);
paramerCount += storeCommandList[i].Parameters.Length;
if (i == (storeCommandList.Length - 1) || storeCommandListTemp.Count == maxExecuteCount || paramerCount >= MaxParameterCount)
{
StoreCommand sc = StoreCommandHelper.UnitStoreCommand(storeCommandListTemp);
DbCommand dbCmd = ConvertStoreCommandToDbCommand(db, sc);
totalCount += db.ExecuteNonQuery(dbCmd);
storeCommandListTemp.Clear();
paramerCount = 0;
}
}
}
return(totalCount);
}
public override int GetSeed(string tableName, string pkColumn, int SeedPoolSize = 100)
{
SeedPool pool = null;
DatabaseEngine db = DatabaseEngineFactory.GetDatabaseEngine();
lock (this)
{
string PoolName = string.Format("{0}_{1}", db.DatabaseSession.DatabaseName, db.GetTableName(tableName));
if (SeedPoolDict.ContainsKey(PoolName))
{
pool = SeedPoolDict[PoolName]; //从种子缓存加载种子值
}
else
{
//初始化种子缓存
int SeedValue = db.GetMaxSeed(tableName, pkColumn, 0);
pool = new SeedPool();
pool.TableName = tableName;
pool.SeedValue = SeedValue;
SeedPoolDict[PoolName] = pool;
}
}
lock (pool)
{
return(++pool.SeedValue);
}
}
public static DatabaseEngine GetNewDatabaseEngine(string databasename)
{
lock (LockedObject)
{
DatabaseEngine engine = null;
EnumDatabaseEngineType enginetype = GetDatabaseEngineType(databasename);
switch (enginetype)
{
case EnumDatabaseEngineType.Sql2005: engine = new Sql2005DatabaseEngine(); break;
case EnumDatabaseEngineType.Sql2008: engine = new Sql2008DatabaseEngine(); break;
case EnumDatabaseEngineType.Sql2012: engine = new Sql2012DatabaseEngine(); break;
case EnumDatabaseEngineType.SQLite: engine = new SQLiteDatabaseEngine(); break;
case EnumDatabaseEngineType.Oracle: engine = new OracleDatabaseEngine(); break;
case EnumDatabaseEngineType.GenericDatabase: engine = new GenericDatabaseEngine(); break;
}
DatabaseSession session = new DatabaseSession(databasename);
engine.DatabaseSession = session;
return(engine);
}
}
public static List <T> ExecuteQuery <T>(DatabaseEngine db, StoreCommand storeCommand)
{
DbCommand dbCmd = ConvertStoreCommandToDbCommand(db, storeCommand);
List <T> list = new List <T>();
using (IDataReader dr = db.ExecuteReader(dbCmd))
{
db.Load(typeof(T), list, dr);
}
return(list);
}
public override void ClearSeed(string tableName)
{
DatabaseEngine db = DatabaseEngineFactory.GetDatabaseEngine();
string PoolName = string.Format("{0}_{1}", db.DatabaseSession.DatabaseName, db.GetTableName(tableName));
lock (this)
{
if (SeedPoolDict.ContainsKey(PoolName))
{
SeedPoolDict.Remove(PoolName);
}
}
}
public static DbCommand ConvertStoreCommandToDbCommand(DatabaseEngine db, StoreCommand storeCommand)
{
Regex regex = new Regex(@"\{(\d+)\}");
string cmdText = regex.Replace(storeCommand.CommandText, db.GetParameterPrefix() + "Para$1");
DbCommand dbCmd = db.DatabaseSession.Database.GetSqlStringCommand(cmdText);
for (int i = 0; i < storeCommand.Parameters.Length; i++)
{
SqlParameter par = new SqlParameter("Para" + i.ToString(), storeCommand.Parameters[i]);
db.AddParameter(dbCmd, par);
}
return(dbCmd);
}
public static int ExecuteStoreCommand(DatabaseEngine db, params StoreCommand[] storeCommands)
{
if (storeCommands.Length == 0)
{
return(0);
}
else if (storeCommands.Length > 1)
{
return(ExecuteBatchStoreCommand(db, storeCommands));
}
else
{
return(ExecuteStoreCommand(db, storeCommands[0].CommandText, storeCommands[0].Parameters));
}
}
public IList ToList()
{
IList list = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(TableMapping.ObjectType));
DatabaseEngine db = DatabaseEngineFactory.GetDatabaseEngine();
if (this.PageIndex == -1)
{
db.Load(this, list);
}
else
{
db.LoadPage(this, list);
}
return(list);
}
public static StoreCommand GetStoreCommand(DatabaseEngine db, string strSQL, SqlParameterCollection paras)
{
StoreCommand storecommand = new StoreCommand();
storecommand.Parameters = new object[paras.Count];
List <SqlParameter> tempparas = paras.OrderByDescending(o => o.Name.Length).ToList();
for (int i = 0; i < tempparas.Count; i++)
{
strSQL = strSQL.Replace(string.Format("@{0}", tempparas[i].Name), string.Format("{{{0}}}", i));
storecommand.Parameters[i] = tempparas[i].Value;
}
storecommand.CommandText = strSQL;
return(storecommand);
}
public static DatabaseEngine GetDatabaseEngine(string databasename = "")
{
lock (LockedObject)
{
DatabaseSession session = null;
if (string.IsNullOrWhiteSpace(databasename))
{
session = DatabaseScopeManager.Instance.GetCurrentDatabaseSession();
}
else
{
session = DatabaseScopeManager.Instance.GetCurrentDatabaseSession(databasename);
}
DatabaseEngine engine = null;
EnumDatabaseEngineType enginetype = GetDatabaseEngineType(session != null ? session.DatabaseName : databasename);
switch (enginetype)
{
case EnumDatabaseEngineType.Sql2005: engine = new Sql2005DatabaseEngine(); break;
case EnumDatabaseEngineType.Sql2008: engine = new Sql2008DatabaseEngine(); break;
case EnumDatabaseEngineType.Sql2012: engine = new Sql2012DatabaseEngine(); break;
case EnumDatabaseEngineType.SQLite: engine = new SQLiteDatabaseEngine(); break;
case EnumDatabaseEngineType.Oracle: engine = new OracleDatabaseEngine(); break;
case EnumDatabaseEngineType.GenericDatabase: engine = new GenericDatabaseEngine(); break;
}
if (engine != null)
{
if (session == null)
{
session = new DatabaseSession(databasename);
}
engine.DatabaseSession = session;
}
else
{
throw new ObjectMappingException("not find database engine");
}
return(engine);
}
}
public object FirstOrDefault()
{
List <object> list = new List <object>();
DatabaseEngine db = DatabaseEngineFactory.GetDatabaseEngine();
int bakTakeCount = this.TakeCount;
try
{
this.TakeCount = 1;
db.Load(this, list);
}
finally
{
this.TakeCount = bakTakeCount;
}
return(list.FirstOrDefault());
}
public override void ClearSeed(string tableName)
{
DatabaseEngine db = DatabaseEngineFactory.GetDatabaseEngine();
string PoolName = string.Format("{0}_{1}", db.DatabaseSession.DatabaseName, db.GetTableName(tableName));
lock (this)
{
using (DatabaseScope ds = new DatabaseScope().BeginTransaction(TransactionScopeOption.RequiresNew))
{
DatabaseEngine newdb = DatabaseEngineFactory.GetNewDatabaseEngine(db.DatabaseSession.DatabaseName);
newdb.DatabaseSession.MappingTable = db.DatabaseSession.MappingTable;
newdb.ExecuteNonQuery(string.Format("delete from tableseed where tablename='{0}'", db.GetTableName(tableName)));
if (SeedPoolDict.ContainsKey(PoolName))
{
SeedPoolDict.Remove(PoolName);
}
ds.Complete();
}
}
}
public int Update(Expression <Func <object> > expression)
{
HashSet <string> props = ExpressionHelper.GetExpression_PropertyList(expression);
if (props.Count == 0)
{
throw new ObjectMappingException("not any property updated!");
}
object obj = expression.Compile()();
Type objType = obj.GetType();
foreach (var prop in props)
{
var val = objType.GetProperty(prop).GetValue(obj, null);
ColumnMapping column = TableMapping.GetColumnMappingByProperty(prop);
this.UpdateParameters.Add(new SqlParameter(column != null ? column.Name : prop, val));
}
DatabaseEngine db = DatabaseEngineFactory.GetDatabaseEngine();
return(db.Update(this));
}
public int Update()
{
DatabaseEngine db = DatabaseEngineFactory.GetDatabaseEngine();
return(db.Update(this));
}
private int?GetFactorySeed(DatabaseEngine db, string tableName)
{
object seed = db.ExecuteScalar(string.Format("select top 1 seed from tableseed where tablename='{0}'", db.GetTableName(tableName)));
return((seed == DBNull.Value) ? null : (int?)seed);
}
public override int GetSeed(string tableName, string pkColumn, int SeedPoolSize = 100)
{
SeedPool pool = null;
DatabaseEngine db = DatabaseEngineFactory.GetDatabaseEngine();
lock (this)
{
string PoolName = string.Format("{0}_{1}", db.DatabaseSession.DatabaseName, db.GetTableName(tableName));
if (SeedPoolDict.ContainsKey(PoolName))
{
pool = SeedPoolDict[PoolName]; //从种子缓存加载种子值
}
else
{
//初始化种子缓存
int SeedValue = 0;
int CurTableMaxSeed = db.GetMaxSeed(tableName, pkColumn, 0); //从数据库表中获取当前记录中已使用的最大种子值，如果没有记录则使用默认种子值(0)
using (DatabaseScope ds = new DatabaseScope().BeginTransaction(TransactionScopeOption.RequiresNew))
{
DatabaseEngine newdb = DatabaseEngineFactory.GetNewDatabaseEngine(db.DatabaseSession.DatabaseName);
newdb.DatabaseSession.MappingTable = db.DatabaseSession.MappingTable;
int?FactorySeed = GetFactorySeed(newdb, tableName);
if (FactorySeed.HasValue)
{
SeedValue = FactorySeed.Value;
}
else
{
SeedValue = CurTableMaxSeed;
newdb.ExecuteNonQuery(string.Format("insert into tableseed values('{0}',{1})", db.GetTableName(tableName), SeedValue));
}
ds.Complete();
}
pool = new SeedPool();
pool.TableName = tableName;
pool.SeedValue = pool.MaxSeedValue = SeedValue;
SeedPoolDict[PoolName] = pool;
}
}
lock (pool)
{
if (pool.SeedValue >= pool.MaxSeedValue)
{
using (DatabaseScope ds = new DatabaseScope().BeginTransaction(TransactionScopeOption.RequiresNew))
{
DatabaseEngine newdb = DatabaseEngineFactory.GetNewDatabaseEngine(db.DatabaseSession.DatabaseName);
newdb.DatabaseSession.MappingTable = db.DatabaseSession.MappingTable;
string strSQL = string.Format("update tableseed set seed=seed+{0} where tablename='{1}'", SeedPoolSize, newdb.GetTableName(tableName));
int ret = newdb.ExecuteNonQuery(strSQL);
if (ret != 1)
{
throw new ObjectMappingException(string.Format("GetSeed Failed -> \"{0}\"", strSQL));
}
pool.MaxSeedValue = GetFactorySeed(newdb, tableName).Value;
ds.Complete();
}
pool.SeedValue = pool.MaxSeedValue - SeedPoolSize;
}
return(++pool.SeedValue);
}
}
public int Count()
{
DatabaseEngine db = DatabaseEngineFactory.GetDatabaseEngine();
return(db.Count(this));
}
public object Max(string column)
{
DatabaseEngine db = DatabaseEngineFactory.GetDatabaseEngine();
return(db.Max(this, column));
}
public static int ExecuteStoreCommand(DatabaseEngine db, string storeCommandText, params object[] parameters)
{
DbCommand dbCmd = ConvertStoreCommandToDbCommand(db, new StoreCommand(storeCommandText, parameters));
return(db.ExecuteNonQuery(dbCmd));
}
