From a4678ebdc36183fa1fc686e68261341cce6effbc Mon Sep 17 00:00:00 2001 From: 28810 <28810@YEXIANGQIN> Date: Wed, 10 Apr 2019 23:31:34 +0800 Subject: [PATCH] =?UTF-8?q?=E8=A1=A5=E5=85=85=20IAdo=20=E7=9B=B8=E5=85=B3?= =?UTF-8?q?=E6=96=B9=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../MySql/MySqlConnectionExtensionsTest.cs | 84 ------------ FreeSql/FreeSql.csproj | 2 +- FreeSql/Interface/IAdo.cs | 48 +++---- .../CommonProvider/AdoProvider/AdoProvider.cs | 122 +++++++++-------- .../AdoProvider/AdoProviderAsync.cs | 124 +++++++++--------- .../Internal/CommonProvider/DeleteProvider.cs | 11 +- .../Internal/CommonProvider/InsertProvider.cs | 10 +- .../SelectProvider/Select0Provider.cs | 26 ++-- .../Internal/CommonProvider/UpdateProvider.cs | 10 +- FreeSql/MySql/Curd/MySqlDelete.cs | 4 +- FreeSql/MySql/Curd/MySqlInsert.cs | 8 +- FreeSql/MySql/Curd/MySqlUpdate.cs | 4 +- FreeSql/MySql/MySqlAdo/MySqlAdo.cs | 11 +- FreeSql/MySql/MySqlConnectionExtensions.cs | 30 ----- FreeSql/MySql/MySqlProvider.cs | 12 +- FreeSql/Oracle/Curd/OracleInsert.cs | 8 +- FreeSql/Oracle/OracleAdo/OracleAdo.cs | 3 +- FreeSql/PostgreSQL/Curd/PostgreSQLDelete.cs | 4 +- FreeSql/PostgreSQL/Curd/PostgreSQLInsert.cs | 12 +- FreeSql/PostgreSQL/Curd/PostgreSQLUpdate.cs | 4 +- .../PostgreSQL/PostgreSQLAdo/PostgreSQLAdo.cs | 3 +- FreeSql/PostgreSQL/PostgreSQLProvider.cs | 54 ++++---- FreeSql/SqlServer/Curd/SqlServerDelete.cs | 4 +- FreeSql/SqlServer/Curd/SqlServerInsert.cs | 8 +- FreeSql/SqlServer/Curd/SqlServerUpdate.cs | 4 +- .../SqlServer/SqlServerAdo/SqlServerAdo.cs | 3 +- FreeSql/SqlServer/SqlServerProvider.cs | 11 +- FreeSql/Sqlite/Curd/SqliteInsert.cs | 4 +- FreeSql/Sqlite/SqliteAdo/SqliteAdo.cs | 3 +- 29 files changed, 269 insertions(+), 362 deletions(-) delete mode 100644 FreeSql.Tests/MySql/MySqlConnectionExtensionsTest.cs delete mode 100644 FreeSql/MySql/MySqlConnectionExtensions.cs diff --git a/FreeSql.Tests/MySql/MySqlConnectionExtensionsTest.cs b/FreeSql.Tests/MySql/MySqlConnectionExtensionsTest.cs deleted file mode 100644 index a2eeae5a..00000000 --- a/FreeSql.Tests/MySql/MySqlConnectionExtensionsTest.cs +++ /dev/null @@ -1,84 +0,0 @@ -using FreeSql.DataAnnotations; -using MySql.Data.MySqlClient; -using Newtonsoft.Json; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using Xunit; - -namespace FreeSql.Tests.MySql { - public class MySqlConnectionExtensions { - - string _connectString = "Data Source=127.0.0.1;Port=3306;User ID=root;Password=root;Initial Catalog=cccddd;Charset=utf8;SslMode=none;Max pool size=10"; - - [Fact] - public void Insert() { - var affrows = 0; - using (var conn = new MySqlConnection(_connectString)) { - var item = new TestConnectionExt { title = "testinsert" }; - affrows = conn.Insert().AppendData(item).ExecuteAffrows(); - conn.Close(); - } - Assert.Equal(1, affrows); - } - [Fact] - public void Update() { - var affrows = 0; - using (var conn = new MySqlConnection(_connectString)) { - var item = new TestConnectionExt { title = "testupdate" }; - affrows = conn.Insert().AppendData(item).ExecuteAffrows(); - Assert.Equal(1, affrows); - item = conn.Select().First(); - affrows = conn.Update().SetSource(item).Set(a => a.title, "testupdated").ExecuteAffrows(); - conn.Close(); - } - Assert.Equal(1, affrows); - } - [Fact] - public void Delete() { - var affrows = 0; - using (var conn = new MySqlConnection(_connectString)) { - var item = new TestConnectionExt { title = "testdelete" }; - affrows = conn.Insert().AppendData(item).ExecuteAffrows(); - Assert.Equal(1, affrows); - affrows = conn.Delete().Where(item).ExecuteAffrows(); - conn.Close(); - } - Assert.Equal(1, affrows); - } - [Fact] - public void Select() { - var list = new List(); - var affrows = 0; - using (var conn = new MySqlConnection(_connectString)) { - var item = new TestConnectionExt { title = "testselect" }; - affrows = conn.Insert().AppendData(item).ExecuteAffrows(); - Assert.Equal(1, affrows); - list = conn.Select().Where(a => a.id == item.id).ToList(); - conn.Close(); - } - Assert.Single(list); - } - - [Fact] - public void Query() { - var list = new List(); - var affrows = 0; - using (var conn = new MySqlConnection(_connectString)) { - var item = new TestConnectionExt { title = "testquery" }; - affrows = conn.Insert().AppendData(item).ExecuteAffrows(); - Assert.Equal(1, affrows); - list = conn.Query("select * from TestConnectionExt where id = ?id", new { id = item.id }); - conn.Close(); - } - Assert.Single(list); - } - - class TestConnectionExt { - public Guid id { get; set; } - public string title { get; set; } - public DateTime createTime { get; set; } = DateTime.Now; - } - } -} diff --git a/FreeSql/FreeSql.csproj b/FreeSql/FreeSql.csproj index ac4e0642..1d69dcc2 100644 --- a/FreeSql/FreeSql.csproj +++ b/FreeSql/FreeSql.csproj @@ -2,7 +2,7 @@ netstandard2.0 - 0.4.9 + 0.4.10 true YeXiangQin FreeSql is the most convenient ORM in dotnet. It supports Mysql, Postgresql, SqlServer, Oracle and Sqlite. diff --git a/FreeSql/Interface/IAdo.cs b/FreeSql/Interface/IAdo.cs index 627ba325..d27b9f24 100644 --- a/FreeSql/Interface/IAdo.cs +++ b/FreeSql/Interface/IAdo.cs @@ -62,7 +62,7 @@ namespace FreeSql { /// void ExecuteReader(Action readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); void ExecuteReader(DbTransaction transaction, Action readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - void ExecuteReader(DbConnection connection, Action readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); + void ExecuteReader(DbConnection connection, DbTransaction transaction, Action readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); /// /// 查询，ExecuteReader(dr => {}, "select * from user where age > @age", new { age = 25 }) /// @@ -70,7 +70,7 @@ namespace FreeSql { /// void ExecuteReader(Action readerHander, string cmdText, object parms = null); void ExecuteReader(DbTransaction transaction, Action readerHander, string cmdText, object parms = null); - void ExecuteReader(DbConnection connection, Action readerHander, string cmdText, object parms = null); + void ExecuteReader(DbConnection connection, DbTransaction transaction, Action readerHander, string cmdText, object parms = null); /// /// 查询 /// @@ -78,7 +78,7 @@ namespace FreeSql { /// object[][] ExecuteArray(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); object[][] ExecuteArray(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - object[][] ExecuteArray(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); + object[][] ExecuteArray(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); /// /// 查询，ExecuteArray("select * from user where age > @age", new { age = 25 }) /// @@ -87,7 +87,7 @@ namespace FreeSql { /// object[][] ExecuteArray(string cmdText, object parms = null); object[][] ExecuteArray(DbTransaction transaction, string cmdText, object parms = null); - object[][] ExecuteArray(DbConnection connection, string cmdText, object parms = null); + object[][] ExecuteArray(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); /// /// 查询 /// @@ -95,7 +95,7 @@ namespace FreeSql { /// DataTable ExecuteDataTable(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); DataTable ExecuteDataTable(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - DataTable ExecuteDataTable(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); + DataTable ExecuteDataTable(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); /// /// 查询，ExecuteDataTable("select * from user where age > @age", new { age = 25 }) /// @@ -104,7 +104,7 @@ namespace FreeSql { /// DataTable ExecuteDataTable(string cmdText, object parms = null); DataTable ExecuteDataTable(DbTransaction transaction, string cmdText, object parms = null); - DataTable ExecuteDataTable(DbConnection connection, string cmdText, object parms = null); + DataTable ExecuteDataTable(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); /// /// 在【主库】执行 /// @@ -113,7 +113,7 @@ namespace FreeSql { /// int ExecuteNonQuery(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); int ExecuteNonQuery(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - int ExecuteNonQuery(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); + int ExecuteNonQuery(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); /// /// 在【主库】执行，ExecuteNonQuery("delete from user where age > @age", new { age = 25 }) /// @@ -122,7 +122,7 @@ namespace FreeSql { /// int ExecuteNonQuery(string cmdText, object parms = null); int ExecuteNonQuery(DbTransaction transaction, string cmdText, object parms = null); - int ExecuteNonQuery(DbConnection connection, string cmdText, object parms = null); + int ExecuteNonQuery(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); /// /// 在【主库】执行 /// @@ -131,7 +131,7 @@ namespace FreeSql { /// object ExecuteScalar(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); object ExecuteScalar(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - object ExecuteScalar(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); + object ExecuteScalar(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); /// /// 在【主库】执行，ExecuteScalar("select 1 from user where age > @age", new { age = 25 }) /// @@ -140,7 +140,7 @@ namespace FreeSql { /// object ExecuteScalar(string cmdText, object parms = null); object ExecuteScalar(DbTransaction transaction, string cmdText, object parms = null); - object ExecuteScalar(DbConnection connection, string cmdText, object parms = null); + object ExecuteScalar(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); /// /// 执行SQL返回对象集合，Query<User>("select * from user where age > @age", new SqlParameter { ParameterName = "age", Value = 25 }) @@ -152,7 +152,7 @@ namespace FreeSql { /// List Query(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); List Query(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - List Query(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); + List Query(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); /// /// 执行SQL返回对象集合，Query<User>("select * from user where age > @age", new { age = 25 }) /// @@ -162,7 +162,7 @@ namespace FreeSql { /// List Query(string cmdText, object parms = null); List Query(DbTransaction transaction, string cmdText, object parms = null); - List Query(DbConnection connection, string cmdText, object parms = null); + List Query(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); #region async /// @@ -174,7 +174,7 @@ namespace FreeSql { /// Task ExecuteReaderAsync(Func readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task ExecuteReaderAsync(DbTransaction transaction, Func readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task ExecuteReaderAsync(DbConnection connection, Func readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); + Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); /// /// 查询，ExecuteReaderAsync(dr => {}, "select * from user where age > @age", new { age = 25 }) /// @@ -182,7 +182,7 @@ namespace FreeSql { /// Task ExecuteReaderAsync(Func readerHander, string cmdText, object parms = null); Task ExecuteReaderAsync(DbTransaction transaction, Func readerHander, string cmdText, object parms = null); - Task ExecuteReaderAsync(DbConnection connection, Func readerHander, string cmdText, object parms = null); + Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func readerHander, string cmdText, object parms = null); /// /// 查询 /// @@ -190,7 +190,7 @@ namespace FreeSql { /// Task ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task ExecuteArrayAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); + Task ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); /// /// 查询，ExecuteArrayAsync("select * from user where age > @age", new { age = 25 }) /// @@ -199,7 +199,7 @@ namespace FreeSql { /// Task ExecuteArrayAsync(string cmdText, object parms = null); Task ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null); - Task ExecuteArrayAsync(DbConnection connection, string cmdText, object parms = null); + Task ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); /// /// 查询 /// @@ -207,7 +207,7 @@ namespace FreeSql { /// Task ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task ExecuteDataTableAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); + Task ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); /// /// 查询，ExecuteDataTableAsync("select * from user where age > @age", new { age = 25 }) /// @@ -216,7 +216,7 @@ namespace FreeSql { /// Task ExecuteDataTableAsync(string cmdText, object parms = null); Task ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null); - Task ExecuteDataTableAsync(DbConnection connection, string cmdText, object parms = null); + Task ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); /// /// 在【主库】执行 /// @@ -225,7 +225,7 @@ namespace FreeSql { /// Task ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task ExecuteNonQueryAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); + Task ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); /// /// 在【主库】执行，ExecuteNonQueryAsync("delete from user where age > @age", new { age = 25 }) /// @@ -234,7 +234,7 @@ namespace FreeSql { /// Task ExecuteNonQueryAsync(string cmdText, object parms = null); Task ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null); - Task ExecuteNonQueryAsync(DbConnection connection, string cmdText, object parms = null); + Task ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); /// /// 在【主库】执行 /// @@ -243,7 +243,7 @@ namespace FreeSql { /// Task ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task ExecuteScalarAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); + Task ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); /// /// 在【主库】执行，ExecuteScalarAsync("select 1 from user where age > @age", new { age = 25 }) /// @@ -252,7 +252,7 @@ namespace FreeSql { /// Task ExecuteScalarAsync(string cmdText, object parms = null); Task ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null); - Task ExecuteScalarAsync(DbConnection connection, string cmdText, object parms = null); + Task ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); /// /// 执行SQL返回对象集合，QueryAsync<User>("select * from user where age > @age", new SqlParameter { ParameterName = "age", Value = 25 }) @@ -264,7 +264,7 @@ namespace FreeSql { /// Task> QueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task> QueryAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); + Task> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); /// /// 执行SQL返回对象集合，QueryAsync<User>("select * from user where age > @age", new { age = 25 }) /// @@ -274,7 +274,7 @@ namespace FreeSql { /// Task> QueryAsync(string cmdText, object parms = null); Task> QueryAsync(DbTransaction transaction, string cmdText, object parms = null); - Task> QueryAsync(DbConnection connection, string cmdText, object parms = null); + Task> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); #endregion } } diff --git a/FreeSql/Internal/CommonProvider/AdoProvider/AdoProvider.cs b/FreeSql/Internal/CommonProvider/AdoProvider/AdoProvider.cs index fb9a7554..556e02aa 100644 --- a/FreeSql/Internal/CommonProvider/AdoProvider/AdoProvider.cs +++ b/FreeSql/Internal/CommonProvider/AdoProvider/AdoProvider.cs @@ -37,7 +37,9 @@ namespace FreeSql.Internal.CommonProvider { this.DataType = dataType; } - void LoggerException(ObjectPool pool, DbCommand cmd, Exception e, DateTime dt, StringBuilder logtxt, bool isThrowException = true) { + void LoggerException(ObjectPool 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 dicQueryTypeGetProperties = new ConcurrentDictionary(); public List Query(string cmdText, object parms = null) => Query(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public List Query(DbTransaction transaction, string cmdText, object parms = null) => Query(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public List Query(DbConnection connection, string cmdText, object parms = null) => Query(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); + public List Query(DbTransaction transaction, string cmdText, object parms = null) => Query(null, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); + public List Query(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => Query(connection, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public List Query(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => Query(null, null, cmdType, cmdText, cmdParms); - public List Query(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => Query(transaction, null, cmdType, cmdText, cmdParms); - public List Query(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => Query(null, connection, cmdType, cmdText, cmdParms); - List Query(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { + public List Query(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => Query(null, transaction, cmdType, cmdText, cmdParms); + public List Query(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { var ret = new List(); 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(StringComparer.CurrentCultureIgnoreCase); for (var a = 0; a < dr.FieldCount; a++) @@ -98,12 +99,11 @@ namespace FreeSql.Internal.CommonProvider { return ret; } public void ExecuteReader(Action readerHander, string cmdText, object parms = null) => ExecuteReader(null, null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public void ExecuteReader(DbTransaction transaction, Action readerHander, string cmdText, object parms = null) => ExecuteReader(transaction, null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public void ExecuteReader(DbConnection connection, Action readerHander, string cmdText, object parms = null) => ExecuteReader(null, connection, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); + public void ExecuteReader(DbTransaction transaction, Action readerHander, string cmdText, object parms = null) => ExecuteReader(null, transaction, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); + public void ExecuteReader(DbConnection connection, DbTransaction transaction, Action readerHander, string cmdText, object parms = null) => ExecuteReader(connection, transaction, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public void ExecuteReader(Action readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReader(null, null, readerHander, cmdType, cmdText, cmdParms); - public void ExecuteReader(DbTransaction transaction, Action readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReader(transaction, null, readerHander, cmdType, cmdText, cmdParms); - public void ExecuteReader(DbConnection connection, Action readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReader(null, connection, readerHander, cmdType, cmdText, cmdParms); - void ExecuteReader(DbTransaction transaction, DbConnection connection, Action readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { + public void ExecuteReader(DbTransaction transaction, Action readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReader(null, transaction, readerHander, cmdType, cmdText, cmdParms); + public void ExecuteReader(DbConnection connection, DbTransaction transaction, Action 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 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 ret = new List(); - 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 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 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); } } } diff --git a/FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderAsync.cs b/FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderAsync.cs index 1974c6e6..cf573637 100644 --- a/FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderAsync.cs +++ b/FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderAsync.cs @@ -10,18 +10,17 @@ using System.Threading.Tasks; namespace FreeSql.Internal.CommonProvider { partial class AdoProvider { public Task> QueryAsync(string cmdText, object parms = null) => QueryAsync(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task> QueryAsync(DbTransaction transaction, string cmdText, object parms = null) => QueryAsync(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task> QueryAsync(DbConnection connection, string cmdText, object parms = null) => QueryAsync(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); + public Task> QueryAsync(DbTransaction transaction, string cmdText, object parms = null) => QueryAsync(null, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); + public Task> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => QueryAsync(connection, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task> QueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync(null, null, cmdType, cmdText, cmdParms); - public Task> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync(transaction, null, cmdType, cmdText, cmdParms); - public Task> QueryAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync(null, connection, cmdType, cmdText, cmdParms); - async Task> QueryAsync(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { + public Task> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync(null, transaction, cmdType, cmdText, cmdParms); + async public Task> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { var ret = new List(); 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(StringComparer.CurrentCultureIgnoreCase); for (var a = 0; a < dr.FieldCount; a++) @@ -34,12 +33,11 @@ namespace FreeSql.Internal.CommonProvider { return ret; } public Task ExecuteReaderAsync(Func readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(null, null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteReaderAsync(DbTransaction transaction, Func readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(transaction, null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteReaderAsync(DbConnection connection, Func readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(null, connection, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); + public Task ExecuteReaderAsync(DbTransaction transaction, Func readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(null, transaction, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); + public Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(connection, transaction, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task ExecuteReaderAsync(Func readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(null, null, readerHander, cmdType, cmdText, cmdParms); - public Task ExecuteReaderAsync(DbTransaction transaction, Func readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(transaction, null, readerHander, cmdType, cmdText, cmdParms); - public Task ExecuteReaderAsync(DbConnection connection, Func readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(null, connection, readerHander, cmdType, cmdText, cmdParms); - async Task ExecuteReaderAsync(DbTransaction transaction, DbConnection connection, Func readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { + public Task ExecuteReaderAsync(DbTransaction transaction, Func readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(null, transaction, readerHander, cmdType, cmdText, cmdParms); + async public Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func 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 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 ExecuteArrayAsync(string cmdText, object parms = null) => ExecuteArrayAsync(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteArrayAsync(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteArrayAsync(DbConnection connection, string cmdText, object parms = null) => ExecuteArrayAsync(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); + public Task ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteArrayAsync(null, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); + public Task ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteArrayAsync(connection, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArrayAsync(null, null, cmdType, cmdText, cmdParms); - public Task ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArrayAsync(transaction, null, cmdType, cmdText, cmdParms); - public Task ExecuteArrayAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArrayAsync(null, connection, cmdType, cmdText, cmdParms); - async Task ExecuteArrayAsync(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { + public Task ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArrayAsync(null, transaction, cmdType, cmdText, cmdParms); + async public Task ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { List ret = new List(); - 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(a); ret.Add(values); @@ -151,14 +148,13 @@ namespace FreeSql.Internal.CommonProvider { return ret.ToArray(); } public Task ExecuteDataTableAsync(string cmdText, object parms = null) => ExecuteDataTableAsync(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTableAsync(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteDataTableAsync(DbConnection connection, string cmdText, object parms = null) => ExecuteDataTableAsync(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); + public Task ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTableAsync(null, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); + public Task ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTableAsync(connection, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTableAsync(null, null, cmdType, cmdText, cmdParms); - public Task ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTableAsync(transaction, null, cmdType, cmdText, cmdParms); - public Task ExecuteDataTableAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTableAsync(null, connection, cmdType, cmdText, cmdParms); - async Task ExecuteDataTableAsync(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { + public Task ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTableAsync(null, transaction, cmdType, cmdText, cmdParms); + async public Task 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 ExecuteNonQueryAsync(string cmdText, object parms = null) => ExecuteNonQueryAsync(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQueryAsync(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteNonQueryAsync(DbConnection connection, string cmdText, object parms = null) => ExecuteNonQueryAsync(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); + public Task ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQueryAsync(null, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); + public Task ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQueryAsync(connection, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(null, null, cmdType, cmdText, cmdParms); - public Task ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(transaction, null, cmdType, cmdText, cmdParms); - public Task ExecuteNonQueryAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(null, connection, cmdType, cmdText, cmdParms); - async Task ExecuteNonQueryAsync(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { + public Task ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(null, transaction, cmdType, cmdText, cmdParms); + async public Task 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 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 ExecuteScalarAsync(string cmdText, object parms = null) => ExecuteScalarAsync(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalarAsync(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteScalarAsync(DbConnection connection, string cmdText, object parms = null) => ExecuteScalarAsync(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); + public Task ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalarAsync(null, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); + public Task ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalarAsync(connection, transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(null, null, cmdType, cmdText, cmdParms); - public Task ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(transaction, null, cmdType, cmdText, cmdParms); - public Task ExecuteScalarAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(null, connection, cmdType, cmdText, cmdParms); - async Task ExecuteScalarAsync(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { + public Task ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(null, transaction, cmdType, cmdText, cmdParms); + async public Task 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 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); } } } diff --git a/FreeSql/Internal/CommonProvider/DeleteProvider.cs b/FreeSql/Internal/CommonProvider/DeleteProvider.cs index 7c7bac76..a23d8478 100644 --- a/FreeSql/Internal/CommonProvider/DeleteProvider.cs +++ b/FreeSql/Internal/CommonProvider/DeleteProvider.cs @@ -38,27 +38,28 @@ namespace FreeSql.Internal.CommonProvider { _params.Clear(); } - public IDelete WithTransaction(DbTransaction transaction) { _transaction = transaction; + _connection = _transaction?.Connection; return this; } - public IDelete WithConnection(DbConnection coinnection) { - _connection = coinnection; + public IDelete 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 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; } diff --git a/FreeSql/Internal/CommonProvider/InsertProvider.cs b/FreeSql/Internal/CommonProvider/InsertProvider.cs index eb9c8928..c0995198 100644 --- a/FreeSql/Internal/CommonProvider/InsertProvider.cs +++ b/FreeSql/Internal/CommonProvider/InsertProvider.cs @@ -41,10 +41,12 @@ namespace FreeSql.Internal.CommonProvider { public IInsert WithTransaction(DbTransaction transaction) { _transaction = transaction; + _connection = _transaction?.Connection; return this; } - public IInsert WithConnection(DbConnection coinnection) { - _connection = coinnection; + public IInsert 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 RawExecuteAffrowsAsync() => _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, ToSql(), _params); + internal int RawExecuteAffrows() => _orm.Ado.ExecuteNonQuery(_connection, _transaction, CommandType.Text, ToSql(), _params); + internal Task RawExecuteAffrowsAsync() => _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, ToSql(), _params); internal abstract long RawExecuteIdentity(); internal abstract Task RawExecuteIdentityAsync(); internal abstract List RawExecuteInserted(); diff --git a/FreeSql/Internal/CommonProvider/SelectProvider/Select0Provider.cs b/FreeSql/Internal/CommonProvider/SelectProvider/Select0Provider.cs index 41e8f70f..307849e9 100644 --- a/FreeSql/Internal/CommonProvider/SelectProvider/Select0Provider.cs +++ b/FreeSql/Internal/CommonProvider/SelectProvider/Select0Provider.cs @@ -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 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 ToList(string field) { @@ -224,7 +226,7 @@ namespace FreeSql.Internal.CommonProvider { return _orm.Cache.Shell(_cache.key, _cache.seconds, () => { List ret = new List(); 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 ret = new List(); 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 ret = new List(); - _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 ret = new List(); - 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 ret = new List(); 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 ret = new List(); 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(select), _params.ToArray()); - protected Task InternalToDataTableAsync(Expression select) => _orm.Ado.ExecuteDataTableAsync(_transaction, CommandType.Text, this.InternalToSql(select), _params.ToArray()); + protected DataTable InternalToDataTable(Expression select) => _orm.Ado.ExecuteDataTable(_connection, _transaction, CommandType.Text, this.InternalToSql(select), _params.ToArray()); + protected Task InternalToDataTableAsync(Expression select) => _orm.Ado.ExecuteDataTableAsync(_connection, _transaction, CommandType.Text, this.InternalToSql(select), _params.ToArray()); protected TReturn InternalToAggregate(Expression select) { var map = new ReadAnonymousTypeInfo(); diff --git a/FreeSql/Internal/CommonProvider/UpdateProvider.cs b/FreeSql/Internal/CommonProvider/UpdateProvider.cs index 635fb3ad..dad1d1fc 100644 --- a/FreeSql/Internal/CommonProvider/UpdateProvider.cs +++ b/FreeSql/Internal/CommonProvider/UpdateProvider.cs @@ -50,10 +50,12 @@ namespace FreeSql.Internal.CommonProvider { public IUpdate WithTransaction(DbTransaction transaction) { _transaction = transaction; + _connection = _transaction?.Connection; return this; } - public IUpdate WithConnection(DbConnection coinnection) { - _connection = coinnection; + public IUpdate 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 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; } diff --git a/FreeSql/MySql/Curd/MySqlDelete.cs b/FreeSql/MySql/Curd/MySqlDelete.cs index ec055aec..f95d7b4a 100644 --- a/FreeSql/MySql/Curd/MySqlDelete.cs +++ b/FreeSql/MySql/Curd/MySqlDelete.cs @@ -24,7 +24,7 @@ namespace FreeSql.MySql.Curd { sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); ++colidx; } - var ret = _orm.Ado.Query(_transaction, CommandType.Text, sb.ToString(), _params.ToArray()); + var ret = _orm.Ado.Query(_connection, _transaction, CommandType.Text, sb.ToString(), _params.ToArray()); this.ClearData(); return ret; } @@ -41,7 +41,7 @@ namespace FreeSql.MySql.Curd { sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); ++colidx; } - var ret = await _orm.Ado.QueryAsync(_transaction, CommandType.Text, sb.ToString(), _params.ToArray()); + var ret = await _orm.Ado.QueryAsync(_connection, _transaction, CommandType.Text, sb.ToString(), _params.ToArray()); this.ClearData(); return ret; } diff --git a/FreeSql/MySql/Curd/MySqlInsert.cs b/FreeSql/MySql/Curd/MySqlInsert.cs index 8c2da2ba..f9d6a3f5 100644 --- a/FreeSql/MySql/Curd/MySqlInsert.cs +++ b/FreeSql/MySql/Curd/MySqlInsert.cs @@ -23,13 +23,13 @@ namespace FreeSql.MySql.Curd { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; - return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_transaction, CommandType.Text, string.Concat(sql, "; SELECT LAST_INSERT_ID();"), _params)), out var trylng) ? trylng : 0; + return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_connection, _transaction, CommandType.Text, string.Concat(sql, "; SELECT LAST_INSERT_ID();"), _params)), out var trylng) ? trylng : 0; } async internal override Task RawExecuteIdentityAsync() { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; - return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_transaction, CommandType.Text, string.Concat(sql, "; SELECT LAST_INSERT_ID();"), _params)), out var trylng) ? trylng : 0; + return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, string.Concat(sql, "; SELECT LAST_INSERT_ID();"), _params)), out var trylng) ? trylng : 0; } internal override List RawExecuteInserted() { var sql = this.ToSql(); @@ -44,7 +44,7 @@ namespace FreeSql.MySql.Curd { sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); ++colidx; } - return _orm.Ado.Query(_transaction, CommandType.Text, sb.ToString(), _params); + return _orm.Ado.Query(_connection, _transaction, CommandType.Text, sb.ToString(), _params); } async internal override Task> RawExecuteInsertedAsync() { var sql = this.ToSql(); @@ -59,7 +59,7 @@ namespace FreeSql.MySql.Curd { sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); ++colidx; } - return await _orm.Ado.QueryAsync(_transaction, CommandType.Text, sb.ToString(), _params); + return await _orm.Ado.QueryAsync(_connection, _transaction, CommandType.Text, sb.ToString(), _params); } } } diff --git a/FreeSql/MySql/Curd/MySqlUpdate.cs b/FreeSql/MySql/Curd/MySqlUpdate.cs index d3e8329c..bf33467f 100644 --- a/FreeSql/MySql/Curd/MySqlUpdate.cs +++ b/FreeSql/MySql/Curd/MySqlUpdate.cs @@ -33,7 +33,7 @@ namespace FreeSql.MySql.Curd { sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); ++colidx; } - var ret = _orm.Ado.Query(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); + var ret = _orm.Ado.Query(_connection, _transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); ValidateVersionAndThrow(ret.Count); return ret; } @@ -50,7 +50,7 @@ namespace FreeSql.MySql.Curd { sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); ++colidx; } - var ret = await _orm.Ado.QueryAsync(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); + var ret = await _orm.Ado.QueryAsync(_connection, _transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); ValidateVersionAndThrow(ret.Count); return ret; } diff --git a/FreeSql/MySql/MySqlAdo/MySqlAdo.cs b/FreeSql/MySql/MySqlAdo/MySqlAdo.cs index 5e623332..684b6244 100644 --- a/FreeSql/MySql/MySqlAdo/MySqlAdo.cs +++ b/FreeSql/MySql/MySqlAdo/MySqlAdo.cs @@ -14,13 +14,12 @@ namespace FreeSql.MySql { public MySqlAdo() : base(null, null, DataType.MySql) { } public MySqlAdo(CommonUtils util, ICache cache, ILogger log, string masterConnectionString, string[] slaveConnectionStrings) : base(cache, log, DataType.MySql) { base._util = util; - if (!string.IsNullOrEmpty(masterConnectionString)) { + if (!string.IsNullOrEmpty(masterConnectionString)) MasterPool = new MySqlConnectionPool("主库", masterConnectionString, null, null); - if (slaveConnectionStrings != null) { - foreach (var slaveConnectionString in slaveConnectionStrings) { - var slavePool = new MySqlConnectionPool($"从库{SlavePools.Count + 1}", slaveConnectionString, () => Interlocked.Decrement(ref slaveUnavailables), () => Interlocked.Increment(ref slaveUnavailables)); - SlavePools.Add(slavePool); - } + if (slaveConnectionStrings != null) { + foreach (var slaveConnectionString in slaveConnectionStrings) { + var slavePool = new MySqlConnectionPool($"从库{SlavePools.Count + 1}", slaveConnectionString, () => Interlocked.Decrement(ref slaveUnavailables), () => Interlocked.Increment(ref slaveUnavailables)); + SlavePools.Add(slavePool); } } } diff --git a/FreeSql/MySql/MySqlConnectionExtensions.cs b/FreeSql/MySql/MySqlConnectionExtensions.cs deleted file mode 100644 index 5b9f3173..00000000 --- a/FreeSql/MySql/MySqlConnectionExtensions.cs +++ /dev/null @@ -1,30 +0,0 @@ -using FreeSql.MySql; -using FreeSql.MySql.Curd; -using Microsoft.Extensions.Logging; -using MySql.Data.MySqlClient; -using System; -using System.Collections.Generic; -using System.Data; -using System.Data.Common; -using System.Text; - -namespace FreeSql { - public static class MySqlConnectionExtensions { - - static IFreeSql _curd = new MySqlProvider(null, new LoggerFactory().CreateLogger("MySqlConnectionExtensions"), null, null); - - public static ISelect Select(this MySqlConnection that) where T1 : class => _curd.Select().WithConnection(that); - public static ISelect Select(this MySqlConnection that, object dywhere) where T1 : class => _curd.Select(dywhere).WithConnection(that); - public static IInsert Insert(this MySqlConnection that) where T1 : class => _curd.Insert().WithConnection(that); - public static IInsert Insert(this MySqlConnection that, T1 source) where T1 : class => _curd.Insert().WithConnection(that).AppendData(source); - public static IInsert Insert(this MySqlConnection that, T1[] source) where T1 : class => _curd.Insert().WithConnection(that).AppendData(source); - public static IInsert Insert(this MySqlConnection that, IEnumerable source) where T1 : class => _curd.Insert().WithConnection(that).AppendData(source); - public static IUpdate Update(this MySqlConnection that) where T1 : class => _curd.Update().WithConnection(that); - public static IUpdate Update(this MySqlConnection that, object dywhere) where T1 : class => _curd.Update(dywhere).WithConnection(that); - public static IDelete Delete(this MySqlConnection that) where T1 : class => _curd.Delete().WithConnection(that); - public static IDelete Delete(this MySqlConnection that, object dywhere) where T1 : class => _curd.Delete(dywhere).WithConnection(that); - - public static List Query(this MySqlConnection that, string cmdText, object parms = null) => _curd.Ado.Query(that, cmdText, parms); - public static List Query(this MySqlConnection that, CommandType cmdType, string cmdText, params MySqlParameter[] cmdParms) => _curd.Ado.Query(that, cmdText, cmdParms); - } -} diff --git a/FreeSql/MySql/MySqlProvider.cs b/FreeSql/MySql/MySqlProvider.cs index 5b12b1c7..22fb58be 100644 --- a/FreeSql/MySql/MySqlProvider.cs +++ b/FreeSql/MySql/MySqlProvider.cs @@ -13,12 +13,12 @@ namespace FreeSql.MySql { class MySqlProvider : IFreeSql { static MySqlProvider() { - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(MygisPoint), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(MygisLineString), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(MygisPolygon), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(MygisMultiPoint), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(MygisMultiLineString), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(MygisMultiPolygon), true); + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(MygisPoint)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(MygisLineString)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(MygisPolygon)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(MygisMultiPoint)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(MygisMultiLineString)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(MygisMultiPolygon)] = true; } public ISelect Select() where T1 : class => new MySqlSelect(this, this.InternalCommonUtils, this.InternalCommonExpression, null); diff --git a/FreeSql/Oracle/Curd/OracleInsert.cs b/FreeSql/Oracle/Curd/OracleInsert.cs index 33f243f8..90a4b810 100644 --- a/FreeSql/Oracle/Curd/OracleInsert.cs +++ b/FreeSql/Oracle/Curd/OracleInsert.cs @@ -88,13 +88,13 @@ namespace FreeSql.Oracle.Curd { if (string.IsNullOrEmpty(sql)) return 0; if (_identCol == null || _source.Count > 1) { - _orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, sql, _params); + _orm.Ado.ExecuteNonQuery(_connection, _transaction, CommandType.Text, sql, _params); return 0; } var identColName = _commonUtils.QuoteSqlName(_identCol.Attribute.Name); var identParam = _commonUtils.AppendParamter(null, $"{_identCol.CsName}99", _identCol.CsType, 0) as OracleParameter; identParam.Direction = ParameterDirection.Output; - _orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, $"{sql} RETURNING {identColName} INTO {identParam.ParameterName}", _params.Concat(new[] { identParam }).ToArray()); + _orm.Ado.ExecuteNonQuery(_connection, _transaction, CommandType.Text, $"{sql} RETURNING {identColName} INTO {identParam.ParameterName}", _params.Concat(new[] { identParam }).ToArray()); return long.TryParse(string.Concat(identParam.Value), out var trylng) ? trylng : 0; } async internal override Task RawExecuteIdentityAsync() { @@ -102,13 +102,13 @@ namespace FreeSql.Oracle.Curd { if (string.IsNullOrEmpty(sql)) return 0; if (_identCol == null || _source.Count > 1) { - await _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, sql, _params); + await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _params); return 0; } var identColName = _commonUtils.QuoteSqlName(_identCol.Attribute.Name); var identParam = _commonUtils.AppendParamter(null, $"{_identCol.CsName}99", _identCol.CsType, 0) as OracleParameter; identParam.Direction = ParameterDirection.Output; - await _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, $"{sql} RETURNING {identColName} INTO {identParam.ParameterName}", _params.Concat(new[] { identParam }).ToArray()); + await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, $"{sql} RETURNING {identColName} INTO {identParam.ParameterName}", _params.Concat(new[] { identParam }).ToArray()); return long.TryParse(string.Concat(identParam.Value), out var trylng) ? trylng : 0; } diff --git a/FreeSql/Oracle/OracleAdo/OracleAdo.cs b/FreeSql/Oracle/OracleAdo/OracleAdo.cs index a8db437a..83ae6f6c 100644 --- a/FreeSql/Oracle/OracleAdo/OracleAdo.cs +++ b/FreeSql/Oracle/OracleAdo/OracleAdo.cs @@ -13,7 +13,8 @@ namespace FreeSql.Oracle { public OracleAdo() : base(null, null, DataType.Oracle) { } public OracleAdo(CommonUtils util, ICache cache, ILogger log, string masterConnectionString, string[] slaveConnectionStrings) : base(cache, log, DataType.Oracle) { base._util = util; - MasterPool = new OracleConnectionPool("主库", masterConnectionString, null, null); + if (!string.IsNullOrEmpty(masterConnectionString)) + MasterPool = new OracleConnectionPool("主库", masterConnectionString, null, null); if (slaveConnectionStrings != null) { foreach (var slaveConnectionString in slaveConnectionStrings) { var slavePool = new OracleConnectionPool($"从库{SlavePools.Count + 1}", slaveConnectionString, () => Interlocked.Decrement(ref slaveUnavailables), () => Interlocked.Increment(ref slaveUnavailables)); diff --git a/FreeSql/PostgreSQL/Curd/PostgreSQLDelete.cs b/FreeSql/PostgreSQL/Curd/PostgreSQLDelete.cs index 4a0cf9df..9a5c05d4 100644 --- a/FreeSql/PostgreSQL/Curd/PostgreSQLDelete.cs +++ b/FreeSql/PostgreSQL/Curd/PostgreSQLDelete.cs @@ -24,7 +24,7 @@ namespace FreeSql.PostgreSQL.Curd { sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); ++colidx; } - var ret = _orm.Ado.Query(_transaction, CommandType.Text, sb.ToString(), _params.ToArray()); + var ret = _orm.Ado.Query(_connection, _transaction, CommandType.Text, sb.ToString(), _params.ToArray()); this.ClearData(); return ret; } @@ -41,7 +41,7 @@ namespace FreeSql.PostgreSQL.Curd { sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); ++colidx; } - var ret = await _orm.Ado.QueryAsync(_transaction, CommandType.Text, sb.ToString(), _params.ToArray()); + var ret = await _orm.Ado.QueryAsync(_connection, _transaction, CommandType.Text, sb.ToString(), _params.ToArray()); this.ClearData(); return ret; } diff --git a/FreeSql/PostgreSQL/Curd/PostgreSQLInsert.cs b/FreeSql/PostgreSQL/Curd/PostgreSQLInsert.cs index b36e0987..8931a62e 100644 --- a/FreeSql/PostgreSQL/Curd/PostgreSQLInsert.cs +++ b/FreeSql/PostgreSQL/Curd/PostgreSQLInsert.cs @@ -26,10 +26,10 @@ namespace FreeSql.PostgreSQL.Curd { var identCols = _table.Columns.Where(a => a.Value.Attribute.IsIdentity == true); if (identCols.Any() == false) { - _orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, sql, _params); + _orm.Ado.ExecuteNonQuery(_connection, _transaction, CommandType.Text, sql, _params); return 0; } - return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_transaction, CommandType.Text, string.Concat(sql, " RETURNING ", _commonUtils.QuoteSqlName(identCols.First().Value.Attribute.Name)), _params)), out var trylng) ? trylng : 0; + return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_connection, _transaction, CommandType.Text, string.Concat(sql, " RETURNING ", _commonUtils.QuoteSqlName(identCols.First().Value.Attribute.Name)), _params)), out var trylng) ? trylng : 0; } async internal override Task RawExecuteIdentityAsync() { var sql = this.ToSql(); @@ -37,10 +37,10 @@ namespace FreeSql.PostgreSQL.Curd { var identCols = _table.Columns.Where(a => a.Value.Attribute.IsIdentity == true); if (identCols.Any() == false) { - await _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, sql, _params); + await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _params); return 0; } - return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_transaction, CommandType.Text, string.Concat(sql, " RETURNING ", _commonUtils.QuoteSqlName(identCols.First().Value.Attribute.Name)), _params)), out var trylng) ? trylng : 0; + return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, string.Concat(sql, " RETURNING ", _commonUtils.QuoteSqlName(identCols.First().Value.Attribute.Name)), _params)), out var trylng) ? trylng : 0; } internal override List RawExecuteInserted() { @@ -56,7 +56,7 @@ namespace FreeSql.PostgreSQL.Curd { sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); ++colidx; } - return _orm.Ado.Query(_transaction, CommandType.Text, sb.ToString(), _params); + return _orm.Ado.Query(_connection, _transaction, CommandType.Text, sb.ToString(), _params); } async internal override Task> RawExecuteInsertedAsync() { var sql = this.ToSql(); @@ -71,7 +71,7 @@ namespace FreeSql.PostgreSQL.Curd { sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); ++colidx; } - return await _orm.Ado.QueryAsync(_transaction, CommandType.Text, sb.ToString(), _params); + return await _orm.Ado.QueryAsync(_connection, _transaction, CommandType.Text, sb.ToString(), _params); } } } diff --git a/FreeSql/PostgreSQL/Curd/PostgreSQLUpdate.cs b/FreeSql/PostgreSQL/Curd/PostgreSQLUpdate.cs index 98515b94..415a56eb 100644 --- a/FreeSql/PostgreSQL/Curd/PostgreSQLUpdate.cs +++ b/FreeSql/PostgreSQL/Curd/PostgreSQLUpdate.cs @@ -33,7 +33,7 @@ namespace FreeSql.PostgreSQL.Curd { sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); ++colidx; } - var ret = _orm.Ado.Query(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); + var ret = _orm.Ado.Query(_connection, _transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); ValidateVersionAndThrow(ret.Count); return ret; } @@ -50,7 +50,7 @@ namespace FreeSql.PostgreSQL.Curd { sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); ++colidx; } - var ret = await _orm.Ado.QueryAsync(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); + var ret = await _orm.Ado.QueryAsync(_connection, _transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); ValidateVersionAndThrow(ret.Count); return ret; } diff --git a/FreeSql/PostgreSQL/PostgreSQLAdo/PostgreSQLAdo.cs b/FreeSql/PostgreSQL/PostgreSQLAdo/PostgreSQLAdo.cs index 80540292..82166704 100644 --- a/FreeSql/PostgreSQL/PostgreSQLAdo/PostgreSQLAdo.cs +++ b/FreeSql/PostgreSQL/PostgreSQLAdo/PostgreSQLAdo.cs @@ -15,7 +15,8 @@ namespace FreeSql.PostgreSQL { public PostgreSQLAdo() : base(null, null, DataType.PostgreSQL) { } public PostgreSQLAdo(CommonUtils util, ICache cache, ILogger log, string masterConnectionString, string[] slaveConnectionStrings) : base(cache, log, DataType.PostgreSQL) { base._util = util; - MasterPool = new PostgreSQLConnectionPool("主库", masterConnectionString, null, null); + if (!string.IsNullOrEmpty(masterConnectionString)) + MasterPool = new PostgreSQLConnectionPool("主库", masterConnectionString, null, null); if (slaveConnectionStrings != null) { foreach (var slaveConnectionString in slaveConnectionStrings) { var slavePool = new PostgreSQLConnectionPool($"从库{SlavePools.Count + 1}", slaveConnectionString, () => Interlocked.Decrement(ref slaveUnavailables), () => Interlocked.Increment(ref slaveUnavailables)); diff --git a/FreeSql/PostgreSQL/PostgreSQLProvider.cs b/FreeSql/PostgreSQL/PostgreSQLProvider.cs index c591a89a..c8e06005 100644 --- a/FreeSql/PostgreSQL/PostgreSQLProvider.cs +++ b/FreeSql/PostgreSQL/PostgreSQLProvider.cs @@ -19,33 +19,33 @@ namespace FreeSql.PostgreSQL { class PostgreSQLProvider : IFreeSql { static PostgreSQLProvider() { - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(BitArray), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlPoint), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlLine), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlLSeg), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlBox), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlPath), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlPolygon), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlCircle), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof((IPAddress Address, int Subnet)), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(IPAddress), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(PhysicalAddress), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlRange), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlRange), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlRange), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlRange), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(PostgisPoint), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(PostgisLineString), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(PostgisPolygon), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(PostgisMultiPoint), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(PostgisMultiLineString), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(PostgisMultiPolygon), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(PostgisGeometry), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(PostgisGeometryCollection), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(Dictionary), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(JToken), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(JObject), true); - Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(JArray), true); + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(BitArray)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlPoint)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlLine)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlLSeg)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlBox)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlPath)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlPolygon)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlCircle)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof((IPAddress Address, int Subnet))] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(IPAddress)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(PhysicalAddress)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlRange)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlRange)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlRange)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlRange)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(PostgisPoint)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(PostgisLineString)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(PostgisPolygon)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(PostgisMultiPoint)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(PostgisMultiLineString)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(PostgisMultiPolygon)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(PostgisGeometry)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(PostgisGeometryCollection)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(Dictionary)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(JToken)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(JObject)] = true; + Utils.dicExecuteArrayRowReadClassOrTuple[typeof(JArray)] = true; } public ISelect Select() where T1 : class => new PostgreSQLSelect(this, this.InternalCommonUtils, this.InternalCommonExpression, null); diff --git a/FreeSql/SqlServer/Curd/SqlServerDelete.cs b/FreeSql/SqlServer/Curd/SqlServerDelete.cs index bcb72a98..365d7698 100644 --- a/FreeSql/SqlServer/Curd/SqlServerDelete.cs +++ b/FreeSql/SqlServer/Curd/SqlServerDelete.cs @@ -30,7 +30,7 @@ namespace FreeSql.SqlServer.Curd { sb.Insert(0, sql.Substring(0, validx)); sb.Append(sql.Substring(validx)); - var ret = _orm.Ado.Query(_transaction, CommandType.Text, sb.ToString(), _params.ToArray()); + var ret = _orm.Ado.Query(_connection, _transaction, CommandType.Text, sb.ToString(), _params.ToArray()); this.ClearData(); return ret; } @@ -52,7 +52,7 @@ namespace FreeSql.SqlServer.Curd { sb.Insert(0, sql.Substring(0, validx)); sb.Append(sql.Substring(validx)); - var ret = await _orm.Ado.QueryAsync(_transaction, CommandType.Text, sb.ToString(), _params.ToArray()); + var ret = await _orm.Ado.QueryAsync(_connection, _transaction, CommandType.Text, sb.ToString(), _params.ToArray()); this.ClearData(); return ret; } diff --git a/FreeSql/SqlServer/Curd/SqlServerInsert.cs b/FreeSql/SqlServer/Curd/SqlServerInsert.cs index 6932bf93..ded77b60 100644 --- a/FreeSql/SqlServer/Curd/SqlServerInsert.cs +++ b/FreeSql/SqlServer/Curd/SqlServerInsert.cs @@ -26,13 +26,13 @@ namespace FreeSql.SqlServer.Curd { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; - return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_transaction, CommandType.Text, string.Concat(sql, "; SELECT SCOPE_IDENTITY();"), _params)), out var trylng) ? trylng : 0; + return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_connection, _transaction, CommandType.Text, string.Concat(sql, "; SELECT SCOPE_IDENTITY();"), _params)), out var trylng) ? trylng : 0; } async internal override Task RawExecuteIdentityAsync() { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; - return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_transaction, CommandType.Text, string.Concat(sql, "; SELECT SCOPE_IDENTITY();"), _params)), out var trylng) ? trylng : 0; + return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, string.Concat(sql, "; SELECT SCOPE_IDENTITY();"), _params)), out var trylng) ? trylng : 0; } internal override List RawExecuteInserted() { @@ -53,7 +53,7 @@ namespace FreeSql.SqlServer.Curd { sb.Insert(0, sql.Substring(0, validx + 1)); sb.Append(sql.Substring(validx + 1)); - return _orm.Ado.Query(_transaction, CommandType.Text, sb.ToString(), _params); + return _orm.Ado.Query(_connection, _transaction, CommandType.Text, sb.ToString(), _params); } async internal override Task> RawExecuteInsertedAsync() { var sql = this.ToSql(); @@ -73,7 +73,7 @@ namespace FreeSql.SqlServer.Curd { sb.Insert(0, sql.Substring(0, validx + 1)); sb.Append(sql.Substring(validx + 1)); - return await _orm.Ado.QueryAsync(_transaction, CommandType.Text, sb.ToString(), _params); + return await _orm.Ado.QueryAsync(_connection, _transaction, CommandType.Text, sb.ToString(), _params); } } } \ No newline at end of file diff --git a/FreeSql/SqlServer/Curd/SqlServerUpdate.cs b/FreeSql/SqlServer/Curd/SqlServerUpdate.cs index ccc5c09c..382ab633 100644 --- a/FreeSql/SqlServer/Curd/SqlServerUpdate.cs +++ b/FreeSql/SqlServer/Curd/SqlServerUpdate.cs @@ -39,7 +39,7 @@ namespace FreeSql.SqlServer.Curd { sb.Insert(0, sql.Substring(0, validx)); sb.Append(sql.Substring(validx)); - var ret = _orm.Ado.Query(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); + var ret = _orm.Ado.Query(_connection, _transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); ValidateVersionAndThrow(ret.Count); return ret; } @@ -61,7 +61,7 @@ namespace FreeSql.SqlServer.Curd { sb.Insert(0, sql.Substring(0, validx)); sb.Append(sql.Substring(validx)); - var ret = await _orm.Ado.QueryAsync(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); + var ret = await _orm.Ado.QueryAsync(_connection, _transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); ValidateVersionAndThrow(ret.Count); return ret; } diff --git a/FreeSql/SqlServer/SqlServerAdo/SqlServerAdo.cs b/FreeSql/SqlServer/SqlServerAdo/SqlServerAdo.cs index 3a57dff4..4675e7e5 100644 --- a/FreeSql/SqlServer/SqlServerAdo/SqlServerAdo.cs +++ b/FreeSql/SqlServer/SqlServerAdo/SqlServerAdo.cs @@ -13,7 +13,8 @@ namespace FreeSql.SqlServer { public SqlServerAdo() : base(null, null, DataType.SqlServer) { } public SqlServerAdo(CommonUtils util, ICache cache, ILogger log, string masterConnectionString, string[] slaveConnectionStrings) : base(cache, log, DataType.SqlServer) { base._util = util; - MasterPool = new SqlServerConnectionPool("主库", masterConnectionString, null, null); + if (!string.IsNullOrEmpty(masterConnectionString)) + MasterPool = new SqlServerConnectionPool("主库", masterConnectionString, null, null); if (slaveConnectionStrings != null) { foreach (var slaveConnectionString in slaveConnectionStrings) { var slavePool = new SqlServerConnectionPool($"从库{SlavePools.Count + 1}", slaveConnectionString, () => Interlocked.Decrement(ref slaveUnavailables), () => Interlocked.Increment(ref slaveUnavailables)); diff --git a/FreeSql/SqlServer/SqlServerProvider.cs b/FreeSql/SqlServer/SqlServerProvider.cs index 649a67f2..b165e2c9 100644 --- a/FreeSql/SqlServer/SqlServerProvider.cs +++ b/FreeSql/SqlServer/SqlServerProvider.cs @@ -40,12 +40,13 @@ namespace FreeSql.SqlServer { this.DbFirst = new SqlServerDbFirst(this, this.InternalCommonUtils, this.InternalCommonExpression); this.CodeFirst = new SqlServerCodeFirst(this, this.InternalCommonUtils, this.InternalCommonExpression); - using (var conn = this.Ado.MasterPool.Get()) { - try { - (this.InternalCommonUtils as SqlServerUtils).IsSelectRowNumber = int.Parse(conn.Value.ServerVersion.Split('.')[0]) <= 10; - } catch { + if (this.Ado.MasterPool != null) + using (var conn = this.Ado.MasterPool.Get()) { + try { + (this.InternalCommonUtils as SqlServerUtils).IsSelectRowNumber = int.Parse(conn.Value.ServerVersion.Split('.')[0]) <= 10; + } catch { + } } - } } internal CommonUtils InternalCommonUtils { get; } diff --git a/FreeSql/Sqlite/Curd/SqliteInsert.cs b/FreeSql/Sqlite/Curd/SqliteInsert.cs index 7feda22a..38e5c654 100644 --- a/FreeSql/Sqlite/Curd/SqliteInsert.cs +++ b/FreeSql/Sqlite/Curd/SqliteInsert.cs @@ -25,13 +25,13 @@ namespace FreeSql.Sqlite.Curd { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; - return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_transaction, CommandType.Text, string.Concat(sql, "; SELECT last_insert_rowid();"), _params)), out var trylng) ? trylng : 0; + return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_connection, _transaction, CommandType.Text, string.Concat(sql, "; SELECT last_insert_rowid();"), _params)), out var trylng) ? trylng : 0; } async internal override Task RawExecuteIdentityAsync() { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; - return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_transaction, CommandType.Text, string.Concat(sql, "; SELECT last_insert_rowid();"), _params)), out var trylng) ? trylng : 0; + return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, string.Concat(sql, "; SELECT last_insert_rowid();"), _params)), out var trylng) ? trylng : 0; } internal override List RawExecuteInserted() { var sql = this.ToSql(); diff --git a/FreeSql/Sqlite/SqliteAdo/SqliteAdo.cs b/FreeSql/Sqlite/SqliteAdo/SqliteAdo.cs index 67ad8eca..a065a624 100644 --- a/FreeSql/Sqlite/SqliteAdo/SqliteAdo.cs +++ b/FreeSql/Sqlite/SqliteAdo/SqliteAdo.cs @@ -13,7 +13,8 @@ namespace FreeSql.Sqlite { public SqliteAdo() : base(null, null, DataType.Sqlite) { } public SqliteAdo(CommonUtils util, ICache cache, ILogger log, string masterConnectionString, string[] slaveConnectionStrings) : base(cache, log, DataType.Sqlite) { base._util = util; - MasterPool = new SqliteConnectionPool("主库", masterConnectionString, null, null); + if (!string.IsNullOrEmpty(masterConnectionString)) + MasterPool = new SqliteConnectionPool("主库", masterConnectionString, null, null); if (slaveConnectionStrings != null) { foreach (var slaveConnectionString in slaveConnectionStrings) { var slavePool = new SqliteConnectionPool($"从库{SlavePools.Count + 1}", slaveConnectionString, () => Interlocked.Decrement(ref slaveUnavailables), () => Interlocked.Increment(ref slaveUnavailables));