tk/FreeSql
1
0
Fork 0
mirror of https://github.com/nsnail/FreeSql.git synced 2025-06-19 04:18:16 +08:00
Code Issues Packages Projects Releases Wiki Activity

## v0.3.11

Browse Source 
- 增加 ISelect、IInsert、IUpdate、IDelete WithTransaction 方法，将事务对象暴露给外部；
- 增加 IAdo ExecuteXxx 系列方法重载，支持事务对象的传入；
This commit is contained in:
28810
2019-03-11 17:26:27 +08:00
parent c14dd0c169
commit 4f66c3b9eb
29 changed files with 216 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
FreeSql/Internal/CommonProvider/AdoProvider/AdoProvider.cs
View File

@ -58,7 +58,13 @@ namespace FreeSql.Internal.CommonProvider {
log.Append(e.Message);
_log.LogError(log.ToString());
RollbackTransaction();
if (cmd.Transaction != null) {
var curTran = TransactionCurrentThread;
if (cmd.Transaction != TransactionCurrentThread) {
//cmd.Transaction.Rollback();
} else
RollbackTransaction();
}
AopCommandExecuted?.Invoke(cmd, log.ToString());
@ -67,13 +73,15 @@ namespace FreeSql.Internal.CommonProvider {
}
internal static ConcurrentDictionary<Type, PropertyInfo[]> dicQueryTypeGetProperties = new ConcurrentDictionary<Type, PropertyInfo[]>();
public List<T> Query<T>(string cmdText, object parms = null) => Query<T>(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public List<T> Query<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public List<T> Query<T>(string cmdText, object parms = null) => Query<T>(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public List<T> Query<T>(DbTransaction transaction, string cmdText, object parms = null) => Query<T>(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public List<T> Query<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => Query<T>(null, cmdType, cmdText, cmdParms);
public List<T> Query<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var ret = new List<T>();
var type = typeof(T);
int[] indexes = null;
var props = dicQueryTypeGetProperties.GetOrAdd(type, k => type.GetProperties());
ExecuteReader(dr => {
ExecuteReader(transaction, dr => {
if (indexes == null) {
var dic = new Dictionary<string, int>(StringComparer.CurrentCultureIgnoreCase);
for (var a = 0; a < dr.FieldCount; a++)
@ -84,8 +92,10 @@ namespace FreeSql.Internal.CommonProvider {
}, cmdType, cmdText, cmdParms);
return ret;
}
public void ExecuteReader(Action<DbDataReader> readerHander, string cmdText, object parms = null) => ExecuteReader(readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public void ExecuteReader(Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public void ExecuteReader(Action<DbDataReader> readerHander, string cmdText, object parms = null) => ExecuteReader(null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, string cmdText, object parms = null) => ExecuteReader(transaction, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public void ExecuteReader(Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReader(null, readerHander, cmdType, cmdText, cmdParms);
public void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var dt = DateTime.Now;
var logtxt = new StringBuilder();
var logtxt_dt = DateTime.Now;
@ -108,7 +118,7 @@ namespace FreeSql.Internal.CommonProvider {
}
Object<DbConnection> conn = null;
var pc = PrepareCommand(cmdType, cmdText, cmdParms, logtxt);
var pc = PrepareCommand(transaction, cmdType, cmdText, cmdParms, logtxt);
if (IsTracePerformance) logtxt.Append("PrepareCommand: ").Append(DateTime.Now.Subtract(logtxt_dt).TotalMilliseconds).Append("ms Total: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n");
Exception ex = null;
try {
@ -178,20 +188,24 @@ namespace FreeSql.Internal.CommonProvider {
LoggerException(pool, pc.cmd, ex, dt, logtxt);
pc.cmd.Parameters.Clear();
}
public object[][] ExecuteArray(string cmdText, object parms = null) => ExecuteArray(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object[][] ExecuteArray(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public object[][] ExecuteArray(string cmdText, object parms = null) => ExecuteArray(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object[][] ExecuteArray(DbTransaction transaction, string cmdText, object parms = null) => ExecuteArray(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object[][] ExecuteArray(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArray(null, cmdType, cmdText, cmdParms);
public object[][] ExecuteArray(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
List<object[]> ret = new List<object[]>();
ExecuteReader(dr => {
ExecuteReader(transaction, dr => {
object[] values = new object[dr.FieldCount];
dr.GetValues(values);
ret.Add(values);
}, cmdType, cmdText, cmdParms);
return ret.ToArray();
}
public DataTable ExecuteDataTable(string cmdText, object parms = null) => ExecuteDataTable(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public DataTable ExecuteDataTable(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public DataTable ExecuteDataTable(string cmdText, object parms = null) => ExecuteDataTable(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public DataTable ExecuteDataTable(DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTable(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public DataTable ExecuteDataTable(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTable(null, cmdType, cmdText, cmdParms);
public DataTable ExecuteDataTable(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var ret = new DataTable();
ExecuteReader(dr => {
ExecuteReader(transaction, dr => {
if (ret.Columns.Count == 0)
for (var a = 0; a < dr.FieldCount; a++) ret.Columns.Add(dr.GetName(a));
object[] values = new object[ret.Columns.Count];
@ -200,13 +214,15 @@ namespace FreeSql.Internal.CommonProvider {
}, cmdType, cmdText, cmdParms);
return ret;
}
public int ExecuteNonQuery(string cmdText, object parms = null) => ExecuteNonQuery(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public int ExecuteNonQuery(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public int ExecuteNonQuery(string cmdText, object parms = null) => ExecuteNonQuery(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public int ExecuteNonQuery(DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQuery(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public int ExecuteNonQuery(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQuery(null, cmdType, cmdText, cmdParms);
public int ExecuteNonQuery(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var dt = DateTime.Now;
var logtxt = new StringBuilder();
var logtxt_dt = DateTime.Now;
Object<DbConnection> conn = null;
var pc = PrepareCommand(cmdType, cmdText, cmdParms, logtxt);
var pc = PrepareCommand(transaction, cmdType, cmdText, cmdParms, logtxt);
int val = 0;
Exception ex = null;
try {
@ -225,13 +241,15 @@ namespace FreeSql.Internal.CommonProvider {
pc.cmd.Parameters.Clear();
return val;
}
public object ExecuteScalar(string cmdText, object parms = null) => ExecuteScalar(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object ExecuteScalar(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public object ExecuteScalar(string cmdText, object parms = null) => ExecuteScalar(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object ExecuteScalar(DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalar(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object ExecuteScalar(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalar(null, cmdType, cmdText, cmdParms);
public object ExecuteScalar(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var dt = DateTime.Now;
var logtxt = new StringBuilder();
var logtxt_dt = DateTime.Now;
Object<DbConnection> conn = null;
var pc = PrepareCommand(cmdType, cmdText, cmdParms, logtxt);
var pc = PrepareCommand(transaction, cmdType, cmdText, cmdParms, logtxt);
object val = null;
Exception ex = null;
try {
@ -251,7 +269,7 @@ namespace FreeSql.Internal.CommonProvider {
return val;
}
private (DbTransaction tran, DbCommand cmd) PrepareCommand(CommandType cmdType, string cmdText, DbParameter[] cmdParms, StringBuilder logtxt) {
private (DbTransaction tran, DbCommand cmd) PrepareCommand(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, StringBuilder logtxt) {
var dt = DateTime.Now;
DbCommand cmd = CreateCommand();
cmd.CommandType = cmdType;
@ -265,7 +283,7 @@ namespace FreeSql.Internal.CommonProvider {
}
}
var tran = TransactionCurrentThread;
var tran = transaction ?? TransactionCurrentThread;
if (IsTracePerformance) logtxt.Append(" PrepareCommand_part1: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms cmdParms: ").Append(cmd.Parameters.Count).Append("\r\n");
if (tran != null) {

61
FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderAsync.cs
View File

@ -9,13 +9,15 @@ using System.Threading.Tasks;
namespace FreeSql.Internal.CommonProvider {
partial class AdoProvider {
public Task<List<T>> QueryAsync<T>(string cmdText, object parms = null) => QueryAsync<T>(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
async public Task<List<T>> QueryAsync<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public Task<List<T>> QueryAsync<T>(string cmdText, object parms = null) => QueryAsync<T>(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<List<T>> QueryAsync<T>(DbTransaction transaction, string cmdText, object parms = null) => QueryAsync<T>(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<List<T>> QueryAsync<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T>(null, cmdType, cmdText, cmdParms);
async public Task<List<T>> QueryAsync<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var ret = new List<T>();
var type = typeof(T);
int[] indexes = null;
var props = dicQueryTypeGetProperties.GetOrAdd(type, k => type.GetProperties());
await ExecuteReaderAsync(dr => {
await ExecuteReaderAsync(transaction, dr => {
if (indexes == null) {
var dic = new Dictionary<string, int>(StringComparer.CurrentCultureIgnoreCase);
for (var a = 0; a < dr.FieldCount; a++)
@ -27,8 +29,10 @@ namespace FreeSql.Internal.CommonProvider {
}, cmdType, cmdText, cmdParms);
return ret;
}
public Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
async public Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(transaction, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(null, readerHander, cmdType, cmdText, cmdParms);
async public Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var dt = DateTime.Now;
var logtxt = new StringBuilder();
var logtxt_dt = DateTime.Now;
@ -51,7 +55,7 @@ namespace FreeSql.Internal.CommonProvider {
}
Object<DbConnection> conn = null;
var cmd = PrepareCommandAsync(cmdType, cmdText, cmdParms, logtxt);
var cmd = PrepareCommandAsync(transaction, cmdType, cmdText, cmdParms, logtxt);
if (IsTracePerformance) logtxt.Append("PrepareCommandAsync: ").Append(DateTime.Now.Subtract(logtxt_dt).TotalMilliseconds).Append("ms Total: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n");
Exception ex = null;
try {
@ -121,20 +125,24 @@ namespace FreeSql.Internal.CommonProvider {
LoggerException(pool, cmd, ex, dt, logtxt);
cmd.Parameters.Clear();
}
public Task<object[][]> ExecuteArrayAsync(string cmdText, object parms = null) => ExecuteArrayAsync(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
async public Task<object[][]> ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public Task<object[][]> ExecuteArrayAsync(string cmdText, object parms = null) => ExecuteArrayAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteArrayAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<object[][]> ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArrayAsync(null, cmdType, cmdText, cmdParms);
async public Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
List<object[]> ret = new List<object[]>();
await ExecuteReaderAsync(async dr => {
await ExecuteReaderAsync(transaction, async dr => {
object[] values = new object[dr.FieldCount];
for (int a = 0; a < values.Length; a++) if (!await dr.IsDBNullAsync(a)) values[a] = await dr.GetFieldValueAsync<object>(a);
ret.Add(values);
}, cmdType, cmdText, cmdParms);
return ret.ToArray();
}
public Task<DataTable> ExecuteDataTableAsync(string cmdText, object parms = null) => ExecuteDataTableAsync(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
async public Task<DataTable> ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public Task<DataTable> ExecuteDataTableAsync(string cmdText, object parms = null) => ExecuteDataTableAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTableAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<DataTable> ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTableAsync(null, cmdType, cmdText, cmdParms);
async public Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var ret = new DataTable();
await ExecuteReaderAsync(async dr => {
await ExecuteReaderAsync(transaction, async dr => {
if (ret.Columns.Count == 0)
for (var a = 0; a < dr.FieldCount; a++) ret.Columns.Add(dr.GetName(a));
object[] values = new object[ret.Columns.Count];
@ -143,13 +151,15 @@ namespace FreeSql.Internal.CommonProvider {
}, cmdType, cmdText, cmdParms);
return ret;
}
public Task<int> ExecuteNonQueryAsync(string cmdText, object parms = null) => ExecuteNonQueryAsync(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
async public Task<int> ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public Task<int> ExecuteNonQueryAsync(string cmdText, object parms = null) => ExecuteNonQueryAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<int> ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQueryAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<int> ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(null, cmdType, cmdText, cmdParms);
async public Task<int> ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var dt = DateTime.Now;
var logtxt = new StringBuilder();
var logtxt_dt = DateTime.Now;
Object<DbConnection> conn = null;
var cmd = PrepareCommandAsync(cmdType, cmdText, cmdParms, logtxt);
var cmd = PrepareCommandAsync(transaction, cmdType, cmdText, cmdParms, logtxt);
int val = 0;
Exception ex = null;
try {
@ -168,13 +178,15 @@ namespace FreeSql.Internal.CommonProvider {
cmd.Parameters.Clear();
return val;
}
public Task<object> ExecuteScalarAsync(string cmdText, object parms = null) => ExecuteScalarAsync(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
async public Task<object> ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public Task<object> ExecuteScalarAsync(string cmdText, object parms = null) => ExecuteScalarAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<object> ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalarAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<object> ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(null, cmdType, cmdText, cmdParms);
async public Task<object> ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var dt = DateTime.Now;
var logtxt = new StringBuilder();
var logtxt_dt = DateTime.Now;
Object<DbConnection> conn = null;
var cmd = PrepareCommandAsync(cmdType, cmdText, cmdParms, logtxt);
var cmd = PrepareCommandAsync(transaction, cmdType, cmdText, cmdParms, logtxt);
object val = null;
Exception ex = null;
try {
@ -194,7 +206,7 @@ namespace FreeSql.Internal.CommonProvider {
return val;
}
private DbCommand PrepareCommandAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, StringBuilder logtxt) {
private DbCommand PrepareCommandAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, StringBuilder logtxt) {
DateTime dt = DateTime.Now;
DbCommand cmd = CreateCommand();
cmd.CommandType = cmdType;
@ -208,7 +220,16 @@ namespace FreeSql.Internal.CommonProvider {
}
}
if (IsTracePerformance) logtxt.Append(" PrepareCommand_tran==null: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms cmdParms: ").Append(cmd.Parameters.Count).Append("\r\n");
var tran = transaction;
if (tran != null) {
if (IsTracePerformance) dt = DateTime.Now;
cmd.Connection = tran.Connection;
cmd.Transaction = tran;
if (IsTracePerformance) logtxt.Append(" PrepareCommandAsync_tran!=null: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n");
}
if (IsTracePerformance) logtxt.Append(" PrepareCommandAsync ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms cmdParms: ").Append(cmd.Parameters.Count).Append("\r\n");
AopCommandExecuting?.Invoke(cmd);
return cmd;

22
FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderTransaction.cs
View File

@ -47,9 +47,6 @@ namespace FreeSql.Internal.CommonProvider {
}
public void TransactionPreRemoveCache(params string[] key) => PreRemove(key);
/// <summary>
/// 启动事务
/// </summary>
public void BeginTransaction(TimeSpan timeout) {
int tid = Thread.CurrentThread.ManagedThreadId;
Transaction2 tran = null;
@ -60,6 +57,7 @@ namespace FreeSql.Internal.CommonProvider {
tran = new Transaction2(conn, conn.Value.BeginTransaction(), timeout);
} catch(Exception ex) {
_log.LogError($"数据库出错（开启事务）{ex.Message} \r\n{ex.StackTrace}");
MasterPool.Return(conn);
throw ex;
}
if (_trans.ContainsKey(tid)) CommitTransaction();
@ -68,9 +66,6 @@ namespace FreeSql.Internal.CommonProvider {
_trans.Add(tid, tran);
}
/// <summary>
/// 自动提交事务
/// </summary>
private void AutoCommitTransaction() {
if (_trans.Count > 0) {
Transaction2[] trans = null;
@ -110,13 +105,7 @@ namespace FreeSql.Internal.CommonProvider {
private void CommitTransaction(bool isCommit) {
if (_trans.TryGetValue(Thread.CurrentThread.ManagedThreadId, out var tran)) CommitTransaction(isCommit, tran);
}
/// <summary>
/// 提交事务
/// </summary>
public void CommitTransaction() => CommitTransaction(true);
/// <summary>
/// 回滚事务
/// </summary>
public void RollbackTransaction() => CommitTransaction(false);
public void Dispose() {
@ -126,18 +115,9 @@ namespace FreeSql.Internal.CommonProvider {
foreach (Transaction2 tran in trans) CommitTransaction(false, tran);
}
/// <summary>
/// 开启事务（不支持异步），60秒未执行完将自动提交
/// </summary>
/// <param name="handler">事务体 () => {}</param>
public void Transaction(Action handler) {
Transaction(handler, TimeSpan.FromSeconds(60));
}
/// <summary>
/// 开启事务（不支持异步）
/// </summary>
/// <param name="handler">事务体 () => {}</param>
/// <param name="timeout">超时，未执行完将自动提交</param>
public void Transaction(Action handler, TimeSpan timeout) {
try {
BeginTransaction(timeout);

10
FreeSql/Internal/CommonProvider/DeleteProvider.cs
View File

@ -19,6 +19,7 @@ namespace FreeSql.Internal.CommonProvider {
protected StringBuilder _where = new StringBuilder();
protected int _whereTimes = 0;
protected List<DbParameter> _params = new List<DbParameter>();
protected DbTransaction _transaction;
public DeleteProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) {
_orm = orm;
@ -29,15 +30,20 @@ namespace FreeSql.Internal.CommonProvider {
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure<T1>();
}
public IDelete<T1> WithTransaction(DbTransaction transaction) {
_transaction = transaction;
return this;
}
public int ExecuteAffrows() {
var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0;
return _orm.Ado.ExecuteNonQuery(CommandType.Text, sql, _params.ToArray());
return _orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, sql, _params.ToArray());
}
async public Task<int> ExecuteAffrowsAsync() {
var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0;
return await _orm.Ado.ExecuteNonQueryAsync(CommandType.Text, sql, _params.ToArray());
return await _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, sql, _params.ToArray());
}
public abstract List<T1> ExecuteDeleted();
public abstract Task<List<T1>> ExecuteDeletedAsync();

10
FreeSql/Internal/CommonProvider/InsertProvider.cs
View File

@ -19,6 +19,7 @@ namespace FreeSql.Internal.CommonProvider {
protected TableInfo _table;
protected Func<string, string> _tableRule;
protected DbParameter[] _params;
protected DbTransaction _transaction;
public InsertProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression) {
_orm = orm;
@ -28,6 +29,11 @@ namespace FreeSql.Internal.CommonProvider {
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure<T1>();
}
public IInsert<T1> WithTransaction(DbTransaction transaction) {
_transaction = transaction;
return this;
}
public IInsert<T1> AppendData(T1 source) {
if (source != null) _source.Add(source);
return this;
@ -37,8 +43,8 @@ namespace FreeSql.Internal.CommonProvider {
return this;
}
public int ExecuteAffrows() => _orm.Ado.ExecuteNonQuery(CommandType.Text, this.ToSql(), _params);
public Task<int> ExecuteAffrowsAsync() => _orm.Ado.ExecuteNonQueryAsync(CommandType.Text, this.ToSql(), _params);
public int ExecuteAffrows() => _orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, this.ToSql(), _params);
public Task<int> ExecuteAffrowsAsync() => _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, this.ToSql(), _params);
public abstract long ExecuteIdentity();
public abstract Task<long> ExecuteIdentityAsync();
public abstract List<T1> ExecuteInserted();

19
FreeSql/Internal/CommonProvider/SelectProvider/Select0Provider.cs
View File

@ -25,6 +25,7 @@ namespace FreeSql.Internal.CommonProvider {
protected IFreeSql _orm;
protected CommonUtils _commonUtils;
protected CommonExpression _commonExpression;
protected DbTransaction _transaction;
internal static void CopyData(Select0Provider<TSelect, T1> from, object to) {
var toType = to?.GetType();
@ -44,6 +45,7 @@ namespace FreeSql.Internal.CommonProvider {
//toType.GetField("_orm", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._orm);
//toType.GetField("_commonUtils", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._commonUtils);
//toType.GetField("_commonExpression", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._commonExpression);
toType.GetField("_transaction", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._transaction);
}
public Select0Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) {
@ -55,6 +57,11 @@ namespace FreeSql.Internal.CommonProvider {
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure<T1>();
}
public TSelect WithTransaction(DbTransaction transaction) {
_transaction = transaction;
return this as TSelect;
}
public bool Any() {
this.Limit(1);
return this.ToList<int>("1").FirstOrDefault() == 1;
@ -152,7 +159,7 @@ namespace FreeSql.Internal.CommonProvider {
return _orm.Cache.Shell(_cache.key, _cache.seconds, () => {
List<TTuple> ret = new List<TTuple>();
Type type = typeof(TTuple);
_orm.Ado.ExecuteReader(dr => {
_orm.Ado.ExecuteReader(_transaction, dr => {
var read = Utils.ExecuteArrayRowReadClassOrTuple(type, null, dr);
ret.Add((TTuple)read.Value);
}, CommandType.Text, sql, _params.ToArray());
@ -166,7 +173,7 @@ namespace FreeSql.Internal.CommonProvider {
return _orm.Cache.ShellAsync(_cache.key, _cache.seconds, async () => {
List<TTuple> ret = new List<TTuple>();
Type type = typeof(TTuple);
await _orm.Ado.ExecuteReaderAsync(dr => {
await _orm.Ado.ExecuteReaderAsync(_transaction, dr => {
var read = Utils.ExecuteArrayRowReadClassOrTuple(type, null, dr);
ret.Add((TTuple)read.Value);
return Task.CompletedTask;
@ -181,7 +188,7 @@ namespace FreeSql.Internal.CommonProvider {
return _orm.Cache.Shell(_cache.key, _cache.seconds, () => {
List<T1> ret = new List<T1>();
_orm.Ado.ExecuteReader(dr => {
_orm.Ado.ExecuteReader(_transaction, dr => {
ret.Add(af.Read(dr));
}, CommandType.Text, sql, _params.ToArray());
return ret;
@ -194,7 +201,7 @@ namespace FreeSql.Internal.CommonProvider {
return await _orm.Cache.ShellAsync(_cache.key, _cache.seconds, async () => {
List<T1> ret = new List<T1>();
await _orm.Ado.ExecuteReaderAsync(dr => {
await _orm.Ado.ExecuteReaderAsync(_transaction, dr => {
ret.Add(af.Read(dr));
return Task.CompletedTask;
}, CommandType.Text, sql, _params.ToArray());
@ -220,7 +227,7 @@ namespace FreeSql.Internal.CommonProvider {
return _orm.Cache.Shell(_cache.key, _cache.seconds, () => {
List<TReturn> ret = new List<TReturn>();
Type type = typeof(TReturn);
_orm.Ado.ExecuteReader(dr => {
_orm.Ado.ExecuteReader(_transaction, dr => {
var index = -1;
ret.Add((TReturn)_commonExpression.ReadAnonymous(af.map, dr, ref index));
}, CommandType.Text, sql, _params.ToArray());
@ -234,7 +241,7 @@ namespace FreeSql.Internal.CommonProvider {
return await _orm.Cache.ShellAsync(_cache.key, _cache.seconds, async () => {
List<TReturn> ret = new List<TReturn>();
Type type = typeof(TReturn);
await _orm.Ado.ExecuteReaderAsync(dr => {
await _orm.Ado.ExecuteReaderAsync(_transaction, dr => {
var index = -1;
ret.Add((TReturn)_commonExpression.ReadAnonymous(af.map, dr, ref index));
return Task.CompletedTask;

10
FreeSql/Internal/CommonProvider/UpdateProvider.cs
View File

@ -22,6 +22,7 @@ namespace FreeSql.Internal.CommonProvider {
protected StringBuilder _set = new StringBuilder();
protected List<DbParameter> _params = new List<DbParameter>();
protected List<DbParameter> _paramsSource = new List<DbParameter>();
protected DbTransaction _transaction;
public UpdateProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) {
_orm = orm;
@ -32,15 +33,20 @@ namespace FreeSql.Internal.CommonProvider {
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure<T1>();
}
public IUpdate<T1> WithTransaction(DbTransaction transaction) {
_transaction = transaction;
return this;
}
public int ExecuteAffrows() {
var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0;
return _orm.Ado.ExecuteNonQuery(CommandType.Text, sql, _params.Concat(_paramsSource).ToArray());
return _orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, sql, _params.Concat(_paramsSource).ToArray());
}
async public Task<int> ExecuteAffrowsAsync() {
var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0;
return await _orm.Ado.ExecuteNonQueryAsync(CommandType.Text, sql, _params.Concat(_paramsSource).ToArray());
return await _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, sql, _params.Concat(_paramsSource).ToArray());
}
public abstract List<T1> ExecuteUpdated();
public abstract Task<List<T1>> ExecuteUpdatedAsync();