public static void CommitIDbTransaction(IDbTransaction st)
{
try
{
IDbConnection myconn = st.Connection;
st.Commit();
if (myconn != null)
{
if (myconn.State != ConnectionState.Closed)
{
myconn.Close();
myconn.Dispose();
}
}
}
catch (Exception err)
{
IDbConnection myconn = st.Connection;
st.Rollback();
if (myconn != null)
{
if (myconn.State != ConnectionState.Closed)
{
myconn.Close();
myconn.Dispose();
}
}
throw new Exception(CBB.ExceptionHelper.ExpressionPaser.ErrTrim(err));
}
}
private void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
_logger?.LogTrace($" Dispose {nameof(OneWorldDbTransaction<TDbContext>)} start.");
_logger?.LogDebug($" totalChildren:`{_totalChildren}`/commits:`{_beCommits}`/rollbacks:`{_beRollbacks}`/TransactionId:`{TransactionId}`/TransactionNumber:`{TransactionNumber}`");
if (_totalChildren == _beCommits)
{
_dbTransaction?.Commit();
_logger?.LogInformation($" done Commit()./TransactionId:`{TransactionId}`/TransactionNumber:`{TransactionNumber}`");
}
else
{
_dbTransaction?.Rollback();
_logger?.LogWarning($" done Rollback()./TransactionId:`{TransactionId}`/TransactionNumber:`{TransactionNumber}`");
}
_logger?.LogTrace($" isNull _dbContext=`{_dbContext == null}`");
_dbContext?.Dispose();
_logger?.LogTrace($" isNull _dbTransaction=`{_dbTransaction == null}`");
_dbTransaction?.Dispose();
_logger?.LogTrace($" isNull _dbConnection=`{_dbConnection == null}`");
_dbConnection?.Close();
_dbConnection?.Dispose();
_logger?.LogDebug($" Dispose {nameof(OneWorldDbTransaction<TDbContext>)} done.");
}
public void CommitTransaction()
{
_transaction?.Commit();
_connection?.Close();
isClosed = true;
}
public void CommitTransaction()
{
dbTransaction?.Commit();
dbConnection?.Close();
isClosed = true;
}
public void CommitTransaction()
{
_transaction?.Commit(); // if tranx succeed, we commit it; "?" is null check, if _trans is null, we 're not calling "Commit" method.
_connection?.Close();
isClosed = true;
}
public virtual async Task <IEnumerable <T> > GetAllAsync(bool useTransaction = false, int?commandTimeout = null)
{
IDbSession session = DbSession;
IDbTransaction transaction = null;
if (useTransaction)
{
session.BeginTrans();
transaction = session.Transaction;
}
try
{
var result = await session.Connection.GetAllAsync <T>(transaction, commandTimeout);
transaction?.Commit();
return(result);
}
finally
{
session.Dispose();
}
}
public virtual async Task <bool> DeleteAsync(T entity, bool useTransaction = false, int?commandTimeout = null)
{
IDbSession session = DbSession;
IDbTransaction transaction = null;
if (useTransaction)
{
session.BeginTrans();
transaction = session.Transaction;
}
try
{
bool result = await session.Connection.DeleteAsync(entity, transaction, commandTimeout);
transaction?.Commit();
return(result);
}
catch (Exception ex)
{
transaction?.Rollback();
Log.Error($"RepositoryBase >> DeleteAsync Error: {ex.Message}, Entity: {JsonConvert.SerializeObject(entity)}");
return(false);
}
finally
{
session.Dispose();
}
}
public virtual async Task <int> ExecuteAsync(string sql, object param = null, bool useTransaction = false, int?commandTimeout = null,
CommandType?commandType = null)
{
IDbSession session = DbSession;
IDbTransaction transaction = null;
if (useTransaction)
{
session.BeginTrans();
transaction = session.Transaction;
}
try
{
int result = await session.Connection.ExecuteAsync(sql, param, transaction, commandTimeout, commandType);
transaction?.Commit();
return(result);
}
catch (Exception ex)
{
transaction?.Rollback();
Log.Error($"RepositoryBase >> ExecuteAsync Error: {ex.Message}");
return(0);
}
finally
{
session.Dispose();
}
}
public virtual async Task <T> GetFirstOrDefaultAsync(string sql, object param = null, bool useTransaction = false, int?commandTimeout = null)
{
IDbSession session = DbSession;
IDbTransaction transaction = null;
if (useTransaction)
{
session.BeginTrans();
transaction = session.Transaction;
}
try
{
var result = await session.Connection.QueryFirstOrDefaultAsync <T>(sql, param, transaction, commandTimeout);
transaction?.Commit();
return(result);
}
finally
{
session.Dispose();
}
}
public virtual async Task <IEnumerable <T> > GetListAsync(string sql, object param = null, bool useTransaction = false,
int?commandTimeout = null, CommandType?commandType = null)
{
if (string.IsNullOrEmpty(sql))
{
return(null);
}
IDbSession session = DbSession;
IDbTransaction transaction = null;
if (useTransaction)
{
session.BeginTrans();
transaction = session.Transaction;
}
try
{
var result = await session.Connection.QueryAsync <T>(sql, param, transaction, commandTimeout, commandType);
transaction?.Commit();
return(result);
}
finally
{
session.Dispose();
}
}
/// <summary>
/// Saving changes asynchronously to database.
/// </summary>
/// <returns>Whether the changes has been made.</returns>
public Task <bool> SaveChangesAsync()
{
return(Task.Factory.StartNew(() =>
{
try
{
_transaction?.Commit();
return true;
}
catch
{
_transaction?.Rollback();
return false;
}
finally
{
if (_transaction != null)
{
_transaction.Dispose();
_transaction = Connection.BeginTransaction();
ResetRepositories();
}
}
}));
}
public static int Execute(RDBMSProvider rdbmsProvider, string connectionString, string sqlQuery, object paramsObj = null, bool useTransaction = false, int?commandTimeOut = null, CommandType?commandType = null)
{
IDbConnection connection = null;
IDbTransaction transaction = null;
try
{
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new ArgumentException("Connection string cannot be null, empty or white-space.", nameof(connectionString));
}
connection = CreateConnection(rdbmsProvider, connectionString);
connection.Open();
if (useTransaction)
{
transaction = connection.BeginTransaction();
}
var ret = connection.Execute(sqlQuery, paramsObj, transaction, commandTimeOut, commandType);
transaction?.Commit();
return(ret);
}
catch { throw; }
finally
{
connection.Dispose();
transaction?.Dispose();
}
}
internal static async Task InsertUsingDefaultsAsync <T>(this IDbCommand dbCmd, T[] objs, CancellationToken token)
{
IDbTransaction dbTrans = null;
if (dbCmd.Transaction == null)
{
dbCmd.Transaction = dbTrans = dbCmd.Connection.BeginTransaction();
}
var dialectProvider = dbCmd.GetDialectProvider();
var modelDef = typeof(T).GetModelDefinition();
var fieldsWithoutDefaults = modelDef.FieldDefinitionsArray
.Where(x => x.DefaultValue == null)
.Select(x => x.Name)
.ToHashSet();
dialectProvider.PrepareParameterizedInsertStatement <T>(dbCmd, insertFields: fieldsWithoutDefaults);
using (dbTrans)
{
foreach (var obj in objs)
{
OrmLiteConfig.InsertFilter?.Invoke(dbCmd, obj);
dialectProvider.SetParameterValues <T>(dbCmd, obj);
await dbCmd.ExecNonQueryAsync(token);
}
dbTrans?.Commit();
}
}
internal static async Task InsertAllAsync <T>(this IDbCommand dbCmd, IEnumerable <T> objs, Action <IDbCommand> commandFilter, CancellationToken token)
{
OrmLiteUtils.AssertNotAnonType <T>();
IDbTransaction dbTrans = null;
if (dbCmd.Transaction == null)
{
dbCmd.Transaction = dbTrans = dbCmd.Connection.BeginTransaction();
}
var dialectProvider = dbCmd.GetDialectProvider();
dialectProvider.PrepareParameterizedInsertStatement <T>(dbCmd);
commandFilter?.Invoke(dbCmd);
using (dbTrans)
{
foreach (var obj in objs)
{
OrmLiteConfig.InsertFilter?.Invoke(dbCmd, obj);
dialectProvider.SetParameterValues <T>(dbCmd, obj);
await dbCmd.ExecNonQueryAsync(token);
}
dbTrans?.Commit();
}
}
public static void f_结束IDbTransaction(IDbTransaction st)
{
try
{
IDbConnection myconn = st.Connection;
st.Commit();
if (myconn != null)
{
if (myconn.State != ConnectionState.Closed)
{
myconn.Close();
myconn.Dispose();
}
}
}
catch (Exception err)
{
IDbConnection myconn = st.Connection;
st.Rollback();
if (myconn != null)
{
if (myconn.State != ConnectionState.Closed)
{
myconn.Close();
myconn.Dispose();
}
}
throw new Exception(NESCBB.ExpressionHelper.c_错误信息类.f_Sql错误处理(err));
}
}
public static IEnumerable <TReturn> Query <TFirst, TSecond, TThird, TFouth, TFifth, TSixth, TSeventh, TReturn>(RDBMSProvider rdbmsProvider, string connectionString, string sqlQuery, Func <TFirst, TSecond, TThird, TFouth, TFifth, TSixth, TSeventh, TReturn> map, object paramsObj = null, bool useTransaction = false, bool buffered = true, string splitOn = "Id", int?commandTimeOut = null, CommandType?commandType = null)
{
IDbConnection connection = null;
IDbTransaction transaction = null;
try
{
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new ArgumentException("Connection string cannot be null, empty or white-space.", nameof(connectionString));
}
connection = CreateConnection(rdbmsProvider, connectionString);
connection.Open();
if (useTransaction)
{
transaction = connection.BeginTransaction();
}
var ret = connection.Query <TFirst, TSecond, TThird, TFouth, TFifth, TSixth, TSeventh, TReturn>(sqlQuery, map, paramsObj, transaction, buffered, splitOn, commandTimeOut, commandType);
transaction?.Commit();
return(ret);
}
catch { throw; }
finally
{
connection.Dispose();
transaction?.Dispose();
}
}
public virtual async Task <T> GetAsync(int id, bool useTransaction = false, int?commandTimeout = null)
{
if (id == 0)
{
return(null);
}
IDbSession session = DbSession;
IDbTransaction transaction = null;
if (useTransaction)
{
session.BeginTrans();
transaction = session.Transaction;
}
try
{
var result = await session.Connection.GetAsync <T>(id, transaction, commandTimeout);
transaction?.Commit();
return(result);
}
finally
{
session.Dispose();
}
}
private T Execute <T>(Func <IDbConnection, IDbTransaction, T> func, bool beginTransaction = false, bool disposeConn = true)
{
IDbTransaction dbTransaction = null;
if (beginTransaction)
{
Connection.Open();
dbTransaction = Connection.BeginTransaction();
}
try
{
T reslutT = func(Connection, dbTransaction);
dbTransaction?.Commit();
return(reslutT);
}
catch (Exception ex)
{
dbTransaction?.Rollback();
Connection.Dispose();
throw ex;
}
finally
{
if (disposeConn)
{
Connection.Dispose();
}
}
}
private static async Task <int> DeleteAllAsync <T>(IDbCommand dbCmd, IEnumerable <T> objs, Func <object, Dictionary <string, object> > fieldValuesFn = null, CancellationToken token = default(CancellationToken))
{
IDbTransaction dbTrans = null;
int count = 0;
if (dbCmd.Transaction == null)
{
dbCmd.Transaction = dbTrans = dbCmd.Connection.BeginTransaction();
}
var dialectProvider = dbCmd.GetDialectProvider();
using (dbTrans)
{
foreach (var obj in objs)
{
var fieldValues = fieldValuesFn != null
? fieldValuesFn(obj)
: obj.AllFieldsMap <T>();
dialectProvider.PrepareParameterizedDeleteStatement <T>(dbCmd, fieldValues);
dialectProvider.SetParameterValues <T>(dbCmd, obj);
var rowsAffected = await dbCmd.ExecNonQueryAsync(token);
count += rowsAffected;
}
dbTrans?.Commit();
}
return(count);
}
public void Commit()
{
if(Connection.State != ConnectionState.Open)
Connection.Open();
_transaction = Connection.BeginTransaction();
try
{
// run updates
foreach (var command in _nonQueryActions)
{
command.Execute();
}
_transaction.Commit();
_nonQueryActions.Clear();
_transaction = null;
}
catch(Exception)
{
_transaction?.Rollback();
throw;
}
}
/// <summary>
/// Deletes all the target existing data from the database. It uses the <see cref="Delete{TEntity}(IDbConnection, QueryGroup, string, int?, IDbTransaction, ITrace, IStatementBuilder)"/> operation as the underlying operation.
/// </summary>
/// <typeparam name="TEntity">The type of the data entity.</typeparam>
/// <param name="connection">The connection object to be used.</param>
/// <param name="primaryKeys">The list of the primary keys to be deleted.</param>
/// <param name="hints">The table hints to be used.</param>
/// <param name="commandTimeout">The command timeout in seconds to be used.</param>
/// <param name="transaction">The transaction to be used.</param>
/// <param name="trace">The trace object to be used.</param>
/// <param name="statementBuilder">The statement builder object to be used.</param>
/// <returns>The number of rows affected by the execution.</returns>
public static int DeleteAll <TEntity>(this IDbConnection connection,
IEnumerable <object> primaryKeys,
string hints = null,
int?commandTimeout = null,
IDbTransaction transaction = null,
ITrace trace = null,
IStatementBuilder statementBuilder = null)
where TEntity : class
{
var primary = GetAndGuardPrimaryKey <TEntity>(connection, transaction);
var hasImplicitTransaction = false;
var count = primaryKeys?.AsList()?.Count;
var deletedRows = 0;
try
{
// Creates a transaction (if needed)
if (transaction == null && count > ParameterBatchCount)
{
transaction = connection.EnsureOpen().BeginTransaction();
hasImplicitTransaction = true;
}
// Call the underlying method
var splitted = primaryKeys.Split(ParameterBatchCount).AsList();
foreach (var keys in splitted)
{
if (keys.Any() != true)
{
break;
}
var field = new QueryField(primary.GetMappedName(), Operation.In, keys.AsList());
deletedRows += DeleteInternal <TEntity>(connection: connection,
where : new QueryGroup(field),
hints: hints,
commandTimeout: commandTimeout,
transaction: transaction,
trace: trace,
statementBuilder: statementBuilder);
}
// Commit the transaction
if (hasImplicitTransaction)
{
transaction?.Commit();
}
}
finally
{
// Dispose the transaction
if (hasImplicitTransaction)
{
transaction?.Dispose();
}
}
// Return the value
return(deletedRows);
}
private static void CommitTransaction(IDbTransaction transaction,
bool hasTransaction)
{
if (hasTransaction == false)
{
transaction?.Commit();
}
}
/// <summary>
/// 提交数据库的事务
/// </summary>
public void CommitTransaction()
{
if (--_transCounter == 0)
{
_trans?.Commit();
_trans?.Dispose();
_trans = null;
}
}
public void CommitTransaction()
{
_transaction?.Commit();
_transaction?.Dispose(); ////TODO CHECK
//_transaction = null;
_connection?.Close();
_connection?.Dispose();
//_connection = null;
}
public void commit()
{
if (_dbTransaction == null)
{
throw new Exception("Cannot commit transaction. Transaction is not begun");
}
_dbTransaction?.Commit();
_dbTransaction = null;
}
/// <summary>
/// 更新
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="sql">更新SQL语句</param>
/// <param name="transaction">事务</param>
public static async Task UpdateAsync(this IDbConnection connection, string sql, IDbTransaction transaction = null)
{
connection.Open();
await connection.ExecuteAsync(sql, null, transaction);
transaction?.Commit();
connection.Close();
}
private void CommitTransaction()
{
if (_transaction == null)
{
return;
}
_transaction?.Commit();
_transaction = null;
OpenTransaction();
}
public void Commit()
{
try
{
transaction?.Commit();
}
catch
{
transaction?.Rollback();
throw;
}
}
private void BtnDelete_Click(object sender, RoutedEventArgs e)
{
if (DGMain.SelectedItems.Count == 0)
{
MessageBox.Show("请选中一条数据");
return;
}
else
{
if (MessageBox.Show("是否确认删除？对应的套料信息和工序监控任务都可能被删除", "警告", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
{
List <StationCache> list = new List <StationCache>();
List <StepTrace> steptrace = new List <StepTrace>();
CutPlan cutplan = new CutPlan();
foreach (var item in DGMain.SelectedItems)
{
list.Add((StationCache)item);
}
var ids = list.Select(t => t.Id.Value).ToList();
var stationcachesResult = AppSession.Dal.GetCommonModelByCondition <StationCache>($" where id in ({string.Join(",", ids)})");
if (!stationcachesResult.Success)
{
MessageBox.Show("管材缓存信息不存在！");
}
var stepTraceIds = stationcachesResult.Data.Where(t => t.stepTraceId != null).Select(t => t.stepTraceId).ToList();
using (IDbConnection connection = AppSession.Dal.GetConnection())
{
IDbTransaction tran = null;
try
{
connection.Open();
tran = connection.BeginTransaction();
connection.DeleteList <CutPlan>("where stationCacheId in @stationCacheIds", new { stationCacheIds = ids }, tran);
if (stepTraceIds.Count > 0)
{
connection.DeleteList <StepTrace>("where id in @ids", new { ids = stepTraceIds }, tran);
}
connection.DeleteList <StationCache>("where id in @ids", new { ids = ids }, tran);
tran?.Commit();
}
catch (Exception ex)
{
tran?.Rollback();
Logger.Log($"删除管材缓存的数据候发生异常，原因：{ex.Message}", LogLevel.Exception, ex);
MessageBox.Show("删除失败");
}
}
Query();
}
}
}
private void BtnDelete_Click(object sender, RoutedEventArgs e)
{
if (DGMain.SelectedItems.Count == 0)
{
MessageBox.Show("请至少选中一条数据！");
}
else
{
if (MessageBox.Show("是否确认删除？这可能导致程序异常！", "警告", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
{
List <PipeOrder> list = new List <PipeOrder>();
var statusresult = AppSession.Dal.GetCommonModelByConditionWithZero <PipeOrder>($"where status ={StationCacheStatus.已经套料.GetIndexInt()}").Data;
foreach (var item in DGMain.SelectedItems)
{
var order = (PipeOrder)item;
list.Add(order);
foreach (var statusid in statusresult)
{
if (statusid.Id == order.Id)
{
MessageBox.Show($"选中的工单ID为：{ order.Id}的状态有已经套料过的工单！请重选");
return;
}
}
}
var ids = list.Select(t => t.Id.Value).ToList();
var wonNumber = list.Select(t => t.Code).ToList();//cf
using (IDbConnection connection = AppSession.Dal.GetConnection())
{
IDbTransaction tran = null;
try
{
connection.Open();
tran = connection.BeginTransaction();
//$"where WONumber = '{CurrentPipeOrder.Code}'"
connection.DeleteList <CutPlan>("where WONumber in @WONumbers", new { WONumbers = wonNumber }, tran);
connection.DeleteList <PipeOrder>("where id in @ids", new { ids = ids }, tran);
tran?.Commit();
}
catch (Exception ex)
{
tran?.Rollback();
Logger.Log($"删除工单的数据候发生异常，原因：{ex.Message}", LogLevel.Exception, ex);
MessageBox.Show("删除失败");
}
}
Query();
}
}
}
/// <summary>
/// 更新
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <param name="connection">数据库连接</param>
/// <param name="updates">更新的字段</param>
/// <param name="where">更新条件</param>
/// <param name="transaction">事务</param>
public static async Task UpdateAsync <TEntity>(this IDbConnection connection, IDictionary <string, object> updates, string where, IDbTransaction transaction = null)
where TEntity : class, new()
{
string sql = BuildUpdateSql <TEntity>(updates, where);
connection.Open();
await connection.ExecuteAsync(sql, null, transaction);
transaction?.Commit();
connection.Close();
}
/// <summary>
/// Commits all changes made by consumers of the DbTransaction within a single operation.
/// </summary>
/// <exception cref="RepositoryException">Thrown when there is an error when trying to commit the database transaction</exception>
public void Commit()
{
try
{
_dbTransaction?.Commit();
}
catch (Exception e)
{
_dbTransaction?.Rollback();
throw new RepositoryException(e.Message, e);
}
}
public void Transpor()
{
conexão = ObterConexãoAberta();
transação = conexão.BeginTransaction();
Dictionary<string, bool> referências = ObterHashExisteReferência();
ApagaFornecedores();
CadastrarFornecedores(ObtemLegadoFornecedoresParaCadastrar());
CadastrarVínculos();
SobrescreveInicio(referências);
transação.Commit();
conexão.Close();
}
internal static int UpdateAll <T>(this IDbCommand dbCmd, IEnumerable <T> objs, Action <IDbCommand> commandFilter = null)
{
OrmLiteUtils.AssertNotAnonType <T>();
IDbTransaction dbTrans = null;
int count = 0;
try
{
if (dbCmd.Transaction == null)
{
dbCmd.Transaction = dbTrans = dbCmd.Connection.BeginTransaction();
}
var dialectProvider = dbCmd.GetDialectProvider();
var hadRowVersion = dialectProvider.PrepareParameterizedUpdateStatement <T>(dbCmd);
if (string.IsNullOrEmpty(dbCmd.CommandText))
{
return(0);
}
foreach (var obj in objs)
{
OrmLiteConfig.UpdateFilter?.Invoke(dbCmd, obj);
dialectProvider.SetParameterValues <T>(dbCmd, obj);
commandFilter?.Invoke(dbCmd); //filters can augment SQL & only should be invoked once
commandFilter = null;
var rowsUpdated = dbCmd.ExecNonQuery();
if (hadRowVersion && rowsUpdated == 0)
{
throw new OptimisticConcurrencyException();
}
count += rowsUpdated;
}
dbTrans?.Commit();
}
finally
{
dbTrans?.Dispose();
}
return(count);
}
static void CommitTransaction(IDbTransaction tran)
{
tran.Commit();
}
public DataTable ExecuteSql(string query)
{
_Connection.Open();
_Transaction = _Driver.BeginTransaction(_Connection);
IDbCommand cmd = _Driver.CreateCommand(query, _Connection, _Transaction);
if (TraceSqlSwitch.Enabled)
{
TraceHelpler.Trace(cmd, _Dialect);
}
DataTable result = new DataTable();
using (IDataReader reader = cmd.ExecuteReader())
{
result.Load(reader);
}
_Transaction.Commit();
_Connection.Close();
return result;
}
/// <summary>
/// Creates the queue and history records for the given schedule.
/// </summary>
/// <param name="scheduleId">The ID of the schedule records are being created for.</param>
/// <param name="scheduleDate">The schedule date records are being created for.</param>
/// <param name="queued">The queued records to create.</param>
/// <param name="history">The history records to create.</param>
/// <param name="transaction">The transaction to use, if applicable.</param>
/// <returns>The number of records created.</returns>
public int CreateQueuedAndHistoryForSchedule(long scheduleId, DateTime scheduleDate, IEnumerable<QueueRecord> queued, IEnumerable<HistoryRecord> history, IDbTransaction transaction)
{
int created = 0;
bool commitRollback = false;
if (transaction == null)
{
commitRollback = true;
transaction = this.BeginTransaction();
}
try
{
const string InsertQueuedSql =
@"INSERT INTO [BlueCollarQueue]([ApplicationName],[ScheduleId],[QueueName],[JobName],[JobType],[Data],[QueuedOn],[TryNumber])
VALUES(@ApplicationName,@ScheduleId,@QueueName,@JobName,@JobType,@Data,@QueuedOn,@TryNumber);";
const string InsertHistorySql =
@"INSERT INTO [BlueCollarHistory]([ApplicationName],[WorkerId],[ScheduleId],[QueueName],[JobName],[JobType],[Data],[QueuedOn],[TryNumber],[StartedOn],[Status],[Exception],[FinishedOn])
VALUES (@ApplicationName,@WorkerId,@ScheduleId,@QueueName,@JobName,@JobType,@Data,@QueuedOn,@TryNumber,@StartedOn,@StatusString,@Exception,@FinishedOn);";
if (queued != null && queued.Count() > 0)
{
created += this.connection.Execute(InsertQueuedSql, queued, transaction, null, null);
}
if (history != null && history.Count() > 0)
{
created += this.connection.Execute(InsertHistorySql, history, transaction, null, null);
}
if (commitRollback)
{
transaction.Commit();
}
}
catch
{
if (commitRollback)
{
transaction.Rollback();
}
throw;
}
finally
{
if (commitRollback)
{
transaction.Dispose();
}
}
return created;
}
public static object f_调用读取单一对象(IDbTransaction st, String sql, IDbDataParameter[] sp, CommandType commaneType, bool AllComplete)
{
if (st == null)
{
throw new Exception("本方法调用需要传入一个有效的事务，本次调用传入事务为Null");
}
try
{
object returnvalue = null;
if (GetDBType(st.Connection.ConnectionString) == OperationDBType.OLEDB)
{
throw new Exception("NESCBB.DataLayer：OLEDB不提供单一对象提取方法。");
}
else if (GetDBType(st.Connection.ConnectionString) == OperationDBType.SQL)
{
returnvalue = DataLayer.Core.SqlHelper.ExecuteScalar((SqlTransaction)st, commaneType, sql, (SqlParameter[])sp);
}
if (AllComplete)
{
IDbConnection myconn = st.Connection;
st.Commit();
if (myconn != null)
{
if (myconn.State != ConnectionState.Closed)
{
myconn.Close();
myconn.Dispose();
}
}
}
return returnvalue;
}
catch (Exception err)
{
IDbConnection myconn = st.Connection;
st.Rollback();
if (myconn != null)
{
if (myconn.State != ConnectionState.Closed)
{
myconn.Close();
myconn.Dispose();
}
}
throw new Exception(NESCBB.ExpressionHelper.c_错误信息类.f_Sql错误处理(err));
}
}
private void CommitTransaction(IDbTransaction trans)
{
if (trans == null) return;
trans.Commit();
}
/// <summary>
/// Executes a collection of sql commands that returns no result set
/// and takes no parameters, using the provided connection.
/// This method can be used effectively where the database vendor
/// supports the execution of several sql statements in one
/// ExecuteNonQuery. However, for database vendors like Microsoft
/// Access and MySql, the sql statements will need to be split up
/// and executed as separate transactions.
/// </summary>
/// <param name="statements">A valid sql statement object (typically "insert",
/// "update" or "delete"). Note_ that this assumes that the
/// sqlCommand is not a stored procedure.</param>
/// <param name="transaction">A valid transaction object in which the
/// sql must be executed, or null</param>
/// <returns>Returns the number of rows affected</returns>
/// <exception cref="DatabaseWriteException">Thrown if there is an
/// error writing to the database. Also outputs error messages to the log.
/// </exception>
/// <future>
/// In future override this method with methods that allow you to
/// pass in stored procedures and parameters.
/// </future>
public virtual int ExecuteSql(IEnumerable<ISqlStatement> statements, IDbTransaction transaction)
{
var inTransaction = false;
ArgumentValidationHelper.CheckArgumentNotNull(statements, "statements");
IDbConnection con = null;
try
{
IDbCommand cmd;
if (transaction != null)
{
inTransaction = true;
con = transaction.Connection;
if (con.State != ConnectionState.Open)
{
con.Open();
}
cmd = CreateCommand(con);
cmd.Transaction = transaction;
}
else
{
con = OpenConnection;
cmd = CreateCommand(con);
transaction = con.BeginTransaction();
cmd.Transaction = transaction;
}
var totalRowsAffected = 0;
foreach (SqlStatement statement in statements)
{
statement.SetupCommand(cmd);
try
{
totalRowsAffected += cmd.ExecuteNonQuery();
}
catch (Exception ex)
{
throw new DatabaseWriteException
("There was an error executing the statement : " + Environment.NewLine + cmd.CommandText, ex);
}
statement.DoAfterExecute(this, transaction, cmd);
}
if (!inTransaction)
{
transaction.Commit();
}
return totalRowsAffected;
}
catch (Exception ex)
{
Log.Log
("Error writing to database : " + Environment.NewLine
+ ExceptionUtilities.GetExceptionString(ex, 10, true), LogCategory.Exception);
Log.Log("Sql: " + statements, LogCategory.Exception);
if (transaction != null)
{
transaction.Rollback();
}
throw new DatabaseWriteException
("There was an error writing to the database. Please contact your system administrator."
+ Environment.NewLine + "The command executeNonQuery could not be completed. :" + statements,
"The command executeNonQuery could not be completed.", ex, statements.ToString(), ErrorSafeConnectString());
}
finally
{
if (!inTransaction)
{
if (con != null && con.State != ConnectionState.Closed)
{
con.Close();
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
public void Commit(IDbTransaction transaction)
{
try
{
command.Transaction = (NpgsqlTransaction)transaction;
transaction.Commit();
}
catch (Exception ex)
{
Exception wrappedEx = new Exception(ErrorManager.AddLayer(ex, RunningClass.GetName(this), RunningClass.GetMethod()));
throw wrappedEx;
}
}
/// <summary>
/// The execute.
/// </summary>
/// <param name="dbfunctionType">
/// The dbfunction type.
/// </param>
/// <param name="operationName">
/// The operation name.
/// </param>
/// <param name="parameters">
/// The parameters.
/// </param>
/// <param name="result">
/// The result.
/// </param>
/// <param name="transaction"></param>
/// <returns>
/// The execute.
/// </returns>
public virtual bool Execute(
DbFunctionType dbfunctionType,
[NotNull] string operationName,
[NotNull] IEnumerable<KeyValuePair<string, object>> parameters,
[CanBeNull] out object result,
IDbTransaction transaction = null)
{
if (this.IsSupportedOperation(operationName))
{
this._sqlMessages.Clear();
bool createdTransaction = transaction == null;
try
{
if (transaction == null)
{
transaction = this.DbAccess.BeginTransaction();
}
if (transaction.Connection is SqlConnection)
{
var sqlConnection = transaction.Connection as SqlConnection;
sqlConnection.FireInfoMessageEventOnUserErrors = true;
sqlConnection.InfoMessage += new SqlInfoMessageEventHandler(this.sqlConnection_InfoMessage);
var operationSuccessful = this.RunOperation(sqlConnection, transaction, dbfunctionType, operationName, parameters, out result);
if (createdTransaction && operationSuccessful)
{
transaction.Commit();
}
return operationSuccessful;
}
}
finally
{
if (createdTransaction && transaction != null)
{
transaction.Dispose();
}
}
}
result = null;
return false;
}
public void Execute ()
{
SessionFactoryFactory.CreateIndexes(memConn);
transaction.Commit();
if(String.IsNullOrEmpty(diskFilepath))
return;
lock (ioMutex)
{
if (!File.Exists(diskFilepath))
{
(memConn as System.Data.SQLite.SQLiteConnection).SaveToDisk(diskFilepath);
}
else
{
memConn.ExecuteNonQuery("ATTACH DATABASE '" + diskFilepath.Replace("'", "''") + "' AS disk");
memConn.ExecuteNonQuery("PRAGMA disk.journal_mode=OFF; PRAGMA disk.synchronous=OFF;");
transaction = memConn.BeginTransaction();
memConn.ExecuteNonQuery("INSERT INTO disk.Protein SELECT * FROM Protein");
memConn.ExecuteNonQuery("INSERT INTO disk.ProteinMetadata SELECT * FROM ProteinMetadata");
memConn.ExecuteNonQuery("INSERT INTO disk.ProteinData SELECT * FROM ProteinData");
memConn.ExecuteNonQuery("INSERT INTO disk.Peptide SELECT * FROM Peptide");
memConn.ExecuteNonQuery("INSERT INTO disk.PeptideSequences SELECT * FROM PeptideSequences");
memConn.ExecuteNonQuery("INSERT INTO disk.PeptideInstance SELECT * FROM PeptideInstance");
memConn.ExecuteNonQuery("INSERT INTO disk.SpectrumSourceGroup SELECT * FROM SpectrumSourceGroup");
memConn.ExecuteNonQuery("INSERT INTO disk.SpectrumSource SELECT * FROM SpectrumSource");
memConn.ExecuteNonQuery("INSERT INTO disk.SpectrumSourceMetadata SELECT * FROM SpectrumSourceMetadata");
memConn.ExecuteNonQuery("INSERT INTO disk.SpectrumSourceGroupLink SELECT * FROM SpectrumSourceGroupLink");
memConn.ExecuteNonQuery("INSERT INTO disk.Spectrum SELECT * FROM Spectrum");
memConn.ExecuteNonQuery("INSERT INTO disk.Analysis SELECT * FROM Analysis");
memConn.ExecuteNonQuery("INSERT INTO disk.AnalysisParameter SELECT * FROM AnalysisParameter");
memConn.ExecuteNonQuery("INSERT INTO disk.PeptideSpectrumMatch SELECT * FROM PeptideSpectrumMatch");
memConn.ExecuteNonQuery("INSERT INTO disk.PeptideSpectrumMatchScoreName SELECT * FROM PeptideSpectrumMatchScoreName");
memConn.ExecuteNonQuery("INSERT INTO disk.PeptideSpectrumMatchScore SELECT * FROM PeptideSpectrumMatchScore");
memConn.ExecuteNonQuery("INSERT INTO disk.Modification SELECT * FROM Modification");
memConn.ExecuteNonQuery("INSERT INTO disk.PeptideModification SELECT * FROM PeptideModification");
memConn.ExecuteNonQuery("INSERT OR IGNORE INTO disk.IntegerSet SELECT * FROM IntegerSet");
memConn.ExecuteNonQuery("INSERT INTO disk.QonverterSettings SELECT * FROM QonverterSettings");
/*foreach (var itr in insertCommandByTable)
{
IDbCommand cmd = itr.Key;
foreach (var row in itr.Value)
{
setParameters(cmd, row);
cmd.ExecuteNonQuery();
}
}*/
transaction.Commit();
memConn.ExecuteNonQuery("DETACH DATABASE disk");
}
}
}
/// <summary>
/// Executes a collection of sql commands that returns no result set
/// and takes no parameters, using the provided connection.
/// This method can be used effectively where the database vendor
/// supports the execution of several sql statements in one
/// ExecuteNonQuery. However, for database vendors like Microsoft
/// Access and MySql, the sql statements will need to be split up
/// and executed as separate transactions.
/// </summary>
/// <param name="statements">A valid sql statement object (typically "insert",
/// "update" or "delete"). Note_ that this assumes that the
/// sqlCommand is not a stored procedure.</param>
/// <param name="transaction">A valid transaction object in which the
/// sql must be executed, or null</param>
/// <returns>Returns the number of rows affected</returns>
/// <exception cref="DatabaseWriteException">Thrown if there is an
/// error writing to the database. Also outputs error messages to the log.
/// </exception>
/// <future>
/// In future override this method with methods that allow you to
/// pass in stored procedures and parameters.
/// </future>
public virtual int ExecuteSql(IEnumerable<ISqlStatement> statements, IDbTransaction transaction)
{
var inTransaction = transaction != null;
ArgumentValidationHelper.CheckArgumentNotNull(statements, "statements");
IDbConnection con = null;
try
{
con = GetOpenConnection(transaction);
if (transaction == null)
{
transaction = BeginTransaction(con);
}
var totalRowsAffected = ExecuteSqlInternal(statements, con, transaction);
if (!inTransaction)
{
transaction.Commit();
}
return totalRowsAffected;
}
catch (Exception ex)
{
Log.Log
("Error writing to database : " + Environment.NewLine
+ ExceptionUtilities.GetExceptionString(ex, 10, true), LogCategory.Exception);
Log.Log("Sql: " + statements, LogCategory.Exception);
if (transaction != null)
{
transaction.Rollback();
}
throw new DatabaseWriteException
("There was an error writing to the database. Please contact your system administrator."
+ Environment.NewLine + "The command executeNonQuery could not be completed. :" + statements,
"The command executeNonQuery could not be completed.", ex, statements.ToString(), ErrorSafeConnectString());
}
finally
{
if (!inTransaction)
{
if (con != null && con.State != ConnectionState.Closed)
{
con.Close();
}
}
}
}
/// <summary>
/// Commits changes to the database
/// </summary>
/// <param name="transaction">Database Transcation to be committed</param>
public void CommitTransaction(IDbTransaction transaction)
{
try
{
transaction.Commit();
}
catch (Exception err)
{
throw err;
}
}
/// <summary>
/// Закрыть транзакцию
/// </summary>
/// <param name="transaction"></param>
public static void СommitTransaction(IDbTransaction transaction) {
if (transaction != null) {
var v_storedConn = transaction.Connection;
transaction.Commit();
transaction.Dispose();
if (v_storedConn != null) {
v_storedConn.Close();
v_storedConn.Dispose();
}
}
}
public override void ProcessCommands(Transaction tx)
{
_CommandProcessor = new SqlMapperCommandProcessor(this);
_Connection.Open();
_Transaction = Driver.BeginTransaction(_Connection);
_CommandProcessor.Transaction = _Transaction;
try
{
foreach (Command cmd in tx.PendingCommands)
{
cmd.Accept(_CommandProcessor);
tx.NewIds = new Hashtable();
foreach (string oldid in _CommandProcessor.NewIds.Keys)
tx.NewIds.Add(oldid, _CommandProcessor.NewIds[oldid]);
}
_CommandProcessor.EnableForeignKeys();
_Transaction.Commit();
}
catch
{
_Transaction.Rollback();
throw;
}
finally
{
_Connection.Close();
}
}
public override void InitializeRepository()
{
base.InitializeRepository();
if (_InitCommands == null)
CreateInitCommands();
if (_Connection.State != ConnectionState.Open)
{
_Connection.Open();
}
try
{
foreach (ISQLExpression expression in _InitCommands)
{
IDbCommand cmd = null;
CreateTableSQLCommand ctCommand = expression as CreateTableSQLCommand;
if (ctCommand != null)
{
DropTableSQLCommand delete_query = new DropTableSQLCommand(ctCommand.TagMapping, ctCommand.TableName);
foreach (string sql in _Dialect.RenderQueries(delete_query, _Driver))
{
try
{
_Transaction = _Connection.BeginTransaction();
cmd = _Driver.CreateCommand(sql, _Connection, _Transaction);
if (TraceSqlSwitch.Enabled)
{
TraceHelpler.Trace(cmd, _Dialect);
}
cmd.ExecuteNonQuery();
_Transaction.Commit();
}
catch (Exception e)
{
_Transaction.Rollback();
System.Diagnostics.Trace.WriteLine(e.Message + " on:\n" + sql);
}
}
foreach (string sql in _Dialect.RenderQueries(ctCommand, _Driver))
{
try
{
_Transaction = _Connection.BeginTransaction();
cmd = _Driver.CreateCommand(sql, _Connection, _Transaction);
if (TraceSqlSwitch.Enabled)
{
TraceHelpler.Trace(cmd, _Dialect);
}
cmd.ExecuteNonQuery();
_Transaction.Commit();
}
catch (Exception e)
{
_Transaction.Rollback();
System.Diagnostics.Trace.WriteLine(e.Message + " on:\n" + sql);
}
}
}
AlterTableSQLCommand atCommand = expression as AlterTableSQLCommand;
if (atCommand != null)
{
foreach (string sql in _Dialect.RenderQueries(atCommand, _Driver))
{
try
{
_Transaction = _Connection.BeginTransaction();
cmd = _Driver.CreateCommand(sql, _Connection, _Transaction);
if (TraceSqlSwitch.Enabled)
{
TraceHelpler.Trace(cmd, _Dialect);
}
cmd.ExecuteNonQuery();
_Transaction.Commit();
}
catch (Exception e)
{
_Transaction.Rollback();
System.Diagnostics.Trace.WriteLine(e.Message + " on:\n" + sql);
// Dropping a constraint might fail during InitializeRepository if it doesn't exist
}
}
}
}
}
finally
{
_Connection.Close();
}
}
private void CommitTransaction(IDbTransaction tran)
{
tran.Commit();
instrumentation.TransactionCommitted();
}
public static int ExecuteNonQuery(IDbTransaction st, String sql, IDbDataParameter[] sp, CommandType commaneType, bool AllComplete)
{
if (st == null)
{
throw new Exception("本方法调用需要传入一个有效的事务，本次调用传入事务为Null");
}
try
{
int returnvalue = 0;
if (GetDBType(st.Connection.ConnectionString) == OperationDBType.SQLLite)
{
returnvalue = SqliteHelper.ExecuteNonQuery((SqliteTransaction)st, commaneType, sql, (SqliteParameter[])sp);
}
else if (GetDBType(st.Connection.ConnectionString) == OperationDBType.SQL)
{
returnvalue = SqlHelper.ExecuteNonQuery((SqlTransaction)st, commaneType, sql, (SqlParameter[])sp);
}
if (AllComplete)
{
IDbConnection myconn = st.Connection;
st.Commit();
if (myconn != null)
{
if (myconn.State != ConnectionState.Closed)
{
myconn.Close();
myconn.Dispose();
}
}
}
return returnvalue;
}
catch (Exception err)
{
IDbConnection myconn = st.Connection;
st.Rollback();
if (myconn != null)
{
if (myconn.State != ConnectionState.Closed)
{
myconn.Close();
myconn.Dispose();
}
}
throw new Exception(CBB.ExceptionHelper.ExpressionPaser.ErrTrim(err));
}
}
public static int f_调用无反回(IDbTransaction st, String sql, bool AllComplete)
{
if (st == null)
{
throw new Exception("本方法调用需要传入一个有效的事务，本次调用传入事务为Null");
}
try
{
int returnvalue=0;
if (GetDBType(st.Connection.ConnectionString) == OperationDBType.OLEDB)
{
returnvalue = DataLayer.Core.OleDbHelper.ExecuteNonQuery((OleDbTransaction)st, CommandType.Text, sql);
}
else if (GetDBType(st.Connection.ConnectionString) == OperationDBType.SQL)
{
returnvalue = DataLayer.Core.SqlHelper.ExecuteNonQuery((SqlTransaction)st, CommandType.Text, sql);
}
if (AllComplete)
{
IDbConnection myconn = st.Connection;
st.Commit();
if (myconn != null)
{
if (myconn.State != ConnectionState.Closed)
{
myconn.Close();
myconn.Dispose();
}
}
}
return returnvalue;
}
catch (Exception err)
{
IDbConnection myconn = st.Connection;
st.Rollback();
if (myconn != null)
{
if (myconn.State != ConnectionState.Closed)
{
myconn.Close();
myconn.Dispose();
}
}
throw new Exception(NESCBB.ExpressionHelper.c_错误信息类.f_Sql错误处理(err));
}
}
public override object LoadScalar(OPath.OPathQuery query)
{
if (query.QueryType == OPathQueryTypeEnum.Path)
{
query.QueryType = OPathQueryTypeEnum.Expression;
query.Expression = new OPath.Expressions.Call("eval", new Evaluant.OPath.Expressions.Collections.ConstraintCollection(new OPath.Expressions.Constraint[] { query.Path }));
}
SqlMapperTransformer transformer = new SqlMapperTransformer(_Mapping, _Model);
transformer.Dialect = Dialect;
ISQLExpression exp = transformer.TransformScalar(query);
_Connection.Open();
_Transaction = _Connection.BeginTransaction();
object result = null;
try
{
string[] queries = Dialect.RenderQueries(exp);
IDbCommand command = Driver.CreateCommand(queries[queries.Length - 1], _Connection, _Transaction);
if (TraceSqlSwitch.Enabled)
{
TraceHelpler.Trace(command, _Dialect);
}
object res = command.ExecuteScalar();
if (res != DBNull.Value)
result = res;
_Transaction.Commit();
}
catch
{
_Transaction.Rollback();
throw;
}
finally
{
_Connection.Close();
}
// Ensure the result in an Int32 in case of a count()
if (query.Expression.Operands[0] is OPath.Expressions.Function
&& ((OPath.Expressions.Function)query.Expression.Operands[0]).Type == Evaluant.OPath.Expressions.FunctionEnum.Count)
result = Convert.ToInt32(result);
return result;
}
public void EndUpdate(IDbTransaction trans)
{
trans.Commit();
trans.Dispose();
m_conn.Close();
m_conn = null;
}
public override void LoadReference(IEnumerable entities, string[] references)
{
// references = null => don't load references
if (references == null)
return;
// Group entities by type
Hashtable orderedEntities = new Hashtable();
foreach (Entity e in entities)
{
if (!orderedEntities.ContainsKey(e.Type))
orderedEntities.Add(e.Type, new EntitySet());
((EntitySet)orderedEntities[e.Type]).Add(e);
e.RemoveReference(references);
}
// Process each entity by type
foreach (string entityType in orderedEntities.Keys)
{
Hashtable entityIndex = new Hashtable();
foreach (Entity entity in ((EntitySet)orderedEntities[entityType]))
entityIndex.Add(entity.Id, entity);
string[] ids = new string[((EntitySet)orderedEntities[entityType]).Count];
int i = 0;
foreach (Entity e in (EntitySet)orderedEntities[entityType])
ids[i++] = e.Id;
string id = String.Join("', '", ids);
Hashtable refs = GetReferenceMappings(entityType, references);
// Process each reference of the current entity type
foreach (string refName in refs.Keys)
{
ReferenceMapping rm = (ReferenceMapping)refs[refName];
Evaluant.Uss.Models.Reference referenceModel =
_Model.GetReference(rm.EntityParent.Type, refName.Substring(refName.LastIndexOf('.') + 1), true);
if (_Mapping.Entities[referenceModel.ParentType] == null)
referenceModel = new Evaluant.Uss.Models.Reference(referenceModel.Name, entityType, referenceModel.ChildType, referenceModel.IsComposition, referenceModel.FromMany, referenceModel.ToMany);
string parentType = entityType;
string opath = String.Concat(parentType, "[ id( '", id, "' ) ].", refName);
OPathQuery opathQuery = new OPathQuery(opath);
opathQuery.Compile();
if (opathQuery.HasErrors)
throw new OPathException(opathQuery);
SqlMapperTransformer transformer = new SqlMapperTransformer(_Mapping, _Model);
transformer.Dialect = _Dialect;
string childType = referenceModel.ChildType;
//StringCollection attributes = new StringCollection();
//if(_Model.GetEntity(rm.EntityChild) != null)
// attributes = GetInheritedAttributes(rm.EntityChild);
//string[] atts = new string[attributes.Count];
//for(i = 0; i < attributes.Count; i++)
// atts[i] = attributes[i];
string[] atts = new string[0];
UnionStatement exp = (UnionStatement)transformer.TransformToSql(opathQuery.Path, atts, new string[] { }, false);
// ToDo : Add expression for children types
IList childrenSubTypes = _Model.GetTree(childType);
foreach (SelectStatement select in exp.SelectExpressions)
{
EntityMapping entityChild = _Mapping.Entities[referenceModel.ChildType];
// Insert the ParentId field in case of generic reference mapping
// Then, we can add the OrderBy clause
for (int pmkIndex = 0; pmkIndex < rm.EntityParent.Ids.Count; pmkIndex++)
{
PrimaryKeyMapping pkm = rm.EntityParent.Ids[pmkIndex];
string parentIdAlias = SqlMapperTransformer.GetParentIdAlias(rm.EntityParent, pkm.Field);
if (!FieldExists(select.SelectList, parentIdAlias))
select.SelectList.Insert(2 + pmkIndex, new Column(pkm, select.TableAlias, parentIdAlias, parentIdAlias));
}
}
if (rm.OrderBy != null && rm.OrderBy != string.Empty)
{
exp.OrderByClause = new OrderByClause(exp);
string[] orderbies = rm.OrderBy.Split(',');
foreach (string orderby in orderbies)
{
string[] orderbyDirection = orderby.Split(' ');
if (orderbyDirection.Length == 1)
exp.OrderByClause.Add(new OrderByClauseColumn(orderbyDirection[0]));
else
exp.OrderByClause.Add(new OrderByClauseColumn(orderbyDirection[0], orderbyDirection[1].ToLower() == "desc"));
}
}
exp.SelectedAllColumns = true;
exp.TableAlias = "q";
_Connection.Open();
_Transaction = _Connection.BeginTransaction();
try
{
foreach (string q in _Dialect.RenderQueries(exp, Driver))
{
IDbCommand command = _Driver.CreateCommand(q, _Connection, _Transaction);
if (TraceSqlSwitch.Enabled)
{
TraceHelpler.Trace(command, _Dialect);
}
using (IDataReader reader = command.ExecuteReader())
{
EntityMapping entityChild = _Mapping.Entities[referenceModel.ChildType];
EntityMapping baseEntityChild = entityChild;
string parentId = String.Empty;
string refId = null; //String.Empty; Empty string can be the value
Entity parentEntity = null, reference = null;
while (reader.Read())
{
string trueType = reader[SqlMapperTransformer.TYPE_ALIAS].ToString();
if (baseEntityChild == null || baseEntityChild.Type != trueType)
entityChild = _Mapping.Entities[trueType];
if (entityChild == null)
throw new MappingNotFoundException(string.Format("The entity [{0}] could not be found the mapping", trueType));
int nbParentIds = _Mapping.Entities[referenceModel.ParentType].Ids.Count;
string[] newParentIds = new string[nbParentIds];
for (int indexId = 0; indexId < nbParentIds; indexId++)
newParentIds[indexId] = reader.GetValue(reader.GetOrdinal("ParentId" + (nbParentIds == 1 ? "" : indexId.ToString()))).ToString().Trim();
string newParentId = string.Join(SqlMapperProvider.IDSEP.ToString(), newParentIds);
int nbChildIds = entityChild.Ids.Count;
string[] newChildIds = new string[nbChildIds];
for (int indexId = 0; indexId < nbChildIds; indexId++)
{
if (entityChild.Ids[indexId].Generator.Name == Evaluant.Uss.SqlMapper.GeneratorMapping.GeneratorType.business)
newChildIds[indexId] = reader[entityChild.GetIdFieldAs(entityChild.Ids[indexId])].ToString().Trim();
else
newChildIds[indexId] = reader.GetValue(1 + nbParentIds + indexId).ToString().Trim();
}
string newReferenceId = string.Join(SqlMapperProvider.IDSEP.ToString(), newChildIds);
// Go the next parent
if (parentId != newParentId)
{
if (parentEntity != null)
parentEntity.State = State.UpToDate;
parentId = newParentId;
parentEntity = entityIndex[parentId] as Entity;
refId = null; //String.Empty; Empty string can be the value
}
// Create a new reference
if (refId != newReferenceId)
{
if (reference != null)
reference.State = State.UpToDate;
reference = new Entity(entityChild.Type);
refId = newReferenceId;
reference.Id = refId;
parentEntity.AddValue(refName, reference, State.UpToDate);
}
ImportAttributes(reader, new string[] { }, _Mapping.Entities[reference.Type], reference, transformer.ColumnAliasMapping);
entityChild = baseEntityChild;
}
if (parentEntity != null)
parentEntity.State = State.UpToDate;
if (reference != null)
reference.State = State.UpToDate;
// mark the reference as loaded for each parentEntity
foreach (Entity e in entities)
if (!e.InferredReferences.Contains(refName))
e.InferredReferences.Add(refName);
}
}
_Transaction.Commit();
}
catch (Exception e)
{
_Transaction.Rollback();
throw e;
}
finally
{
_Connection.Close();
}
}
}
}
public EntitySet LoadWithSql(ISQLExpression query, string[] attributes, Hashtable columnAliasMapping, bool loadReference)
{
EntitySet es = new EntitySet();
_Connection.Open();
_Transaction = _Driver.BeginTransaction(_Connection);
#if !DEBUG
try
{
#endif
foreach (string sql in _Dialect.RenderQueries(query, Driver))
{
es = LoadSql(sql, attributes, columnAliasMapping, loadReference);
}
_Transaction.Commit();
#if !DEBUG
}
catch (Exception e)
{
_Transaction.Rollback();
throw e;
}
finally
{
#endif
_Connection.Close();
#if !DEBUG
}
#endif
return es;
}
/// <summary>
/// Attempts to obtain the enqueueing lock for the given schedule ID.
/// </summary>
/// <param name="scheduleId">The ID of the schedule to obtain the schedule enqueueing lock for.</param>
/// <param name="forceIfOlderThan">A date to compare the enqueue lock's last updated date with. If
/// the lock is older than the given date, then it will be forced and acquired by the caller.</param>
/// <param name="transaction">The transaction to use, if applicable.</param>
/// <returns>True if the enqueueing lock was obtained, false otherwise.</returns>
public bool GetScheduleEnqueueingLock(long scheduleId, DateTime forceIfOlderThan, IDbTransaction transaction)
{
const string SelectSql =
@"SELECT [Enqueueing], [EnqueueingUpdatedOn]
FROM [BlueCollarSchedule]
WHERE
[Id] = @Id;";
const string UpdateSql =
@"UPDATE [BlueCollarSchedule]
SET
[Enqueueing] = @Enqueueing,
[EnqueueingUpdatedOn] = @EnqueueingUpdatedOn
WHERE
[Id] = @Id;";
bool obtained = false, commitRollback = false;
if (transaction == null)
{
transaction = this.BeginTransaction(IsolationLevel.RepeatableRead);
commitRollback = true;
}
try
{
EnqueueingRecord enqueueing = this.connection.Query<EnqueueingRecord>(
SelectSql,
new { Id = scheduleId },
transaction,
true,
null,
null).First();
if (!enqueueing.Enqueueing || enqueueing.EnqueueingUpdatedOn == null || enqueueing.EnqueueingUpdatedOn <= forceIfOlderThan)
{
obtained = true;
this.connection.Execute(
UpdateSql,
new { Id = scheduleId, Enqueueing = true, EnqueueingUpdatedOn = DateTime.UtcNow },
transaction,
null,
null);
}
if (commitRollback)
{
transaction.Commit();
}
}
catch
{
if (commitRollback)
{
transaction.Rollback();
}
throw;
}
return obtained;
}
public static object ExecSQLReturnObject(IDbTransaction st, String sql, bool AllComplete)
{
if (st == null)
{
throw new Exception("本方法调用需要传入一个有效的事务，本次调用传入事务为Null");
}
try
{
object returnvalue=null;
if (GetDBType(st.Connection.ConnectionString) == OperationDBType.SQLLite)
{
throw new Exception("Sqlite不提供单一对象提取方法。");
}
else if (GetDBType(st.Connection.ConnectionString) == OperationDBType.SQL)
{
returnvalue = SqlHelper.ExecuteScalar((SqlTransaction)st, CommandType.Text, sql);
}
if (AllComplete)
{
IDbConnection myconn = st.Connection;
st.Commit();
if (myconn != null)
{
if (myconn.State != ConnectionState.Closed)
{
myconn.Close();
myconn.Dispose();
}
}
}
return returnvalue;
}
catch (Exception err)
{
IDbConnection myconn = st.Connection;
st.Rollback();
if (myconn != null)
{
if (myconn.State != ConnectionState.Closed)
{
myconn.Close();
myconn.Dispose();
}
}
throw new Exception(CBB.ExceptionHelper.ExpressionPaser.ErrTrim(err));
}
}
public virtual void AddDefaultData()
{
_transaction = _connection.BeginTransaction();
long superBoss = AddEmployee("Craig", "Boucher", DateTime.Today, true, 0);
long boss = AddEmployee("Jacob", "Lewallen", DateTime.Today, true, superBoss);
AddEmployee("Bruce", "Springsteen", DateTime.Today, true, 0);
AddEmployee("John", "McClane", DateTime.Today, true, 0);
AddEmployee("Andrea", "Lewallen", DateTime.Today, true, boss);
AddEmployee("Aaron", "Jensen", DateTime.Today, true, boss);
long electronics = AddCategory("Electronics");
AddProduct("iPod", electronics);
AddProduct("Nintendo DS", electronics);
AddProduct("Camera", electronics);
long sports = AddCategory("Sports");
AddProduct("Soccer", sports);
AddProduct("Football", sports);
AddCustomerData("Cyberdyne", 2);
AddCustomerData("ACME", 4);
_transaction.Commit();
}
/// <summary>提交事务</summary>
public static void Commit(IDbTransaction trans)
{
try
{
trans.Commit();
Debug.Log("Both records are written to database.");
}
catch (Exception ex)
{
Debug.Log("Commit Exception Type: {0}\n"+ ex.GetType());
Debug.Log(" Message: {0}\n"+ex.Message);
try
{
trans.Rollback();
}
catch (Exception ex2)
{
Debug.Log("Rollback Exception Type: {0}" + ex2.GetType());
Debug.Log(" Message: {0}" + ex2.Message);
}
}
}
