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

补充 IAdo 相关方法

Browse Source
This commit is contained in:
28810
2019-04-10 23:31:34 +08:00
parent d1a07dc888
commit a4678ebdc3
29 changed files with 269 additions and 362 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -37,7 +37,9 @@ namespace FreeSql.Internal.CommonProvider {
this.DataType = dataType;
}
void LoggerException(ObjectPool<DbConnection> pool, DbCommand cmd, Exception e, DateTime dt, StringBuilder logtxt, bool isThrowException = true) {
void LoggerException(ObjectPool<DbConnection> pool, (DbCommand cmd, bool isclose) pc, Exception e, DateTime dt, StringBuilder logtxt, bool isThrowException = true) {
var cmd = pc.cmd;
if (pc.isclose) pc.cmd.Connection.Close();
if (IsTracePerformance) {
TimeSpan ts = DateTime.Now.Subtract(dt);
if (e == null && ts.TotalMilliseconds > 100)
@ -75,18 +77,17 @@ 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>(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public List<T> Query<T>(DbTransaction transaction, string cmdText, object parms = null) => Query<T>(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public List<T> Query<T>(DbConnection connection, string cmdText, object parms = null) => Query<T>(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public List<T> Query<T>(DbTransaction transaction, string cmdText, object parms = null) => Query<T>(null, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public List<T> Query<T>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => Query<T>(connection, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public List<T> Query<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => Query<T>(null, null, cmdType, cmdText, cmdParms);
public List<T> Query<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => Query<T>(transaction, null, cmdType, cmdText, cmdParms);
public List<T> Query<T>(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => Query<T>(null, connection, cmdType, cmdText, cmdParms);
List<T> Query<T>(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public List<T> Query<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => Query<T>(null, transaction, cmdType, cmdText, cmdParms);
public List<T> Query<T>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var ret = new List<T>();
if (string.IsNullOrEmpty(cmdText)) return ret;
var type = typeof(T);
int[] indexes = null;
var props = dicQueryTypeGetProperties.GetOrAdd(type, k => type.GetProperties());
ExecuteReader(transaction, connection, dr => {
ExecuteReader(connection, transaction, dr => {
if (indexes == null) {
var dic = new Dictionary<string, int>(StringComparer.CurrentCultureIgnoreCase);
for (var a = 0; a < dr.FieldCount; a++)
@ -98,12 +99,11 @@ namespace FreeSql.Internal.CommonProvider {
return ret;
}
public void ExecuteReader(Action<DbDataReader> readerHander, string cmdText, object parms = null) => ExecuteReader(null, null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, string cmdText, object parms = null) => ExecuteReader(transaction, null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public void ExecuteReader(DbConnection connection, Action<DbDataReader> readerHander, string cmdText, object parms = null) => ExecuteReader(null, connection, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, string cmdText, object parms = null) => ExecuteReader(null, transaction, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public void ExecuteReader(DbConnection connection, DbTransaction transaction, Action<DbDataReader> readerHander, string cmdText, object parms = null) => ExecuteReader(connection, transaction, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public void ExecuteReader(Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReader(null, null, readerHander, cmdType, cmdText, cmdParms);
public void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReader(transaction, null, readerHander, cmdType, cmdText, cmdParms);
public void ExecuteReader(DbConnection connection, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReader(null, connection, readerHander, cmdType, cmdText, cmdParms);
void ExecuteReader(DbTransaction transaction, DbConnection connection, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReader(null, transaction, readerHander, cmdType, cmdText, cmdParms);
public void ExecuteReader(DbConnection connection, DbTransaction transaction, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
if (string.IsNullOrEmpty(cmdText)) return;
var dt = DateTime.Now;
var logtxt = new StringBuilder();
@ -129,7 +129,7 @@ namespace FreeSql.Internal.CommonProvider {
}
Object<DbConnection> conn = null;
var pc = PrepareCommand(transaction, connection, cmdType, cmdText, cmdParms, logtxt);
var pc = PrepareCommand(connection, 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 {
@ -138,7 +138,7 @@ namespace FreeSql.Internal.CommonProvider {
//从库查询切换，恢复
bool isSlaveFail = false;
try {
if (pc.Connection == null) pc.Connection = (conn = pool.Get()).Value;
if (pc.cmd.Connection == null) pc.cmd.Connection = (conn = pool.Get()).Value;
//if (slaveRandom.Next(100) % 2 == 0) throw new Exception("测试从库抛出异常");
} catch {
isSlaveFail = true;
@ -150,19 +150,19 @@ namespace FreeSql.Internal.CommonProvider {
if (IsTracePerformance) logtxt.Append("ReleaseConnection: ").Append(DateTime.Now.Subtract(logtxt_dt).TotalMilliseconds).Append("ms Total: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms");
}
LoggerException(pool, pc, new Exception($"连接失败，准备切换其他可用服务器"), dt, logtxt, false);
pc.Parameters.Clear();
pc.cmd.Parameters.Clear();
ExecuteReader(readerHander, cmdType, cmdText, cmdParms);
return;
}
} else {
//主库查询
if (pc.Connection == null) pc.Connection = (conn = pool.Get()).Value;
if (pc.cmd.Connection == null) pc.cmd.Connection = (conn = pool.Get()).Value;
}
if (IsTracePerformance) {
logtxt.Append("Open: ").Append(DateTime.Now.Subtract(logtxt_dt).TotalMilliseconds).Append("ms Total: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n");
logtxt_dt = DateTime.Now;
}
using (var dr = pc.ExecuteReader()) {
using (var dr = pc.cmd.ExecuteReader()) {
if (IsTracePerformance) logtxt.Append("ExecuteReader: ").Append(DateTime.Now.Subtract(logtxt_dt).TotalMilliseconds).Append("ms Total: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n");
while (true) {
if (IsTracePerformance) logtxt_dt = DateTime.Now;
@ -197,17 +197,16 @@ namespace FreeSql.Internal.CommonProvider {
if (IsTracePerformance) logtxt.Append("ReleaseConnection: ").Append(DateTime.Now.Subtract(logtxt_dt).TotalMilliseconds).Append("ms Total: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms");
}
LoggerException(pool, pc, ex, dt, logtxt);
pc.Parameters.Clear();
pc.cmd.Parameters.Clear();
}
public object[][] ExecuteArray(string cmdText, object parms = null) => ExecuteArray(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object[][] ExecuteArray(DbTransaction transaction, string cmdText, object parms = null) => ExecuteArray(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object[][] ExecuteArray(DbConnection connection, string cmdText, object parms = null) => ExecuteArray(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object[][] ExecuteArray(DbTransaction transaction, string cmdText, object parms = null) => ExecuteArray(null, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object[][] ExecuteArray(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteArray(connection, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object[][] ExecuteArray(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArray(null, null, cmdType, cmdText, cmdParms);
public object[][] ExecuteArray(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArray(transaction, null, cmdType, cmdText, cmdParms);
public object[][] ExecuteArray(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArray(null, connection, cmdType, cmdText, cmdParms);
object[][] ExecuteArray(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public object[][] ExecuteArray(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArray(null, transaction, cmdType, cmdText, cmdParms);
public object[][] ExecuteArray(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
List<object[]> ret = new List<object[]>();
ExecuteReader(transaction, connection, dr => {
ExecuteReader(connection, transaction, dr => {
object[] values = new object[dr.FieldCount];
dr.GetValues(values);
ret.Add(values);
@ -215,14 +214,13 @@ namespace FreeSql.Internal.CommonProvider {
return ret.ToArray();
}
public DataTable ExecuteDataTable(string cmdText, object parms = null) => ExecuteDataTable(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public DataTable ExecuteDataTable(DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTable(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public DataTable ExecuteDataTable(DbConnection connection, string cmdText, object parms = null) => ExecuteDataTable(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public DataTable ExecuteDataTable(DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTable(null, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public DataTable ExecuteDataTable(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTable(connection, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public DataTable ExecuteDataTable(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTable(null, null, cmdType, cmdText, cmdParms);
public DataTable ExecuteDataTable(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTable(transaction, null, cmdType, cmdText, cmdParms);
public DataTable ExecuteDataTable(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTable(null, connection, cmdType, cmdText, cmdParms);
DataTable ExecuteDataTable(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public DataTable ExecuteDataTable(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTable(null, transaction, cmdType, cmdText, cmdParms);
public DataTable ExecuteDataTable(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var ret = new DataTable();
ExecuteReader(transaction, connection, dr => {
ExecuteReader(connection, 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];
@ -232,23 +230,22 @@ namespace FreeSql.Internal.CommonProvider {
return ret;
}
public int ExecuteNonQuery(string cmdText, object parms = null) => ExecuteNonQuery(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public int ExecuteNonQuery(DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQuery(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public int ExecuteNonQuery(DbConnection connection, string cmdText, object parms = null) => ExecuteNonQuery(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public int ExecuteNonQuery(DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQuery(null, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public int ExecuteNonQuery(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQuery(connection, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public int ExecuteNonQuery(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQuery(null, null, cmdType, cmdText, cmdParms);
public int ExecuteNonQuery(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQuery(transaction, null, cmdType, cmdText, cmdParms);
public int ExecuteNonQuery(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQuery(null, connection, cmdType, cmdText, cmdParms);
int ExecuteNonQuery(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public int ExecuteNonQuery(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQuery(null, transaction, cmdType, cmdText, cmdParms);
public int ExecuteNonQuery(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
if (string.IsNullOrEmpty(cmdText)) return 0;
var dt = DateTime.Now;
var logtxt = new StringBuilder();
var logtxt_dt = DateTime.Now;
Object<DbConnection> conn = null;
var pc = PrepareCommand(transaction, connection, cmdType, cmdText, cmdParms, logtxt);
var pc = PrepareCommand(connection, transaction, cmdType, cmdText, cmdParms, logtxt);
int val = 0;
Exception ex = null;
try {
if (pc.Connection == null) pc.Connection = (conn = this.MasterPool.Get()).Value;
val = pc.ExecuteNonQuery();
if (pc.cmd.Connection == null) pc.cmd.Connection = (conn = this.MasterPool.Get()).Value;
val = pc.cmd.ExecuteNonQuery();
} catch (Exception ex2) {
ex = ex2;
}
@ -259,27 +256,26 @@ namespace FreeSql.Internal.CommonProvider {
if (IsTracePerformance) logtxt.Append("ReleaseConnection: ").Append(DateTime.Now.Subtract(logtxt_dt).TotalMilliseconds).Append("ms Total: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms");
}
LoggerException(this.MasterPool, pc, ex, dt, logtxt);
pc.Parameters.Clear();
pc.cmd.Parameters.Clear();
return val;
}
public object ExecuteScalar(string cmdText, object parms = null) => ExecuteScalar(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object ExecuteScalar(DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalar(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object ExecuteScalar(DbConnection connection, string cmdText, object parms = null) => ExecuteScalar(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object ExecuteScalar(DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalar(null, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object ExecuteScalar(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalar(connection, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object ExecuteScalar(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalar(null, null, cmdType, cmdText, cmdParms);
public object ExecuteScalar(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalar(transaction, null, cmdType, cmdText, cmdParms);
public object ExecuteScalar(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalar(null, connection, cmdType, cmdText, cmdParms);
object ExecuteScalar(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public object ExecuteScalar(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalar(null, transaction, cmdType, cmdText, cmdParms);
public object ExecuteScalar(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
if (string.IsNullOrEmpty(cmdText)) return null;
var dt = DateTime.Now;
var logtxt = new StringBuilder();
var logtxt_dt = DateTime.Now;
Object<DbConnection> conn = null;
var pc = PrepareCommand(transaction, connection, cmdType, cmdText, cmdParms, logtxt);
var pc = PrepareCommand(connection, transaction, cmdType, cmdText, cmdParms, logtxt);
object val = null;
Exception ex = null;
try {
if (pc.Connection == null) pc.Connection = (conn = this.MasterPool.Get()).Value;
val = pc.ExecuteScalar();
if (pc.cmd.Connection == null) pc.cmd.Connection = (conn = this.MasterPool.Get()).Value;
val = pc.cmd.ExecuteScalar();
} catch (Exception ex2) {
ex = ex2;
}
@ -290,13 +286,14 @@ namespace FreeSql.Internal.CommonProvider {
if (IsTracePerformance) logtxt.Append("ReleaseConnection: ").Append(DateTime.Now.Subtract(logtxt_dt).TotalMilliseconds).Append("ms Total: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms");
}
LoggerException(this.MasterPool, pc, ex, dt, logtxt);
pc.Parameters.Clear();
pc.cmd.Parameters.Clear();
return val;
}
DbCommand PrepareCommand(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, DbParameter[] cmdParms, StringBuilder logtxt) {
(DbCommand cmd, bool isclose) PrepareCommand(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, StringBuilder logtxt) {
var dt = DateTime.Now;
DbCommand cmd = CreateCommand();
bool isclose = false;
cmd.CommandType = cmdType;
cmd.CommandText = cmdText;
@ -308,23 +305,32 @@ namespace FreeSql.Internal.CommonProvider {
}
}
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 (connection == null) {
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) {
if (IsTracePerformance) dt = DateTime.Now;
cmd.Connection = tran.Connection;
cmd.Transaction = tran;
if (IsTracePerformance) logtxt.Append(" PrepareCommand_tran!=null: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n");
} else
if (tran != null && connection == null) {
if (IsTracePerformance) dt = DateTime.Now;
cmd.Connection = tran.Connection;
cmd.Transaction = tran;
if (IsTracePerformance) logtxt.Append(" PrepareCommand_tran!=null: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n");
}
} else {
if (connection.State != ConnectionState.Open) {
if (IsTracePerformance) dt = DateTime.Now;
connection.Open();
if (IsTracePerformance) logtxt.Append(" PrepareCommand_ConnectionOpen: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n");
isclose = true;
}
cmd.Connection = connection;
}
if (IsTracePerformance) dt = DateTime.Now;
AutoCommitTransaction();
if (IsTracePerformance) logtxt.Append(" AutoCommitTransaction: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n");
AopCommandExecuting?.Invoke(cmd);
return cmd;
return (cmd, isclose);
}
}
}

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

@ -10,18 +10,17 @@ using System.Threading.Tasks;
namespace FreeSql.Internal.CommonProvider {
partial class AdoProvider {
public Task<List<T>> QueryAsync<T>(string cmdText, object parms = null) => QueryAsync<T>(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<List<T>> QueryAsync<T>(DbTransaction transaction, string cmdText, object parms = null) => QueryAsync<T>(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<List<T>> QueryAsync<T>(DbConnection connection, string cmdText, object parms = null) => QueryAsync<T>(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<List<T>> QueryAsync<T>(DbTransaction transaction, string cmdText, object parms = null) => QueryAsync<T>(null, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<List<T>> QueryAsync<T>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => QueryAsync<T>(connection, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<List<T>> QueryAsync<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T>(null, null, cmdType, cmdText, cmdParms);
public Task<List<T>> QueryAsync<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T>(transaction, null, cmdType, cmdText, cmdParms);
public Task<List<T>> QueryAsync<T>(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T>(null, connection, cmdType, cmdText, cmdParms);
async Task<List<T>> QueryAsync<T>(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public Task<List<T>> QueryAsync<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T>(null, transaction, cmdType, cmdText, cmdParms);
async public Task<List<T>> QueryAsync<T>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var ret = new List<T>();
if (string.IsNullOrEmpty(cmdText)) return ret;
var type = typeof(T);
int[] indexes = null;
var props = dicQueryTypeGetProperties.GetOrAdd(type, k => type.GetProperties());
await ExecuteReaderAsync(transaction, connection, dr => {
await ExecuteReaderAsync(connection, transaction, dr => {
if (indexes == null) {
var dic = new Dictionary<string, int>(StringComparer.CurrentCultureIgnoreCase);
for (var a = 0; a < dr.FieldCount; a++)
@ -34,12 +33,11 @@ namespace FreeSql.Internal.CommonProvider {
return ret;
}
public Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(null, null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(transaction, null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task ExecuteReaderAsync(DbConnection connection, Func<DbDataReader, Task> readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(null, connection, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(null, transaction, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func<DbDataReader, Task> readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(connection, transaction, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(null, null, readerHander, cmdType, cmdText, cmdParms);
public Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(transaction, null, readerHander, cmdType, cmdText, cmdParms);
public Task ExecuteReaderAsync(DbConnection connection, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(null, connection, readerHander, cmdType, cmdText, cmdParms);
async Task ExecuteReaderAsync(DbTransaction transaction, DbConnection connection, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(null, transaction, readerHander, cmdType, cmdText, cmdParms);
async public Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
if (string.IsNullOrEmpty(cmdText)) return;
var dt = DateTime.Now;
var logtxt = new StringBuilder();
@ -65,7 +63,7 @@ namespace FreeSql.Internal.CommonProvider {
}
Object<DbConnection> conn = null;
var cmd = PrepareCommandAsync(transaction, connection, cmdType, cmdText, cmdParms, logtxt);
var pc = await PrepareCommandAsync(connection, 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 {
@ -74,7 +72,7 @@ namespace FreeSql.Internal.CommonProvider {
//从库查询切换，恢复
bool isSlaveFail = false;
try {
if (cmd.Connection == null) cmd.Connection = (conn = await pool.GetAsync()).Value;
if (pc.cmd.Connection == null) pc.cmd.Connection = (conn = await pool.GetAsync()).Value;
//if (slaveRandom.Next(100) % 2 == 0) throw new Exception("测试从库抛出异常");
} catch {
isSlaveFail = true;
@ -85,20 +83,20 @@ namespace FreeSql.Internal.CommonProvider {
ReturnConnection(pool, conn, ex); //pool.Return(conn, ex);
if (IsTracePerformance) logtxt.Append("ReleaseConnection: ").Append(DateTime.Now.Subtract(logtxt_dt).TotalMilliseconds).Append("ms Total: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms");
}
LoggerException(pool, cmd, new Exception($"连接失败，准备切换其他可用服务器"), dt, logtxt, false);
cmd.Parameters.Clear();
LoggerException(pool, pc, new Exception($"连接失败，准备切换其他可用服务器"), dt, logtxt, false);
pc.cmd.Parameters.Clear();
await ExecuteReaderAsync(readerHander, cmdType, cmdText, cmdParms);
return;
}
} else {
//主库查询
if (cmd.Connection == null) cmd.Connection = (conn = await pool.GetAsync()).Value;
if (pc.cmd.Connection == null) pc.cmd.Connection = (conn = await pool.GetAsync()).Value;
}
if (IsTracePerformance) {
logtxt.Append("OpenAsync: ").Append(DateTime.Now.Subtract(logtxt_dt).TotalMilliseconds).Append("ms Total: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n");
logtxt_dt = DateTime.Now;
}
using (var dr = await cmd.ExecuteReaderAsync()) {
using (var dr = await pc.cmd.ExecuteReaderAsync()) {
if (IsTracePerformance) logtxt.Append("ExecuteReaderAsync: ").Append(DateTime.Now.Subtract(logtxt_dt).TotalMilliseconds).Append("ms Total: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n");
while (true) {
if (IsTracePerformance) logtxt_dt = DateTime.Now;
@ -132,18 +130,17 @@ namespace FreeSql.Internal.CommonProvider {
ReturnConnection(pool, conn, ex); //pool.Return(conn, ex);
if (IsTracePerformance) logtxt.Append("ReleaseConnection: ").Append(DateTime.Now.Subtract(logtxt_dt).TotalMilliseconds).Append("ms Total: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms");
}
LoggerException(pool, cmd, ex, dt, logtxt);
cmd.Parameters.Clear();
LoggerException(pool, pc, ex, dt, logtxt);
pc.cmd.Parameters.Clear();
}
public Task<object[][]> ExecuteArrayAsync(string cmdText, object parms = null) => ExecuteArrayAsync(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteArrayAsync(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<object[][]> ExecuteArrayAsync(DbConnection connection, string cmdText, object parms = null) => ExecuteArrayAsync(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteArrayAsync(null, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<object[][]> ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteArrayAsync(connection, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<object[][]> ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArrayAsync(null, null, cmdType, cmdText, cmdParms);
public Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArrayAsync(transaction, null, cmdType, cmdText, cmdParms);
public Task<object[][]> ExecuteArrayAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArrayAsync(null, connection, cmdType, cmdText, cmdParms);
async Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArrayAsync(null, transaction, cmdType, cmdText, cmdParms);
async public Task<object[][]> ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
List<object[]> ret = new List<object[]>();
await ExecuteReaderAsync(transaction, connection, async dr => {
await ExecuteReaderAsync(connection, 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);
@ -151,14 +148,13 @@ namespace FreeSql.Internal.CommonProvider {
return ret.ToArray();
}
public Task<DataTable> ExecuteDataTableAsync(string cmdText, object parms = null) => ExecuteDataTableAsync(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTableAsync(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<DataTable> ExecuteDataTableAsync(DbConnection connection, string cmdText, object parms = null) => ExecuteDataTableAsync(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTableAsync(null, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<DataTable> ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTableAsync(connection, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<DataTable> ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTableAsync(null, null, cmdType, cmdText, cmdParms);
public Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTableAsync(transaction, null, cmdType, cmdText, cmdParms);
public Task<DataTable> ExecuteDataTableAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTableAsync(null, connection, cmdType, cmdText, cmdParms);
async Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTableAsync(null, transaction, cmdType, cmdText, cmdParms);
async public Task<DataTable> ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var ret = new DataTable();
await ExecuteReaderAsync(transaction, connection, async dr => {
await ExecuteReaderAsync(connection, 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];
@ -168,23 +164,22 @@ namespace FreeSql.Internal.CommonProvider {
return ret;
}
public Task<int> ExecuteNonQueryAsync(string cmdText, object parms = null) => ExecuteNonQueryAsync(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<int> ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQueryAsync(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<int> ExecuteNonQueryAsync(DbConnection connection, string cmdText, object parms = null) => ExecuteNonQueryAsync(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<int> ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQueryAsync(null, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<int> ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQueryAsync(connection, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<int> ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(null, null, cmdType, cmdText, cmdParms);
public Task<int> ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(transaction, null, cmdType, cmdText, cmdParms);
public Task<int> ExecuteNonQueryAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(null, connection, cmdType, cmdText, cmdParms);
async Task<int> ExecuteNonQueryAsync(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public Task<int> ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(null, transaction, cmdType, cmdText, cmdParms);
async public Task<int> ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
if (string.IsNullOrEmpty(cmdText)) return 0;
var dt = DateTime.Now;
var logtxt = new StringBuilder();
var logtxt_dt = DateTime.Now;
Object<DbConnection> conn = null;
var cmd = PrepareCommandAsync(transaction, connection, cmdType, cmdText, cmdParms, logtxt);
var pc = await PrepareCommandAsync(connection, transaction, cmdType, cmdText, cmdParms, logtxt);
int val = 0;
Exception ex = null;
try {
if (cmd.Connection == null) cmd.Connection = (conn = await this.MasterPool.GetAsync()).Value;
val = await cmd.ExecuteNonQueryAsync();
if (pc.cmd.Connection == null) pc.cmd.Connection = (conn = await this.MasterPool.GetAsync()).Value;
val = await pc.cmd.ExecuteNonQueryAsync();
} catch (Exception ex2) {
ex = ex2;
}
@ -194,28 +189,27 @@ namespace FreeSql.Internal.CommonProvider {
ReturnConnection(MasterPool, conn, ex); //this.MasterPool.Return(conn, ex);
if (IsTracePerformance) logtxt.Append("ReleaseConnection: ").Append(DateTime.Now.Subtract(logtxt_dt).TotalMilliseconds).Append("ms Total: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms");
}
LoggerException(this.MasterPool, cmd, ex, dt, logtxt);
cmd.Parameters.Clear();
LoggerException(this.MasterPool, pc, ex, dt, logtxt);
pc.cmd.Parameters.Clear();
return val;
}
public Task<object> ExecuteScalarAsync(string cmdText, object parms = null) => ExecuteScalarAsync(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<object> ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalarAsync(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<object> ExecuteScalarAsync(DbConnection connection, string cmdText, object parms = null) => ExecuteScalarAsync(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<object> ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalarAsync(null, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<object> ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalarAsync(connection, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<object> ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(null, null, cmdType, cmdText, cmdParms);
public Task<object> ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(transaction, null, cmdType, cmdText, cmdParms);
public Task<object> ExecuteScalarAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(null, connection, cmdType, cmdText, cmdParms);
async Task<object> ExecuteScalarAsync(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
public Task<object> ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(null, transaction, cmdType, cmdText, cmdParms);
async public Task<object> ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
if (string.IsNullOrEmpty(cmdText)) return null;
var dt = DateTime.Now;
var logtxt = new StringBuilder();
var logtxt_dt = DateTime.Now;
Object<DbConnection> conn = null;
var cmd = PrepareCommandAsync(transaction, connection, cmdType, cmdText, cmdParms, logtxt);
var pc = await PrepareCommandAsync(connection, transaction, cmdType, cmdText, cmdParms, logtxt);
object val = null;
Exception ex = null;
try {
if (cmd.Connection == null) cmd.Connection = (conn = await this.MasterPool.GetAsync()).Value;
val = await cmd.ExecuteScalarAsync();
if (pc.cmd.Connection == null) pc.cmd.Connection = (conn = await this.MasterPool.GetAsync()).Value;
val = await pc.cmd.ExecuteScalarAsync();
} catch (Exception ex2) {
ex = ex2;
}
@ -225,14 +219,15 @@ namespace FreeSql.Internal.CommonProvider {
ReturnConnection(MasterPool, conn, ex); //this.MasterPool.Return(conn, ex);
if (IsTracePerformance) logtxt.Append("ReleaseConnection: ").Append(DateTime.Now.Subtract(logtxt_dt).TotalMilliseconds).Append("ms Total: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms");
}
LoggerException(this.MasterPool, cmd, ex, dt, logtxt);
cmd.Parameters.Clear();
LoggerException(this.MasterPool, pc, ex, dt, logtxt);
pc.cmd.Parameters.Clear();
return val;
}
private DbCommand PrepareCommandAsync(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, DbParameter[] cmdParms, StringBuilder logtxt) {
async Task<(DbCommand cmd, bool isclose)> PrepareCommandAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, StringBuilder logtxt) {
DateTime dt = DateTime.Now;
DbCommand cmd = CreateCommand();
bool isclose = false;
cmd.CommandType = cmdType;
cmd.CommandText = cmdText;
@ -244,20 +239,29 @@ namespace FreeSql.Internal.CommonProvider {
}
}
var tran = transaction;
if (connection == null) {
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");
} else
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");
}
} else {
if (connection.State != ConnectionState.Open) {
if (IsTracePerformance) dt = DateTime.Now;
await connection.OpenAsync();
if (IsTracePerformance) logtxt.Append(" PrepareCommand_ConnectionOpenAsync: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n");
isclose = true;
}
cmd.Connection = connection;
}
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;
return (cmd, isclose);
}
}
}

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

@ -38,27 +38,28 @@ namespace FreeSql.Internal.CommonProvider {
_params.Clear();
}
public IDelete<T1> WithTransaction(DbTransaction transaction) {
_transaction = transaction;
_connection = _transaction?.Connection;
return this;
}
public IDelete<T1> WithConnection(DbConnection coinnection) {
_connection = coinnection;
public IDelete<T1> WithConnection(DbConnection connection) {
if (_transaction?.Connection != connection) _transaction = null;
_connection = connection;
return this;
}
public int ExecuteAffrows() {
var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0;
var affrows = _orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, sql, _params.ToArray());
var affrows = _orm.Ado.ExecuteNonQuery(_connection, _transaction, CommandType.Text, sql, _params.ToArray());
this.ClearData();
return affrows;
}
async public Task<int> ExecuteAffrowsAsync() {
var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0;
var affrows = await _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, sql, _params.ToArray());
var affrows = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _params.ToArray());
this.ClearData();
return affrows;
}

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

@ -41,10 +41,12 @@ namespace FreeSql.Internal.CommonProvider {
public IInsert<T1> WithTransaction(DbTransaction transaction) {
_transaction = transaction;
_connection = _transaction?.Connection;
return this;
}
public IInsert<T1> WithConnection(DbConnection coinnection) {
_connection = coinnection;
public IInsert<T1> WithConnection(DbConnection connection) {
if (_transaction?.Connection != connection) _transaction = null;
_connection = connection;
return this;
}
@ -321,8 +323,8 @@ namespace FreeSql.Internal.CommonProvider {
}
#endregion
internal int RawExecuteAffrows() => _orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, ToSql(), _params);
internal Task<int> RawExecuteAffrowsAsync() => _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, ToSql(), _params);
internal int RawExecuteAffrows() => _orm.Ado.ExecuteNonQuery(_connection, _transaction, CommandType.Text, ToSql(), _params);
internal Task<int> RawExecuteAffrowsAsync() => _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, ToSql(), _params);
internal abstract long RawExecuteIdentity();
internal abstract Task<long> RawExecuteIdentityAsync();
internal abstract List<T1> RawExecuteInserted();

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

@ -82,10 +82,12 @@ namespace FreeSql.Internal.CommonProvider {
public TSelect WithTransaction(DbTransaction transaction) {
_transaction = transaction;
_connection = _transaction?.Connection;
return this as TSelect;
}
public TSelect WithConnection(DbConnection coinnection) {
_connection = coinnection;
public TSelect WithConnection(DbConnection connection) {
if (_transaction?.Connection != connection) _transaction = null;
_connection = connection;
return this as TSelect;
}
@ -207,14 +209,14 @@ namespace FreeSql.Internal.CommonProvider {
if (_cache.seconds > 0 && string.IsNullOrEmpty(_cache.key)) _cache.key = sql;
return _orm.Cache.Shell(_cache.key, _cache.seconds, () =>
_orm.Ado.ExecuteDataTable(_transaction?.Connection ?? _connection, CommandType.Text, sql, _params.ToArray()));
_orm.Ado.ExecuteDataTable(_connection, _transaction, CommandType.Text, sql, _params.ToArray()));
}
public Task<DataTable> ToDataTableAsync(string field = null) {
var sql = this.ToSql(field);
if (_cache.seconds > 0 && string.IsNullOrEmpty(_cache.key)) _cache.key = sql;
return _orm.Cache.ShellAsync(_cache.key, _cache.seconds, () =>
_orm.Ado.ExecuteDataTableAsync(_transaction?.Connection ?? _connection, CommandType.Text, sql, _params.ToArray()));
_orm.Ado.ExecuteDataTableAsync(_connection, _transaction, CommandType.Text, sql, _params.ToArray()));
}
public List<TTuple> ToList<TTuple>(string field) {
@ -224,7 +226,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(_transaction?.Connection ?? _connection, dr => {
_orm.Ado.ExecuteReader(_connection, _transaction, dr => {
var read = Utils.ExecuteArrayRowReadClassOrTuple(type, null, dr, 0, _commonUtils);
ret.Add((TTuple)read.Value);
}, CommandType.Text, sql, _params.ToArray());
@ -240,7 +242,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(_transaction, dr => {
await _orm.Ado.ExecuteReaderAsync(_connection, _transaction, dr => {
var read = Utils.ExecuteArrayRowReadClassOrTuple(type, null, dr, 0, _commonUtils);
ret.Add((TTuple)read.Value);
return Task.CompletedTask;
@ -257,7 +259,7 @@ namespace FreeSql.Internal.CommonProvider {
return _orm.Cache.Shell(_cache.key, _cache.seconds, () => {
List<T1> ret = new List<T1>();
_orm.Ado.ExecuteReader(_transaction, dr => {
_orm.Ado.ExecuteReader(_connection, _transaction, dr => {
ret.Add(af.Read(_orm, dr));
}, CommandType.Text, sql, _params.ToArray());
_orm.Aop.ToList?.Invoke(this, new AopToListEventArgs(ret));
@ -272,7 +274,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(_transaction, dr => {
await _orm.Ado.ExecuteReaderAsync(_connection, _transaction, dr => {
ret.Add(af.Read(_orm, dr));
return Task.CompletedTask;
}, CommandType.Text, sql, _params.ToArray());
@ -300,7 +302,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(_transaction, dr => {
_orm.Ado.ExecuteReader(_connection, _transaction, dr => {
var index = -1;
ret.Add((TReturn)_commonExpression.ReadAnonymous(af.map, dr, ref index, false));
}, CommandType.Text, sql, _params.ToArray());
@ -316,7 +318,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(_transaction, dr => {
await _orm.Ado.ExecuteReaderAsync(_connection, _transaction, dr => {
var index = -1;
ret.Add((TReturn)_commonExpression.ReadAnonymous(af.map, dr, ref index, false));
return Task.CompletedTask;
@ -564,8 +566,8 @@ namespace FreeSql.Internal.CommonProvider {
return this.ToSql(af.field);
}
protected DataTable InternalToDataTable(Expression select) => _orm.Ado.ExecuteDataTable(_transaction, CommandType.Text, this.InternalToSql<int>(select), _params.ToArray());
protected Task<DataTable> InternalToDataTableAsync(Expression select) => _orm.Ado.ExecuteDataTableAsync(_transaction, CommandType.Text, this.InternalToSql<int>(select), _params.ToArray());
protected DataTable InternalToDataTable(Expression select) => _orm.Ado.ExecuteDataTable(_connection, _transaction, CommandType.Text, this.InternalToSql<int>(select), _params.ToArray());
protected Task<DataTable> InternalToDataTableAsync(Expression select) => _orm.Ado.ExecuteDataTableAsync(_connection, _transaction, CommandType.Text, this.InternalToSql<int>(select), _params.ToArray());
protected TReturn InternalToAggregate<TReturn>(Expression select) {
var map = new ReadAnonymousTypeInfo();

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

@ -50,10 +50,12 @@ namespace FreeSql.Internal.CommonProvider {
public IUpdate<T1> WithTransaction(DbTransaction transaction) {
_transaction = transaction;
_connection = _transaction?.Connection;
return this;
}
public IUpdate<T1> WithConnection(DbConnection coinnection) {
_connection = coinnection;
public IUpdate<T1> WithConnection(DbConnection connection) {
if (_transaction?.Connection != connection) _transaction = null;
_connection = connection;
return this;
}
@ -237,14 +239,14 @@ namespace FreeSql.Internal.CommonProvider {
internal int RawExecuteAffrows() {
var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0;
var affrows = _orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, sql, _params.Concat(_paramsSource).ToArray());
var affrows = _orm.Ado.ExecuteNonQuery(_connection, _transaction, CommandType.Text, sql, _params.Concat(_paramsSource).ToArray());
ValidateVersionAndThrow(affrows);
return affrows;
}
async internal Task<int> RawExecuteAffrowsAsync() {
var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0;
var affrows = await _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, sql, _params.Concat(_paramsSource).ToArray());
var affrows = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _params.Concat(_paramsSource).ToArray());
ValidateVersionAndThrow(affrows);
return affrows;
}