From d1a07dc8888063ea400f61e29f883451c6668127 Mon Sep 17 00:00:00 2001 From: 28810 <28810@YEXIANGQIN> Date: Wed, 10 Apr 2019 21:19:32 +0800 Subject: [PATCH] =?UTF-8?q?-=20=E4=BF=AE=E5=A4=8D=20MySql=20=E6=9E=9A?= =?UTF-8?q?=E4=B8=BE=E8=A1=A8=E8=BE=BE=E5=BC=8F=20=3D=3D=20=E8=A7=A3?= =?UTF-8?q?=E6=9E=90=E6=88=90=E6=95=B0=E5=AD=97=E7=9A=84=20bug=EF=BC=9B=20?= =?UTF-8?q?-=20=E5=A2=9E=E5=8A=A0=20Connection=20=E5=AF=B9=E8=B1=A1?= =?UTF-8?q?=E6=89=A9=E5=B1=95=E6=96=B9=E6=B3=95=EF=BC=8C=E5=AE=9E=E7=8E=B0?= =?UTF-8?q?=E5=83=8F=20Dapper=20=E7=9A=84=E4=BD=BF=E7=94=A8=E4=B9=A0?= =?UTF-8?q?=E6=83=AF=EF=BC=9B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- FreeSql.Tests/MySql/Curd/MySqlSelectTest.cs | 13 ++ .../MySql/MySqlConnectionExtensionsTest.cs | 84 ++++++++++ FreeSql/Interface/Curd/IDelete.cs | 6 + FreeSql/Interface/Curd/IInsert.cs | 6 + FreeSql/Interface/Curd/ISelect/ISelect0.cs | 6 + FreeSql/Interface/Curd/IUpdate.cs | 6 + FreeSql/Interface/IAdo.cs | 24 +++ FreeSql/Interface/IDbManage.cs | 57 +++++++ FreeSql/Interface/iDbFirst.cs | 2 +- FreeSql/Internal/CommonExpression.cs | 18 ++- .../CommonProvider/AdoProvider/AdoProvider.cs | 147 ++++++++++-------- .../AdoProvider/AdoProviderAsync.cs | 109 +++++++------ .../Internal/CommonProvider/DeleteProvider.cs | 5 + .../Internal/CommonProvider/InsertProvider.cs | 6 + .../SelectProvider/Select0Provider.cs | 12 +- .../Internal/CommonProvider/UpdateProvider.cs | 6 + FreeSql/MySql/MySqlAdo/MySqlAdo.cs | 12 +- FreeSql/MySql/MySqlConnectionExtensions.cs | 30 ++++ 18 files changed, 432 insertions(+), 117 deletions(-) create mode 100644 FreeSql.Tests/MySql/MySqlConnectionExtensionsTest.cs create mode 100644 FreeSql/Interface/IDbManage.cs create mode 100644 FreeSql/MySql/MySqlConnectionExtensions.cs diff --git a/FreeSql.Tests/MySql/Curd/MySqlSelectTest.cs b/FreeSql.Tests/MySql/Curd/MySqlSelectTest.cs index 546a102b..82c6d485 100644 --- a/FreeSql.Tests/MySql/Curd/MySqlSelectTest.cs +++ b/FreeSql.Tests/MySql/Curd/MySqlSelectTest.cs @@ -236,7 +236,20 @@ namespace FreeSql.Tests.MySql { } [Fact] public void ToSql() { + g.mysql.Insert().AppendData(new testenumWhere { type = testenumWhereType.Blaaa }).ExecuteAffrows(); + + var sql1 = g.mysql.Select().Where(a => a.type == testenumWhereType.Blaaa).ToSql(); + var sql2 = g.mysql.Select().Where(a => testenumWhereType.Blaaa == a.type).ToSql(); + + var sql3 = g.mysql.Select().Where(a => a.type.Equals(testenumWhereType.Blaaa)).ToSql(); + var tolist = g.mysql.Select().Where(a => a.type == testenumWhereType.Blaaa).ToList(); } + class testenumWhere { + public Guid id { get; set; } + public testenumWhereType type { get; set; } + } + public enum testenumWhereType { Menu, Class, Blaaa } + [Fact] public void Any() { var count = select.Where(a => 1 == 1).Count(); diff --git a/FreeSql.Tests/MySql/MySqlConnectionExtensionsTest.cs b/FreeSql.Tests/MySql/MySqlConnectionExtensionsTest.cs new file mode 100644 index 00000000..a2eeae5a --- /dev/null +++ b/FreeSql.Tests/MySql/MySqlConnectionExtensionsTest.cs @@ -0,0 +1,84 @@ +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/Interface/Curd/IDelete.cs b/FreeSql/Interface/Curd/IDelete.cs index 6b40250c..5cf4eb20 100644 --- a/FreeSql/Interface/Curd/IDelete.cs +++ b/FreeSql/Interface/Curd/IDelete.cs @@ -13,6 +13,12 @@ namespace FreeSql { /// /// IDelete WithTransaction(DbTransaction transaction); + /// + /// 指定事务对象 + /// + /// + /// + IDelete WithConnection(DbConnection connection); /// /// lambda表达式条件，仅支持实体基础成员（不包含导航对象） diff --git a/FreeSql/Interface/Curd/IInsert.cs b/FreeSql/Interface/Curd/IInsert.cs index 2dd8ca90..573fb26d 100644 --- a/FreeSql/Interface/Curd/IInsert.cs +++ b/FreeSql/Interface/Curd/IInsert.cs @@ -13,6 +13,12 @@ namespace FreeSql { /// /// IInsert WithTransaction(DbTransaction transaction); + /// + /// 指定事务对象 + /// + /// + /// + IInsert WithConnection(DbConnection connection); /// /// 追加准备插入的实体 diff --git a/FreeSql/Interface/Curd/ISelect/ISelect0.cs b/FreeSql/Interface/Curd/ISelect/ISelect0.cs index a3906cbb..9aacdbb3 100644 --- a/FreeSql/Interface/Curd/ISelect/ISelect0.cs +++ b/FreeSql/Interface/Curd/ISelect/ISelect0.cs @@ -15,6 +15,12 @@ namespace FreeSql { /// /// TSelect WithTransaction(DbTransaction transaction); + /// + /// 指定连接对象 + /// + /// + /// + TSelect WithConnection(DbConnection connection); /// /// 审核或跟踪 ToList 即将返回的数据 diff --git a/FreeSql/Interface/Curd/IUpdate.cs b/FreeSql/Interface/Curd/IUpdate.cs index 6c477c51..ab6d3233 100644 --- a/FreeSql/Interface/Curd/IUpdate.cs +++ b/FreeSql/Interface/Curd/IUpdate.cs @@ -13,6 +13,12 @@ namespace FreeSql { /// /// IUpdate WithTransaction(DbTransaction transaction); + /// + /// 指定事务对象 + /// + /// + /// + IUpdate WithConnection(DbConnection connection); /// /// 不使用参数化，可通过 IFreeSql.CodeFirst.IsNotCommandParameter 全局性设置 diff --git a/FreeSql/Interface/IAdo.cs b/FreeSql/Interface/IAdo.cs index 79c8ff7e..627ba325 100644 --- a/FreeSql/Interface/IAdo.cs +++ b/FreeSql/Interface/IAdo.cs @@ -62,6 +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); /// /// 查询，ExecuteReader(dr => {}, "select * from user where age > @age", new { age = 25 }) /// @@ -69,6 +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); /// /// 查询 /// @@ -76,6 +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); /// /// 查询，ExecuteArray("select * from user where age > @age", new { age = 25 }) /// @@ -84,6 +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); /// /// 查询 /// @@ -91,6 +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); /// /// 查询，ExecuteDataTable("select * from user where age > @age", new { age = 25 }) /// @@ -99,6 +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); /// /// 在【主库】执行 /// @@ -107,6 +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); /// /// 在【主库】执行，ExecuteNonQuery("delete from user where age > @age", new { age = 25 }) /// @@ -115,6 +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); /// /// 在【主库】执行 /// @@ -123,6 +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); /// /// 在【主库】执行，ExecuteScalar("select 1 from user where age > @age", new { age = 25 }) /// @@ -131,6 +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); /// /// 执行SQL返回对象集合，Query<User>("select * from user where age > @age", new SqlParameter { ParameterName = "age", Value = 25 }) @@ -142,6 +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); /// /// 执行SQL返回对象集合，Query<User>("select * from user where age > @age", new { age = 25 }) /// @@ -151,6 +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); #region async /// @@ -162,6 +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); /// /// 查询，ExecuteReaderAsync(dr => {}, "select * from user where age > @age", new { age = 25 }) /// @@ -169,6 +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); /// /// 查询 /// @@ -176,6 +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); /// /// 查询，ExecuteArrayAsync("select * from user where age > @age", new { age = 25 }) /// @@ -184,6 +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); /// /// 查询 /// @@ -191,6 +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); /// /// 查询，ExecuteDataTableAsync("select * from user where age > @age", new { age = 25 }) /// @@ -199,6 +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); /// /// 在【主库】执行 /// @@ -207,6 +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); /// /// 在【主库】执行，ExecuteNonQueryAsync("delete from user where age > @age", new { age = 25 }) /// @@ -215,6 +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); /// /// 在【主库】执行 /// @@ -223,6 +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); /// /// 在【主库】执行，ExecuteScalarAsync("select 1 from user where age > @age", new { age = 25 }) /// @@ -231,6 +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); /// /// 执行SQL返回对象集合，QueryAsync<User>("select * from user where age > @age", new SqlParameter { ParameterName = "age", Value = 25 }) @@ -242,6 +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); /// /// 执行SQL返回对象集合，QueryAsync<User>("select * from user where age > @age", new { age = 25 }) /// @@ -251,6 +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); #endregion } } diff --git a/FreeSql/Interface/IDbManage.cs b/FreeSql/Interface/IDbManage.cs new file mode 100644 index 00000000..fa7a06a5 --- /dev/null +++ b/FreeSql/Interface/IDbManage.cs @@ -0,0 +1,57 @@ +//using FreeSql.DatabaseModel; +//using System; +//using System.Collections.Generic; +//using System.Text; + +//namespace FreeSql { +// public interface IDbManage { + +// /// +// /// 判断表是否存在 +// /// +// /// 表名 +// /// +// bool ExistsTable(string name); +// /// +// /// 判断列是否存在 +// /// +// /// 表名 +// /// 列名 +// /// +// bool ExistsColumn(string table, string column); + +// /// +// /// 判断视图是否存在 +// /// +// /// 视图名 +// /// +// bool ExistsView(string name); +// /// +// /// 判断列是否存在 +// /// +// /// 视图名 +// /// 列名 +// /// +// bool ExistsColumnByView(string view, string column); + +// /// +// /// 获取表信息，包括表、列详情、主键、唯一键、索引、备注（注意：本方法不返回外键） +// /// +// /// 表名 +// /// +// DbTableInfo GetTableInfo(string name); +// /// +// /// 获取视图信息，包括表、列详情 +// /// +// /// 视图名 +// /// +// DbTableInfo GetViewInfo(string name); + +// /// +// /// 获取指定数据库的表信息，包括表、列详情、主键、唯一键、索引、外键、备注 +// /// +// /// +// /// +// List GetTablesByDatabase(params string[] database); +// } +//} diff --git a/FreeSql/Interface/iDbFirst.cs b/FreeSql/Interface/iDbFirst.cs index ac8f0fbd..2aa495a8 100644 --- a/FreeSql/Interface/iDbFirst.cs +++ b/FreeSql/Interface/iDbFirst.cs @@ -11,7 +11,7 @@ namespace FreeSql { /// List GetDatabases(); /// - /// 获取指定数据库的表信息，包括表、列详情、主键、唯一键、索引、外键 + /// 获取指定数据库的表信息，包括表、列详情、主键、唯一键、索引、外键、备注 /// /// /// diff --git a/FreeSql/Internal/CommonExpression.cs b/FreeSql/Internal/CommonExpression.cs index 56efbddf..8b985ab0 100644 --- a/FreeSql/Internal/CommonExpression.cs +++ b/FreeSql/Internal/CommonExpression.cs @@ -324,7 +324,7 @@ namespace FreeSql.Internal { tmpleft = tmp33; } if (tmpright == "NULL") tmptryoper = " IS "; - return $"{tmpleft}{tmptryoper}{tmpright}"; + return $"{tmpleft} {tmptryoper} {tmpright}"; } if (callType.FullName.StartsWith("FreeSql.ISelectGroupingAggregate`")) { switch (exp3.Method.Name) { @@ -760,6 +760,22 @@ namespace FreeSql.Internal { if (right == "NULL") tryoper = tryoper == "=" ? " IS " : " IS NOT "; if (tryoper == "+" && (expBinary.Left.Type.FullName == "System.String" || expBinary.Right.Type.FullName == "System.String")) return _common.StringConcat(left, right, expBinary.Left.Type, expBinary.Right.Type); if (tryoper == "%") return _common.Mod(left, right, expBinary.Left.Type, expBinary.Right.Type); + if (_common._orm.Ado.DataType == DataType.MySql) { + //处理c#变态enum convert， a.EnumType1 == Xxx.Xxx，被转成了 Convert(a.EnumType1, Int32) == 1 + if (expBinary.Left.NodeType == ExpressionType.Convert && expBinary.Right.NodeType == ExpressionType.Constant) { + if (long.TryParse(right, out var tryenumLong)) { + var enumType = (expBinary.Left as UnaryExpression)?.Operand.Type; + if (enumType?.IsEnum == true) + right = _common.FormatSql("{0}", Enum.Parse(enumType, right)); + } + } else if (expBinary.Left.NodeType == ExpressionType.Constant && expBinary.Right.NodeType == ExpressionType.Convert) { + if (long.TryParse(left, out var tryenumLong)) { + var enumType = (expBinary.Right as UnaryExpression)?.Operand.Type; + if (enumType?.IsEnum == true) + left = _common.FormatSql("{0}", Enum.Parse(enumType, left)); + } + } + } return $"{left} {tryoper} {right}"; } diff --git a/FreeSql/Internal/CommonProvider/AdoProvider/AdoProvider.cs b/FreeSql/Internal/CommonProvider/AdoProvider/AdoProvider.cs index eccbb611..fb9a7554 100644 --- a/FreeSql/Internal/CommonProvider/AdoProvider/AdoProvider.cs +++ b/FreeSql/Internal/CommonProvider/AdoProvider/AdoProvider.cs @@ -41,9 +41,9 @@ namespace FreeSql.Internal.CommonProvider { if (IsTracePerformance) { TimeSpan ts = DateTime.Now.Subtract(dt); if (e == null && ts.TotalMilliseconds > 100) - _log.LogWarning(logtxt.Insert(0, $"{pool.Policy.Name}（执行SQL）语句耗时过长{ts.TotalMilliseconds}ms\r\n{cmd.CommandText}\r\n").ToString()); + _log.LogWarning(logtxt.Insert(0, $"{pool?.Policy.Name}（执行SQL）语句耗时过长{ts.TotalMilliseconds}ms\r\n{cmd.CommandText}\r\n").ToString()); else - logtxt.Insert(0, $"{pool.Policy.Name}（执行SQL）耗时{ts.TotalMilliseconds}ms\r\n{cmd.CommandText}\r\n").ToString(); + logtxt.Insert(0, $"{pool?.Policy.Name}（执行SQL）耗时{ts.TotalMilliseconds}ms\r\n{cmd.CommandText}\r\n").ToString(); } if (e == null) { @@ -52,7 +52,7 @@ namespace FreeSql.Internal.CommonProvider { } StringBuilder log = new StringBuilder(); - log.Append(pool.Policy.Name).Append("数据库出错（执行SQL）〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓\r\n").Append(cmd.CommandText).Append("\r\n"); + log.Append(pool?.Policy.Name).Append("数据库出错（执行SQL）〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓\r\n").Append(cmd.CommandText).Append("\r\n"); foreach (DbParameter parm in cmd.Parameters) log.Append(parm.ParameterName.PadRight(20, ' ')).Append(" = ").Append((parm.Value ?? DBNull.Value) == DBNull.Value ? "NULL" : parm.Value).Append("\r\n"); @@ -74,16 +74,19 @@ namespace FreeSql.Internal.CommonProvider { } internal static ConcurrentDictionary dicQueryTypeGetProperties = new ConcurrentDictionary(); - public List Query(string cmdText, object parms = null) => Query(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public List Query(DbTransaction transaction, string cmdText, object parms = null) => Query(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public List Query(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => Query(null, cmdType, cmdText, cmdParms); - public List Query(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { + 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(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) { 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, dr => { + ExecuteReader(transaction, connection, dr => { if (indexes == null) { var dic = new Dictionary(StringComparer.CurrentCultureIgnoreCase); for (var a = 0; a < dr.FieldCount; a++) @@ -94,10 +97,13 @@ namespace FreeSql.Internal.CommonProvider { }, cmdType, cmdText, cmdParms); return ret; } - public void ExecuteReader(Action readerHander, string cmdText, object parms = null) => ExecuteReader(null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public void ExecuteReader(DbTransaction transaction, Action readerHander, string cmdText, object parms = null) => ExecuteReader(transaction, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public void ExecuteReader(Action readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReader(null, readerHander, cmdType, cmdText, cmdParms); - public void ExecuteReader(DbTransaction transaction, Action readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { + 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(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) { if (string.IsNullOrEmpty(cmdText)) return; var dt = DateTime.Now; var logtxt = new StringBuilder(); @@ -105,23 +111,25 @@ namespace FreeSql.Internal.CommonProvider { var pool = this.MasterPool; var isSlave = false; - //读写分离规则 - if (this.SlavePools.Any() && cmdText.StartsWith("SELECT ", StringComparison.CurrentCultureIgnoreCase)) { - var availables = slaveUnavailables == 0 ? - //查从库 - this.SlavePools : ( - //查主库 - slaveUnavailables == this.SlavePools.Count ? new List>() : - //查从库可用 - this.SlavePools.Where(sp => sp.IsAvailable).ToList()); - if (availables.Any()) { - isSlave = true; - pool = availables.Count == 1 ? availables[0] : availables[slaveRandom.Next(availables.Count)]; + if (transaction == null && connection == null) { + //读写分离规则 + if (this.SlavePools.Any() && cmdText.StartsWith("SELECT ", StringComparison.CurrentCultureIgnoreCase)) { + var availables = slaveUnavailables == 0 ? + //查从库 + this.SlavePools : ( + //查主库 + slaveUnavailables == this.SlavePools.Count ? new List>() : + //查从库可用 + this.SlavePools.Where(sp => sp.IsAvailable).ToList()); + if (availables.Any()) { + isSlave = true; + pool = availables.Count == 1 ? availables[0] : availables[slaveRandom.Next(availables.Count)]; + } } } Object conn = null; - var pc = PrepareCommand(transaction, cmdType, cmdText, cmdParms, logtxt); + var pc = PrepareCommand(transaction, connection, 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 { @@ -130,7 +138,7 @@ namespace FreeSql.Internal.CommonProvider { //从库查询切换，恢复 bool isSlaveFail = false; try { - if (pc.cmd.Connection == null) pc.cmd.Connection = (conn = pool.Get()).Value; + if (pc.Connection == null) pc.Connection = (conn = pool.Get()).Value; //if (slaveRandom.Next(100) % 2 == 0) throw new Exception("测试从库抛出异常"); } catch { isSlaveFail = true; @@ -141,20 +149,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, pc.cmd, new Exception($"连接失败，准备切换其他可用服务器"), dt, logtxt, false); - pc.cmd.Parameters.Clear(); + LoggerException(pool, pc, new Exception($"连接失败，准备切换其他可用服务器"), dt, logtxt, false); + pc.Parameters.Clear(); ExecuteReader(readerHander, cmdType, cmdText, cmdParms); return; } } else { //主库查询 - if (pc.cmd.Connection == null) pc.cmd.Connection = (conn = pool.Get()).Value; + if (pc.Connection == null) pc.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.cmd.ExecuteReader()) { + using (var dr = pc.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; @@ -188,27 +196,33 @@ 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, pc.cmd, ex, dt, logtxt); - pc.cmd.Parameters.Clear(); + LoggerException(pool, pc, ex, dt, logtxt); + pc.Parameters.Clear(); } - public object[][] ExecuteArray(string cmdText, object parms = null) => ExecuteArray(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public object[][] ExecuteArray(DbTransaction transaction, string cmdText, object parms = null) => ExecuteArray(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public object[][] ExecuteArray(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArray(null, cmdType, cmdText, cmdParms); - public object[][] ExecuteArray(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { + 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(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) { List ret = new List(); - ExecuteReader(transaction, dr => { + ExecuteReader(transaction, connection, dr => { object[] values = new object[dr.FieldCount]; dr.GetValues(values); ret.Add(values); }, cmdType, cmdText, cmdParms); return ret.ToArray(); } - public DataTable ExecuteDataTable(string cmdText, object parms = null) => ExecuteDataTable(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public DataTable ExecuteDataTable(DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTable(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public DataTable ExecuteDataTable(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTable(null, cmdType, cmdText, cmdParms); - public DataTable ExecuteDataTable(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { + 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(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) { var ret = new DataTable(); - ExecuteReader(transaction, dr => { + ExecuteReader(transaction, connection, 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]; @@ -217,21 +231,24 @@ namespace FreeSql.Internal.CommonProvider { }, cmdType, cmdText, cmdParms); return ret; } - public int ExecuteNonQuery(string cmdText, object parms = null) => ExecuteNonQuery(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public int ExecuteNonQuery(DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQuery(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public int ExecuteNonQuery(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQuery(null, cmdType, cmdText, cmdParms); - public int ExecuteNonQuery(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { + 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(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) { 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, cmdType, cmdText, cmdParms, logtxt); + var pc = PrepareCommand(transaction, connection, cmdType, cmdText, cmdParms, logtxt); int val = 0; Exception ex = null; try { - if (pc.cmd.Connection == null) pc.cmd.Connection = (conn = this.MasterPool.Get()).Value; - val = pc.cmd.ExecuteNonQuery(); + if (pc.Connection == null) pc.Connection = (conn = this.MasterPool.Get()).Value; + val = pc.ExecuteNonQuery(); } catch (Exception ex2) { ex = ex2; } @@ -241,25 +258,28 @@ 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, pc.cmd, ex, dt, logtxt); - pc.cmd.Parameters.Clear(); + LoggerException(this.MasterPool, pc, ex, dt, logtxt); + pc.Parameters.Clear(); return val; } - public object ExecuteScalar(string cmdText, object parms = null) => ExecuteScalar(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public object ExecuteScalar(DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalar(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public object ExecuteScalar(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalar(null, cmdType, cmdText, cmdParms); - public object ExecuteScalar(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { + 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(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) { 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, cmdType, cmdText, cmdParms, logtxt); + var pc = PrepareCommand(transaction, connection, cmdType, cmdText, cmdParms, logtxt); object val = null; Exception ex = null; try { - if (pc.cmd.Connection == null) pc.cmd.Connection = (conn = this.MasterPool.Get()).Value; - val = pc.cmd.ExecuteScalar(); + if (pc.Connection == null) pc.Connection = (conn = this.MasterPool.Get()).Value; + val = pc.ExecuteScalar(); } catch (Exception ex2) { ex = ex2; } @@ -269,12 +289,12 @@ 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, pc.cmd, ex, dt, logtxt); - pc.cmd.Parameters.Clear(); + LoggerException(this.MasterPool, pc, ex, dt, logtxt); + pc.Parameters.Clear(); return val; } - private (DbTransaction tran, DbCommand cmd) PrepareCommand(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, StringBuilder logtxt) { + DbCommand PrepareCommand(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, DbParameter[] cmdParms, StringBuilder logtxt) { var dt = DateTime.Now; DbCommand cmd = CreateCommand(); cmd.CommandType = cmdType; @@ -296,14 +316,15 @@ namespace FreeSql.Internal.CommonProvider { 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 + 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 (tran, cmd); + return cmd; } } } diff --git a/FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderAsync.cs b/FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderAsync.cs index dd78aa95..1974c6e6 100644 --- a/FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderAsync.cs +++ b/FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderAsync.cs @@ -9,16 +9,19 @@ using System.Threading.Tasks; namespace FreeSql.Internal.CommonProvider { partial class AdoProvider { - public Task> QueryAsync(string cmdText, object parms = null) => QueryAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task> QueryAsync(DbTransaction transaction, string cmdText, object parms = null) => QueryAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task> QueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync(null, cmdType, cmdText, cmdParms); - async public Task> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { + 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(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) { 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, dr => { + await ExecuteReaderAsync(transaction, connection, dr => { if (indexes == null) { var dic = new Dictionary(StringComparer.CurrentCultureIgnoreCase); for (var a = 0; a < dr.FieldCount; a++) @@ -30,10 +33,13 @@ namespace FreeSql.Internal.CommonProvider { }, cmdType, cmdText, cmdParms); return ret; } - public Task ExecuteReaderAsync(Func readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteReaderAsync(DbTransaction transaction, Func readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(transaction, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteReaderAsync(Func readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(null, readerHander, cmdType, cmdText, cmdParms); - async public Task ExecuteReaderAsync(DbTransaction transaction, Func readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { + 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(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) { if (string.IsNullOrEmpty(cmdText)) return; var dt = DateTime.Now; var logtxt = new StringBuilder(); @@ -41,23 +47,25 @@ namespace FreeSql.Internal.CommonProvider { var pool = this.MasterPool; var isSlave = false; - //读写分离规则 - if (this.SlavePools.Any() && cmdText.StartsWith("SELECT ", StringComparison.CurrentCultureIgnoreCase)) { - var availables = slaveUnavailables == 0 ? - //查从库 - this.SlavePools : ( - //查主库 - slaveUnavailables == this.SlavePools.Count ? new List>() : - //查从库可用 - this.SlavePools.Where(sp => sp.IsAvailable).ToList()); - if (availables.Any()) { - isSlave = true; - pool = availables.Count == 1 ? this.SlavePools[0] : availables[slaveRandom.Next(availables.Count)]; + if (transaction == null && connection == null) { + //读写分离规则 + if (this.SlavePools.Any() && cmdText.StartsWith("SELECT ", StringComparison.CurrentCultureIgnoreCase)) { + var availables = slaveUnavailables == 0 ? + //查从库 + this.SlavePools : ( + //查主库 + slaveUnavailables == this.SlavePools.Count ? new List>() : + //查从库可用 + this.SlavePools.Where(sp => sp.IsAvailable).ToList()); + if (availables.Any()) { + isSlave = true; + pool = availables.Count == 1 ? this.SlavePools[0] : availables[slaveRandom.Next(availables.Count)]; + } } } Object conn = null; - var cmd = PrepareCommandAsync(transaction, cmdType, cmdText, cmdParms, logtxt); + var cmd = PrepareCommandAsync(transaction, connection, 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 { @@ -127,24 +135,30 @@ namespace FreeSql.Internal.CommonProvider { LoggerException(pool, cmd, ex, dt, logtxt); cmd.Parameters.Clear(); } - public Task ExecuteArrayAsync(string cmdText, object parms = null) => ExecuteArrayAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteArrayAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArrayAsync(null, cmdType, cmdText, cmdParms); - async public Task ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { + 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(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) { List ret = new List(); - await ExecuteReaderAsync(transaction, async dr => { + await ExecuteReaderAsync(transaction, connection, 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); }, cmdType, cmdText, cmdParms); return ret.ToArray(); } - public Task ExecuteDataTableAsync(string cmdText, object parms = null) => ExecuteDataTableAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTableAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTableAsync(null, cmdType, cmdText, cmdParms); - async public Task ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { + 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(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) { var ret = new DataTable(); - await ExecuteReaderAsync(transaction, async dr => { + await ExecuteReaderAsync(transaction, connection, 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]; @@ -153,16 +167,19 @@ namespace FreeSql.Internal.CommonProvider { }, cmdType, cmdText, cmdParms); return ret; } - public Task ExecuteNonQueryAsync(string cmdText, object parms = null) => ExecuteNonQueryAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQueryAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(null, cmdType, cmdText, cmdParms); - async public Task ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { + 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(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) { 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, cmdType, cmdText, cmdParms, logtxt); + var cmd = PrepareCommandAsync(transaction, connection, cmdType, cmdText, cmdParms, logtxt); int val = 0; Exception ex = null; try { @@ -181,16 +198,19 @@ namespace FreeSql.Internal.CommonProvider { cmd.Parameters.Clear(); return val; } - public Task ExecuteScalarAsync(string cmdText, object parms = null) => ExecuteScalarAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalarAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(null, cmdType, cmdText, cmdParms); - async public Task ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { + 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(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) { 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, cmdType, cmdText, cmdParms, logtxt); + var cmd = PrepareCommandAsync(transaction, connection, cmdType, cmdText, cmdParms, logtxt); object val = null; Exception ex = null; try { @@ -210,7 +230,7 @@ namespace FreeSql.Internal.CommonProvider { return val; } - private DbCommand PrepareCommandAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, StringBuilder logtxt) { + private DbCommand PrepareCommandAsync(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, DbParameter[] cmdParms, StringBuilder logtxt) { DateTime dt = DateTime.Now; DbCommand cmd = CreateCommand(); cmd.CommandType = cmdType; @@ -231,7 +251,8 @@ namespace FreeSql.Internal.CommonProvider { 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 + cmd.Connection = connection; if (IsTracePerformance) logtxt.Append(" PrepareCommandAsync ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms cmdParms: ").Append(cmd.Parameters.Count).Append("\r\n"); diff --git a/FreeSql/Internal/CommonProvider/DeleteProvider.cs b/FreeSql/Internal/CommonProvider/DeleteProvider.cs index 3b71b20b..7c7bac76 100644 --- a/FreeSql/Internal/CommonProvider/DeleteProvider.cs +++ b/FreeSql/Internal/CommonProvider/DeleteProvider.cs @@ -20,6 +20,7 @@ namespace FreeSql.Internal.CommonProvider { protected int _whereTimes = 0; protected List _params = new List(); protected DbTransaction _transaction; + protected DbConnection _connection; public DeleteProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) { _orm = orm; @@ -42,6 +43,10 @@ namespace FreeSql.Internal.CommonProvider { _transaction = transaction; return this; } + public IDelete WithConnection(DbConnection coinnection) { + _connection = coinnection; + return this; + } public int ExecuteAffrows() { var sql = this.ToSql(); diff --git a/FreeSql/Internal/CommonProvider/InsertProvider.cs b/FreeSql/Internal/CommonProvider/InsertProvider.cs index f24006b8..eb9c8928 100644 --- a/FreeSql/Internal/CommonProvider/InsertProvider.cs +++ b/FreeSql/Internal/CommonProvider/InsertProvider.cs @@ -22,6 +22,7 @@ namespace FreeSql.Internal.CommonProvider { protected bool _noneParameter; protected DbParameter[] _params; protected DbTransaction _transaction; + protected DbConnection _connection; public InsertProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression) { _orm = orm; @@ -42,6 +43,11 @@ namespace FreeSql.Internal.CommonProvider { _transaction = transaction; return this; } + public IInsert WithConnection(DbConnection coinnection) { + _connection = coinnection; + return this; + } + public IInsert NoneParameter() { _noneParameter = true; return this; diff --git a/FreeSql/Internal/CommonProvider/SelectProvider/Select0Provider.cs b/FreeSql/Internal/CommonProvider/SelectProvider/Select0Provider.cs index 98024e6d..41e8f70f 100644 --- a/FreeSql/Internal/CommonProvider/SelectProvider/Select0Provider.cs +++ b/FreeSql/Internal/CommonProvider/SelectProvider/Select0Provider.cs @@ -28,6 +28,7 @@ namespace FreeSql.Internal.CommonProvider { protected CommonUtils _commonUtils; protected CommonExpression _commonExpression; protected DbTransaction _transaction; + protected DbConnection _connection; protected Action _trackToList; internal static void CopyData(Select0Provider from, object to, ReadOnlyCollection lambParms) { @@ -61,6 +62,7 @@ namespace FreeSql.Internal.CommonProvider { //toType.GetField("_commonUtils", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._commonUtils); //toType.GetField("_commonExpression", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._commonExpression); toType.GetField("_transaction", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._transaction); + toType.GetField("_connection", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._connection); toType.GetField("_trackToList", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._trackToList); } @@ -82,6 +84,10 @@ namespace FreeSql.Internal.CommonProvider { _transaction = transaction; return this as TSelect; } + public TSelect WithConnection(DbConnection coinnection) { + _connection = coinnection; + return this as TSelect; + } public bool Any() { this.Limit(1); @@ -201,14 +207,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, CommandType.Text, sql, _params.ToArray())); + _orm.Ado.ExecuteDataTable(_transaction?.Connection ?? _connection, 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, CommandType.Text, sql, _params.ToArray())); + _orm.Ado.ExecuteDataTableAsync(_transaction?.Connection ?? _connection, CommandType.Text, sql, _params.ToArray())); } public List ToList(string field) { @@ -218,7 +224,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, dr => { + _orm.Ado.ExecuteReader(_transaction?.Connection ?? _connection, dr => { var read = Utils.ExecuteArrayRowReadClassOrTuple(type, null, dr, 0, _commonUtils); ret.Add((TTuple)read.Value); }, CommandType.Text, sql, _params.ToArray()); diff --git a/FreeSql/Internal/CommonProvider/UpdateProvider.cs b/FreeSql/Internal/CommonProvider/UpdateProvider.cs index 7951c178..635fb3ad 100644 --- a/FreeSql/Internal/CommonProvider/UpdateProvider.cs +++ b/FreeSql/Internal/CommonProvider/UpdateProvider.cs @@ -26,6 +26,7 @@ namespace FreeSql.Internal.CommonProvider { protected List _paramsSource = new List(); protected bool _noneParameter; protected DbTransaction _transaction; + protected DbConnection _connection; public UpdateProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) { _orm = orm; @@ -51,6 +52,11 @@ namespace FreeSql.Internal.CommonProvider { _transaction = transaction; return this; } + public IUpdate WithConnection(DbConnection coinnection) { + _connection = coinnection; + return this; + } + public IUpdate NoneParameter() { _noneParameter = true; return this; diff --git a/FreeSql/MySql/MySqlAdo/MySqlAdo.cs b/FreeSql/MySql/MySqlAdo/MySqlAdo.cs index fe635fb9..5e623332 100644 --- a/FreeSql/MySql/MySqlAdo/MySqlAdo.cs +++ b/FreeSql/MySql/MySqlAdo/MySqlAdo.cs @@ -14,11 +14,13 @@ 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; - 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 (!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); + } } } } diff --git a/FreeSql/MySql/MySqlConnectionExtensions.cs b/FreeSql/MySql/MySqlConnectionExtensions.cs new file mode 100644 index 00000000..5b9f3173 --- /dev/null +++ b/FreeSql/MySql/MySqlConnectionExtensions.cs @@ -0,0 +1,30 @@ +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); + } +}