public void SQLite3()
{
Debug.WriteLine("");
Debug.WriteLine("SQLite3 -----------------");
DataEngine db = GetDbContext("sqlite3", useConnectionPool: false);
using (DBTransactionController trans = db.BeginTrans())
{
bool success = ExecuteCreateTable(TestExecutePattern.InTransaction, db, table_categories, trans);
if (success)
{
success = ExecuteCreateTable(TestExecutePattern.InTransaction, db, table_products, trans);
}
if (success)
{
trans.Commit();
}
}
}
public void PostgreSQL()
{
Debug.WriteLine("");
Debug.WriteLine("PostgreSQL -----------------");
DataEngine db = GetDbContext("npgsql");
using (DBTransactionController trans = db.BeginTrans())
{
bool success = ExecuteCreateTable(TestExecutePattern.InTransaction, db, table_categories, trans);
if (success)
{
success = ExecuteCreateTable(TestExecutePattern.InTransaction, db, table_products, trans);
}
if (success)
{
trans.Commit();
}
}
ReleaseDb(db);
}
/// <summary>
/// 开启事务处理。
/// </summary>
/// <returns></returns>
public DBTransactionController BeginTrans()
{
if (DBA == null || CommandParserAdapter == null)
{
throw (new Exception("无法开启事务，因为尚未初始化 DBA 或 CommandParserAdapter 对象。"));
}
IDbConnection DbConnection = DBA.Connect();
DbConnection.Open();
IDbTransaction Trans = DbConnection.BeginTransaction();
IDbCommand DbCommand = DBA.CreateDbCommand();
DbCommand.Connection = DbConnection;
DbCommand.Transaction = Trans;
TransactionDbAccess transDBA = new TransactionDbAccess(DbCommand, this);
DBTransactionController TransController = new DBTransactionController(Trans, transDBA, new ReleaseTransHandler(ReleaseTransaction));
TransactionConnectionCache.RegisterValidTransaction(TransController.UniqueId, DbConnection);
return(TransController);
}
/// <summary>
/// 在写访问引擎上执行指定的命令并返回受影响记录数.
/// </summary>
/// <param name="Command">要执行的命令.</param>
/// <param name="trans">在该事务中执行.</param>
/// <exception cref="Exception">当命执行命令过程产生错误时引发该异常.</exception>
/// <returns></returns>
public int ExecuteNoneQuery(DbCommandBuilder Command, DBTransactionController trans = null)
{
int result = 0;
if (trans == null)
{
trans.DBA.Errors.Clear();
result = trans.DBA.ExecuteNoneQuery(Command);
if (result < 0 && trans.DBA.Errors.Count > 0)
{
throw new Exception(trans.DBA.Errors[0].Message);
}
}
else
{
result = WriteEngine.ExecuteNoneQuery(Command);
if (result < 0 && WriteEngine.DBA.Error != null)
{
throw new Exception(WriteEngine.DBA.Error.Message);
}
}
return(result);
}
/// <summary>
/// 向数据表中添加一条记录.
/// </summary>
/// <typeparam name="TEntity">数据表对应的实体类型.</typeparam>
/// <param name="entity">实体对象.</param>
/// <param name="trans">写事务的事务控制器.</param>
/// <exception cref="Exception">当新增数据失败时引发该异常.</exception>
protected void Add <TEntity>(TEntity entity, DBTransactionController trans = null) where TEntity : DataEntity, new()
{
if (entity == null)
{
return;
}
// 增加记录时过滤掉自增长字段.
string[] withOutFields = GetWithOutFields(entity.GetType());
EntityTableAttribute tableAttribute = GetTableAttribute();
int result = 0;
if (BatchProccesser == null) // 非同连接分批处理模式.
{
bool InTransaction = trans != null;
QuickDataChanger DC;
if (InTransaction)
{
DC = new QuickDataChanger(trans, Writer);
}
else
{
DC = new QuickDataChanger(Writer);
}
result = DC.SaveToDataBase(tableAttribute.TableName, entity.ToDictionary(withOutFields), false);
if (result == -1) // 若添加失败则向外界抛出异常.
{
string Error;
if (InTransaction)
{
Error = (trans.DBA.Errors != null && trans.DBA.Errors.Count > 0) ? trans.DBA.Errors[0].Message : string.Format("新增：{0}是产生未知错误.", entity.GetType().Name);
}
else
{
Error = (Writer.DBA.Error == null) ? string.Format("新增：{0}是产生未知错误.", entity.GetType().Name) : Writer.DBA.Error.Message;
}
throw new Exception(Error);
}
else // 新增成功时更新实体中的自增长字段值.
{
if (withOutFields.Length > 0)
{
if (InTransaction)
{
entity.SetValue(withOutFields[withOutFields.Length - 1], trans.DBA.SCOPE_IDENTITY, true);
}
else
{
entity.SetValue(withOutFields[withOutFields.Length - 1], Writer.DBA.SCOPE_IDENTITY, true);
}
}
}
}
else // 在同一个连接的分批处理模式.
{
List <FieldDescription> fields = new List <FieldDescription>();
List <object> values = new List <object>();
Dictionary <string, object> data = entity.ToDictionary(withOutFields);
foreach (KeyValuePair <string, object> item in data)
{
fields.Add(td.Field(item.Key));
values.Add(item.Value);
}
DbCommandBuilder cb = new DbCommandBuilder();
cb.Insert(tableAttribute.TableName, fields.ToArray()).Values(values.ToArray());
result = BatchProccesser.Commander.ExecuteNonQuery(cb);
if (withOutFields.Length > 0 && result > 0)
{
entity.SetValue(withOutFields[withOutFields.Length - 1], BatchProccesser.Commander.SCOPE_IDENTITY, true);
}
}
}
/// <summary>
/// 释放与事务相关的资源（包含数据连接）。
/// </summary>
/// <param name="Owner">事务的所有者。</param>
public void ReleaseTransaction(DBTransactionController Owner)
{
TransactionConnectionCache.ReleaseConnection(Owner.UniqueId);
}
/// <summary>
/// 更新数据，并返回受影响的记录数.
/// </summary>
/// <param name="data">包含要更新的数据的字典.</param>
/// <param name="tableName">表名称.</param>
/// <param name="condition">更新条件.</param>
/// <param name="trans">在该事务中执行更新，若无事务则为 null.</param>
/// <returns></returns>
public virtual int Update(Dictionary <string, object> data, string tableName, object[] condition, DBTransactionController trans = null)
{
QuickDataChanger dc = new QuickDataChanger(trans, db);
dc.Conditions.AddRange(condition);
int result = dc.SaveToDataBase(tableName, data, true);
ThrowDbException(result, trans);
return(result);
}
/// <summary>
/// 添加数据，返回自增长编号字段的值.
/// </summary>
/// <param name="data">包含添加的数据的对象.</param>
/// <param name="tableName">表名称.</param>
/// <param name="trans">在该事务中执行添加任务，若无事务则为 null.</param>
/// <returns></returns>
public virtual object Add(Dictionary <string, object> data, string tableName, DBTransactionController trans = null)
{
QuickDataChanger dc = new QuickDataChanger(trans, db);
ThrowDbException(dc.SaveToDataBase(tableName, data, false), trans);
if (trans != null)
{
return(trans.DBA.SCOPE_IDENTITY);
}
return(db.DBA.SCOPE_IDENTITY);
}
