tk/FreeSql
1
0
Fork 0
mirror of https://github.com/nsnail/FreeSql.git synced 2025-04-22 02:32:50 +08:00
Code Issues Packages Projects Releases Wiki Activity

- 修复 MySql 枚举表达式 == 解析成数字的 bug；

Browse Source 
- 增加 Connection 对象扩展方法，实现像 Dapper 的使用习惯；
This commit is contained in:
28810 2019-04-10 21:19:32 +08:00
parent c3c7539150
commit d1a07dc888
18 changed files with 432 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
FreeSql.Tests/MySql/Curd/MySqlSelectTest.cs
View File

@ -236,7 +236,20 @@ namespace FreeSql.Tests.MySql {
} }
[Fact] [Fact]
public void ToSql() { public void ToSql() {
g.mysql.Insert<testenumWhere>().AppendData(new testenumWhere { type = testenumWhereType.Blaaa }).ExecuteAffrows();
var sql1 = g.mysql.Select<testenumWhere>().Where(a => a.type == testenumWhereType.Blaaa).ToSql();
var sql2 = g.mysql.Select<testenumWhere>().Where(a => testenumWhereType.Blaaa == a.type).ToSql();
var sql3 = g.mysql.Select<testenumWhere>().Where(a => a.type.Equals(testenumWhereType.Blaaa)).ToSql();
var tolist = g.mysql.Select<testenumWhere>().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] [Fact]
public void Any() { public void Any() {
var count = select.Where(a => 1 == 1).Count(); var count = select.Where(a => 1 == 1).Count();

84
FreeSql.Tests/MySql/MySqlConnectionExtensionsTest.cs Normal file
View File

@ -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<TestConnectionExt>().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<TestConnectionExt>().AppendData(item).ExecuteAffrows();
Assert.Equal(1, affrows);
item = conn.Select<TestConnectionExt>().First();
affrows = conn.Update<TestConnectionExt>().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<TestConnectionExt>().AppendData(item).ExecuteAffrows();
Assert.Equal(1, affrows);
affrows = conn.Delete<TestConnectionExt>().Where(item).ExecuteAffrows();
conn.Close();
}
Assert.Equal(1, affrows);
}
[Fact]
public void Select() {
var list = new List<TestConnectionExt>();
var affrows = 0;
using (var conn = new MySqlConnection(_connectString)) {
var item = new TestConnectionExt { title = "testselect" };
affrows = conn.Insert<TestConnectionExt>().AppendData(item).ExecuteAffrows();
Assert.Equal(1, affrows);
list = conn.Select<TestConnectionExt>().Where(a => a.id == item.id).ToList();
conn.Close();
}
Assert.Single(list);
}
[Fact]
public void Query() {
var list = new List<TestConnectionExt>();
var affrows = 0;
using (var conn = new MySqlConnection(_connectString)) {
var item = new TestConnectionExt { title = "testquery" };
affrows = conn.Insert<TestConnectionExt>().AppendData(item).ExecuteAffrows();
Assert.Equal(1, affrows);
list = conn.Query<TestConnectionExt>("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;
}
}
}

6
FreeSql/Interface/Curd/IDelete.cs
View File

@ -13,6 +13,12 @@ namespace FreeSql {
/// <param name="transaction"></param> /// <param name="transaction"></param>
/// <returns></returns> /// <returns></returns>
IDelete<T1> WithTransaction(DbTransaction transaction); IDelete<T1> WithTransaction(DbTransaction transaction);
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="transaction"></param>
/// <returns></returns>
IDelete<T1> WithConnection(DbConnection connection);
/// <summary> /// <summary>
/// lambda表达式条件，仅支持实体基础成员（不包含导航对象） /// lambda表达式条件，仅支持实体基础成员（不包含导航对象）

6
FreeSql/Interface/Curd/IInsert.cs
View File

@ -13,6 +13,12 @@ namespace FreeSql {
/// <param name="transaction"></param> /// <param name="transaction"></param>
/// <returns></returns> /// <returns></returns>
IInsert<T1> WithTransaction(DbTransaction transaction); IInsert<T1> WithTransaction(DbTransaction transaction);
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="transaction"></param>
/// <returns></returns>
IInsert<T1> WithConnection(DbConnection connection);
/// <summary> /// <summary>
/// 追加准备插入的实体 /// 追加准备插入的实体

6
FreeSql/Interface/Curd/ISelect/ISelect0.cs
View File

@ -15,6 +15,12 @@ namespace FreeSql {
/// <param name="transaction"></param> /// <param name="transaction"></param>
/// <returns></returns> /// <returns></returns>
TSelect WithTransaction(DbTransaction transaction); TSelect WithTransaction(DbTransaction transaction);
/// <summary>
/// 指定连接对象
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
TSelect WithConnection(DbConnection connection);
/// <summary> /// <summary>
/// 审核或跟踪 ToList 即将返回的数据 /// 审核或跟踪 ToList 即将返回的数据

6
FreeSql/Interface/Curd/IUpdate.cs
View File

@ -13,6 +13,12 @@ namespace FreeSql {
/// <param name="transaction"></param> /// <param name="transaction"></param>
/// <returns></returns> /// <returns></returns>
IUpdate<T1> WithTransaction(DbTransaction transaction); IUpdate<T1> WithTransaction(DbTransaction transaction);
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="transaction"></param>
/// <returns></returns>
IUpdate<T1> WithConnection(DbConnection connection);
/// <summary> /// <summary>
/// 不使用参数化，可通过 IFreeSql.CodeFirst.IsNotCommandParameter 全局性设置 /// 不使用参数化，可通过 IFreeSql.CodeFirst.IsNotCommandParameter 全局性设置

24
FreeSql/Interface/IAdo.cs
View File

@ -62,6 +62,7 @@ namespace FreeSql {
/// <param name="cmdParms"></param> /// <param name="cmdParms"></param>
void ExecuteReader(Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); void ExecuteReader(Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
void ExecuteReader(DbConnection connection, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary> /// <summary>
/// 查询，ExecuteReader(dr => {}, "select * from user where age > @age", new { age = 25 }) /// 查询，ExecuteReader(dr => {}, "select * from user where age > @age", new { age = 25 })
/// </summary> /// </summary>
@ -69,6 +70,7 @@ namespace FreeSql {
/// <param name="parms"></param> /// <param name="parms"></param>
void ExecuteReader(Action<DbDataReader> readerHander, string cmdText, object parms = null); void ExecuteReader(Action<DbDataReader> readerHander, string cmdText, object parms = null);
void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, string cmdText, object parms = null); void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, string cmdText, object parms = null);
void ExecuteReader(DbConnection connection, Action<DbDataReader> readerHander, string cmdText, object parms = null);
/// <summary> /// <summary>
/// 查询 /// 查询
/// </summary> /// </summary>
@ -76,6 +78,7 @@ namespace FreeSql {
/// <param name="cmdParms"></param> /// <param name="cmdParms"></param>
object[][] ExecuteArray(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); object[][] ExecuteArray(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
object[][] ExecuteArray(DbTransaction transaction, 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);
/// <summary> /// <summary>
/// 查询，ExecuteArray("select * from user where age > @age", new { age = 25 }) /// 查询，ExecuteArray("select * from user where age > @age", new { age = 25 })
/// </summary> /// </summary>
@ -84,6 +87,7 @@ namespace FreeSql {
/// <returns></returns> /// <returns></returns>
object[][] ExecuteArray(string cmdText, object parms = null); object[][] ExecuteArray(string cmdText, object parms = null);
object[][] ExecuteArray(DbTransaction transaction, string cmdText, object parms = null); object[][] ExecuteArray(DbTransaction transaction, string cmdText, object parms = null);
object[][] ExecuteArray(DbConnection connection, string cmdText, object parms = null);
/// <summary> /// <summary>
/// 查询 /// 查询
/// </summary> /// </summary>
@ -91,6 +95,7 @@ namespace FreeSql {
/// <param name="cmdParms"></param> /// <param name="cmdParms"></param>
DataTable ExecuteDataTable(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); DataTable ExecuteDataTable(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
DataTable ExecuteDataTable(DbTransaction transaction, 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);
/// <summary> /// <summary>
/// 查询，ExecuteDataTable("select * from user where age > @age", new { age = 25 }) /// 查询，ExecuteDataTable("select * from user where age > @age", new { age = 25 })
/// </summary> /// </summary>
@ -99,6 +104,7 @@ namespace FreeSql {
/// <returns></returns> /// <returns></returns>
DataTable ExecuteDataTable(string cmdText, object parms = null); DataTable ExecuteDataTable(string cmdText, object parms = null);
DataTable ExecuteDataTable(DbTransaction transaction, string cmdText, object parms = null); DataTable ExecuteDataTable(DbTransaction transaction, string cmdText, object parms = null);
DataTable ExecuteDataTable(DbConnection connection, string cmdText, object parms = null);
/// <summary> /// <summary>
/// 在【主库】执行 /// 在【主库】执行
/// </summary> /// </summary>
@ -107,6 +113,7 @@ namespace FreeSql {
/// <param name="cmdParms"></param> /// <param name="cmdParms"></param>
int ExecuteNonQuery(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); int ExecuteNonQuery(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
int ExecuteNonQuery(DbTransaction transaction, 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);
/// <summary> /// <summary>
/// 在【主库】执行，ExecuteNonQuery("delete from user where age > @age", new { age = 25 }) /// 在【主库】执行，ExecuteNonQuery("delete from user where age > @age", new { age = 25 })
/// </summary> /// </summary>
@ -115,6 +122,7 @@ namespace FreeSql {
/// <returns></returns> /// <returns></returns>
int ExecuteNonQuery(string cmdText, object parms = null); int ExecuteNonQuery(string cmdText, object parms = null);
int ExecuteNonQuery(DbTransaction transaction, string cmdText, object parms = null); int ExecuteNonQuery(DbTransaction transaction, string cmdText, object parms = null);
int ExecuteNonQuery(DbConnection connection, string cmdText, object parms = null);
/// <summary> /// <summary>
/// 在【主库】执行 /// 在【主库】执行
/// </summary> /// </summary>
@ -123,6 +131,7 @@ namespace FreeSql {
/// <param name="cmdParms"></param> /// <param name="cmdParms"></param>
object ExecuteScalar(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); object ExecuteScalar(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
object ExecuteScalar(DbTransaction transaction, 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);
/// <summary> /// <summary>
/// 在【主库】执行，ExecuteScalar("select 1 from user where age > @age", new { age = 25 }) /// 在【主库】执行，ExecuteScalar("select 1 from user where age > @age", new { age = 25 })
/// </summary> /// </summary>
@ -131,6 +140,7 @@ namespace FreeSql {
/// <returns></returns> /// <returns></returns>
object ExecuteScalar(string cmdText, object parms = null); object ExecuteScalar(string cmdText, object parms = null);
object ExecuteScalar(DbTransaction transaction, string cmdText, object parms = null); object ExecuteScalar(DbTransaction transaction, string cmdText, object parms = null);
object ExecuteScalar(DbConnection connection, string cmdText, object parms = null);
/// <summary> /// <summary>
/// 执行SQL返回对象集合，Query&lt;User&gt;("select * from user where age > @age", new SqlParameter { ParameterName = "age", Value = 25 }) /// 执行SQL返回对象集合，Query&lt;User&gt;("select * from user where age > @age", new SqlParameter { ParameterName = "age", Value = 25 })
@ -142,6 +152,7 @@ namespace FreeSql {
/// <returns></returns> /// <returns></returns>
List<T> Query<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); List<T> Query<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
List<T> Query<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); List<T> Query<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
List<T> Query<T>(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary> /// <summary>
/// 执行SQL返回对象集合，Query&lt;User&gt;("select * from user where age > @age", new { age = 25 }) /// 执行SQL返回对象集合，Query&lt;User&gt;("select * from user where age > @age", new { age = 25 })
/// </summary> /// </summary>
@ -151,6 +162,7 @@ namespace FreeSql {
/// <returns></returns> /// <returns></returns>
List<T> Query<T>(string cmdText, object parms = null); List<T> Query<T>(string cmdText, object parms = null);
List<T> Query<T>(DbTransaction transaction, string cmdText, object parms = null); List<T> Query<T>(DbTransaction transaction, string cmdText, object parms = null);
List<T> Query<T>(DbConnection connection, string cmdText, object parms = null);
#region async #region async
/// <summary> /// <summary>
@ -162,6 +174,7 @@ namespace FreeSql {
/// <param name="cmdParms"></param> /// <param name="cmdParms"></param>
Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task ExecuteReaderAsync(DbConnection connection, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary> /// <summary>
/// 查询，ExecuteReaderAsync(dr => {}, "select * from user where age > @age", new { age = 25 }) /// 查询，ExecuteReaderAsync(dr => {}, "select * from user where age > @age", new { age = 25 })
/// </summary> /// </summary>
@ -169,6 +182,7 @@ namespace FreeSql {
/// <param name="parms"></param> /// <param name="parms"></param>
Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, string cmdText, object parms = null); Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, string cmdText, object parms = null);
Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, string cmdText, object parms = null); Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, string cmdText, object parms = null);
Task ExecuteReaderAsync(DbConnection connection, Func<DbDataReader, Task> readerHander, string cmdText, object parms = null);
/// <summary> /// <summary>
/// 查询 /// 查询
/// </summary> /// </summary>
@ -176,6 +190,7 @@ namespace FreeSql {
/// <param name="cmdParms"></param> /// <param name="cmdParms"></param>
Task<object[][]> ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<object[][]> ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<object[][]> ExecuteArrayAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary> /// <summary>
/// 查询，ExecuteArrayAsync("select * from user where age > @age", new { age = 25 }) /// 查询，ExecuteArrayAsync("select * from user where age > @age", new { age = 25 })
/// </summary> /// </summary>
@ -184,6 +199,7 @@ namespace FreeSql {
/// <returns></returns> /// <returns></returns>
Task<object[][]> ExecuteArrayAsync(string cmdText, object parms = null); Task<object[][]> ExecuteArrayAsync(string cmdText, object parms = null);
Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null); Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null);
Task<object[][]> ExecuteArrayAsync(DbConnection connection, string cmdText, object parms = null);
/// <summary> /// <summary>
/// 查询 /// 查询
/// </summary> /// </summary>
@ -191,6 +207,7 @@ namespace FreeSql {
/// <param name="cmdParms"></param> /// <param name="cmdParms"></param>
Task<DataTable> ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<DataTable> ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<DataTable> ExecuteDataTableAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary> /// <summary>
/// 查询，ExecuteDataTableAsync("select * from user where age > @age", new { age = 25 }) /// 查询，ExecuteDataTableAsync("select * from user where age > @age", new { age = 25 })
/// </summary> /// </summary>
@ -199,6 +216,7 @@ namespace FreeSql {
/// <returns></returns> /// <returns></returns>
Task<DataTable> ExecuteDataTableAsync(string cmdText, object parms = null); Task<DataTable> ExecuteDataTableAsync(string cmdText, object parms = null);
Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null); Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null);
Task<DataTable> ExecuteDataTableAsync(DbConnection connection, string cmdText, object parms = null);
/// <summary> /// <summary>
/// 在【主库】执行 /// 在【主库】执行
/// </summary> /// </summary>
@ -207,6 +225,7 @@ namespace FreeSql {
/// <param name="cmdParms"></param> /// <param name="cmdParms"></param>
Task<int> ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<int> ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<int> ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<int> ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<int> ExecuteNonQueryAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary> /// <summary>
/// 在【主库】执行，ExecuteNonQueryAsync("delete from user where age > @age", new { age = 25 }) /// 在【主库】执行，ExecuteNonQueryAsync("delete from user where age > @age", new { age = 25 })
/// </summary> /// </summary>
@ -215,6 +234,7 @@ namespace FreeSql {
/// <returns></returns> /// <returns></returns>
Task<int> ExecuteNonQueryAsync(string cmdText, object parms = null); Task<int> ExecuteNonQueryAsync(string cmdText, object parms = null);
Task<int> ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null); Task<int> ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null);
Task<int> ExecuteNonQueryAsync(DbConnection connection, string cmdText, object parms = null);
/// <summary> /// <summary>
/// 在【主库】执行 /// 在【主库】执行
/// </summary> /// </summary>
@ -223,6 +243,7 @@ namespace FreeSql {
/// <param name="cmdParms"></param> /// <param name="cmdParms"></param>
Task<object> ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<object> ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<object> ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<object> ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<object> ExecuteScalarAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary> /// <summary>
/// 在【主库】执行，ExecuteScalarAsync("select 1 from user where age > @age", new { age = 25 }) /// 在【主库】执行，ExecuteScalarAsync("select 1 from user where age > @age", new { age = 25 })
/// </summary> /// </summary>
@ -231,6 +252,7 @@ namespace FreeSql {
/// <returns></returns> /// <returns></returns>
Task<object> ExecuteScalarAsync(string cmdText, object parms = null); Task<object> ExecuteScalarAsync(string cmdText, object parms = null);
Task<object> ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null); Task<object> ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null);
Task<object> ExecuteScalarAsync(DbConnection connection, string cmdText, object parms = null);
/// <summary> /// <summary>
/// 执行SQL返回对象集合，QueryAsync&lt;User&gt;("select * from user where age > @age", new SqlParameter { ParameterName = "age", Value = 25 }) /// 执行SQL返回对象集合，QueryAsync&lt;User&gt;("select * from user where age > @age", new SqlParameter { ParameterName = "age", Value = 25 })
@ -242,6 +264,7 @@ namespace FreeSql {
/// <returns></returns> /// <returns></returns>
Task<List<T>> QueryAsync<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<List<T>> QueryAsync<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<List<T>> QueryAsync<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<List<T>> QueryAsync<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<List<T>> QueryAsync<T>(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary> /// <summary>
/// 执行SQL返回对象集合，QueryAsync&lt;User&gt;("select * from user where age > @age", new { age = 25 }) /// 执行SQL返回对象集合，QueryAsync&lt;User&gt;("select * from user where age > @age", new { age = 25 })
/// </summary> /// </summary>
@ -251,6 +274,7 @@ namespace FreeSql {
/// <returns></returns> /// <returns></returns>
Task<List<T>> QueryAsync<T>(string cmdText, object parms = null); Task<List<T>> QueryAsync<T>(string cmdText, object parms = null);
Task<List<T>> QueryAsync<T>(DbTransaction transaction, string cmdText, object parms = null); Task<List<T>> QueryAsync<T>(DbTransaction transaction, string cmdText, object parms = null);
Task<List<T>> QueryAsync<T>(DbConnection connection, string cmdText, object parms = null);
#endregion #endregion
} }
} }

57
FreeSql/Interface/IDbManage.cs Normal file
View File

@ -0,0 +1,57 @@
//using FreeSql.DatabaseModel;
//using System;
//using System.Collections.Generic;
//using System.Text;
//namespace FreeSql {
// public interface IDbManage {
// /// <summary>
// /// 判断表是否存在
// /// </summary>
// /// <param name="name">表名</param>
// /// <returns></returns>
// bool ExistsTable(string name);
// /// <summary>
// /// 判断列是否存在
// /// </summary>
// /// <param name="table">表名</param>
// /// <param name="column">列名</param>
// /// <returns></returns>
// bool ExistsColumn(string table, string column);
// /// <summary>
// /// 判断视图是否存在
// /// </summary>
// /// <param name="name">视图名</param>
// /// <returns></returns>
// bool ExistsView(string name);
// /// <summary>
// /// 判断列是否存在
// /// </summary>
// /// <param name="view">视图名</param>
// /// <param name="column">列名</param>
// /// <returns></returns>
// bool ExistsColumnByView(string view, string column);
// /// <summary>
// /// 获取表信息，包括表、列详情、主键、唯一键、索引、备注（注意：本方法不返回外键）
// /// </summary>
// /// <param name="name">表名</param>
// /// <returns></returns>
// DbTableInfo GetTableInfo(string name);
// /// <summary>
// /// 获取视图信息，包括表、列详情
// /// </summary>
// /// <param name="name">视图名</param>
// /// <returns></returns>
// DbTableInfo GetViewInfo(string name);
// /// <summary>
// /// 获取指定数据库的表信息，包括表、列详情、主键、唯一键、索引、外键、备注
// /// </summary>
// /// <param name="database"></param>
// /// <returns></returns>
// List<DbTableInfo> GetTablesByDatabase(params string[] database);
// }
//}

2
FreeSql/Interface/iDbFirst.cs
View File

@ -11,7 +11,7 @@ namespace FreeSql {
/// <returns></returns> /// <returns></returns>
List<string> GetDatabases(); List<string> GetDatabases();
/// <summary> /// <summary>
/// 获取指定数据库的表信息，包括表、列详情、主键、唯一键、索引、外键 /// 获取指定数据库的表信息，包括表、列详情、主键、唯一键、索引、外键、备注
/// </summary> /// </summary>
/// <param name="database"></param> /// <param name="database"></param>
/// <returns></returns> /// <returns></returns>

18
FreeSql/Internal/CommonExpression.cs
View File

@ -324,7 +324,7 @@ namespace FreeSql.Internal {
tmpleft = tmp33; tmpleft = tmp33;
} }
if (tmpright == "NULL") tmptryoper = " IS "; if (tmpright == "NULL") tmptryoper = " IS ";
return $"{tmpleft}{tmptryoper}{tmpright}"; return $"{tmpleft} {tmptryoper} {tmpright}";
} }
if (callType.FullName.StartsWith("FreeSql.ISelectGroupingAggregate`")) { if (callType.FullName.StartsWith("FreeSql.ISelectGroupingAggregate`")) {
switch (exp3.Method.Name) { switch (exp3.Method.Name) {
@ -760,6 +760,22 @@ namespace FreeSql.Internal {
if (right == "NULL") tryoper = tryoper == "=" ? " IS " : " IS NOT "; 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 == "+" && (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 (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}"; return $"{left} {tryoper} {right}";
} }

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

@ -41,9 +41,9 @@ namespace FreeSql.Internal.CommonProvider {
if (IsTracePerformance) { if (IsTracePerformance) {
TimeSpan ts = DateTime.Now.Subtract(dt); TimeSpan ts = DateTime.Now.Subtract(dt);
if (e == null && ts.TotalMilliseconds > 100) 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 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) { if (e == null) {
@ -52,7 +52,7 @@ namespace FreeSql.Internal.CommonProvider {
} }
StringBuilder log = new StringBuilder(); 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) 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"); 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<Type, PropertyInfo[]> dicQueryTypeGetProperties = new ConcurrentDictionary<Type, PropertyInfo[]>(); internal static ConcurrentDictionary<Type, PropertyInfo[]> dicQueryTypeGetProperties = new ConcurrentDictionary<Type, PropertyInfo[]>();
public List<T> Query<T>(string cmdText, object parms = null) => Query<T>(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public List<T> Query<T>(string cmdText, object parms = null) => Query<T>(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public List<T> Query<T>(DbTransaction transaction, string cmdText, object parms = null) => Query<T>(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public List<T> Query<T>(DbTransaction transaction, string cmdText, object parms = null) => Query<T>(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public List<T> Query<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => Query<T>(null, cmdType, cmdText, cmdParms); public List<T> Query<T>(DbConnection connection, string cmdText, object parms = null) => Query<T>(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public List<T> Query<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { public List<T> Query<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => Query<T>(null, null, cmdType, cmdText, cmdParms);
public List<T> Query<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => Query<T>(transaction, null, cmdType, cmdText, cmdParms);
public List<T> Query<T>(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => Query<T>(null, connection, cmdType, cmdText, cmdParms);
List<T> Query<T>(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var ret = new List<T>(); var ret = new List<T>();
if (string.IsNullOrEmpty(cmdText)) return ret; if (string.IsNullOrEmpty(cmdText)) return ret;
var type = typeof(T); var type = typeof(T);
int[] indexes = null; int[] indexes = null;
var props = dicQueryTypeGetProperties.GetOrAdd(type, k => type.GetProperties()); var props = dicQueryTypeGetProperties.GetOrAdd(type, k => type.GetProperties());
ExecuteReader(transaction, dr => { ExecuteReader(transaction, connection, dr => {
if (indexes == null) { if (indexes == null) {
var dic = new Dictionary<string, int>(StringComparer.CurrentCultureIgnoreCase); var dic = new Dictionary<string, int>(StringComparer.CurrentCultureIgnoreCase);
for (var a = 0; a < dr.FieldCount; a++) for (var a = 0; a < dr.FieldCount; a++)
@ -94,10 +97,13 @@ namespace FreeSql.Internal.CommonProvider {
}, cmdType, cmdText, cmdParms); }, cmdType, cmdText, cmdParms);
return ret; return ret;
} }
public void ExecuteReader(Action<DbDataReader> readerHander, string cmdText, object parms = null) => ExecuteReader(null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public void ExecuteReader(Action<DbDataReader> readerHander, string cmdText, object parms = null) => ExecuteReader(null, null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, string cmdText, object parms = null) => ExecuteReader(transaction, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, string cmdText, object parms = null) => ExecuteReader(transaction, null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public void ExecuteReader(Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReader(null, readerHander, cmdType, cmdText, cmdParms); public void ExecuteReader(DbConnection connection, Action<DbDataReader> readerHander, string cmdText, object parms = null) => ExecuteReader(null, connection, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { public void ExecuteReader(Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReader(null, null, readerHander, cmdType, cmdText, cmdParms);
public void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReader(transaction, null, readerHander, cmdType, cmdText, cmdParms);
public void ExecuteReader(DbConnection connection, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReader(null, connection, readerHander, cmdType, cmdText, cmdParms);
void ExecuteReader(DbTransaction transaction, DbConnection connection, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
if (string.IsNullOrEmpty(cmdText)) return; if (string.IsNullOrEmpty(cmdText)) return;
var dt = DateTime.Now; var dt = DateTime.Now;
var logtxt = new StringBuilder(); var logtxt = new StringBuilder();
@ -105,23 +111,25 @@ namespace FreeSql.Internal.CommonProvider {
var pool = this.MasterPool; var pool = this.MasterPool;
var isSlave = false; var isSlave = false;
//读写分离规则 if (transaction == null && connection == null) {
if (this.SlavePools.Any() && cmdText.StartsWith("SELECT ", StringComparison.CurrentCultureIgnoreCase)) { //读写分离规则
var availables = slaveUnavailables == 0 ? if (this.SlavePools.Any() && cmdText.StartsWith("SELECT ", StringComparison.CurrentCultureIgnoreCase)) {
//查从库 var availables = slaveUnavailables == 0 ?
this.SlavePools : ( //查从库
//查主库 this.SlavePools : (
slaveUnavailables == this.SlavePools.Count ? new List<ObjectPool<DbConnection>>() : //查主库
//查从库可用 slaveUnavailables == this.SlavePools.Count ? new List<ObjectPool<DbConnection>>() :
this.SlavePools.Where(sp => sp.IsAvailable).ToList()); //查从库可用
if (availables.Any()) { this.SlavePools.Where(sp => sp.IsAvailable).ToList());
isSlave = true; if (availables.Any()) {
pool = availables.Count == 1 ? availables[0] : availables[slaveRandom.Next(availables.Count)]; isSlave = true;
pool = availables.Count == 1 ? availables[0] : availables[slaveRandom.Next(availables.Count)];
}
} }
} }
Object<DbConnection> conn = null; Object<DbConnection> 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"); 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; Exception ex = null;
try { try {
@ -130,7 +138,7 @@ namespace FreeSql.Internal.CommonProvider {
//从库查询切换，恢复 //从库查询切换，恢复
bool isSlaveFail = false; bool isSlaveFail = false;
try { 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("测试从库抛出异常"); //if (slaveRandom.Next(100) % 2 == 0) throw new Exception("测试从库抛出异常");
} catch { } catch {
isSlaveFail = true; isSlaveFail = true;
@ -141,20 +149,20 @@ namespace FreeSql.Internal.CommonProvider {
ReturnConnection(pool, conn, ex); //pool.Return(conn, ex); 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"); 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); LoggerException(pool, pc, new Exception($"连接失败，准备切换其他可用服务器"), dt, logtxt, false);
pc.cmd.Parameters.Clear(); pc.Parameters.Clear();
ExecuteReader(readerHander, cmdType, cmdText, cmdParms); ExecuteReader(readerHander, cmdType, cmdText, cmdParms);
return; return;
} }
} else { } 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) { 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.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; 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"); 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) { while (true) {
if (IsTracePerformance) logtxt_dt = DateTime.Now; if (IsTracePerformance) logtxt_dt = DateTime.Now;
@ -188,27 +196,33 @@ namespace FreeSql.Internal.CommonProvider {
ReturnConnection(pool, conn, ex); //pool.Return(conn, ex); 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"); 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); LoggerException(pool, pc, ex, dt, logtxt);
pc.cmd.Parameters.Clear(); pc.Parameters.Clear();
} }
public object[][] ExecuteArray(string cmdText, object parms = null) => ExecuteArray(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); 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, 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(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArray(null, cmdType, cmdText, cmdParms); public object[][] ExecuteArray(DbConnection connection, string cmdText, object parms = null) => ExecuteArray(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object[][] ExecuteArray(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { 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<object[]> ret = new List<object[]>(); List<object[]> ret = new List<object[]>();
ExecuteReader(transaction, dr => { ExecuteReader(transaction, connection, dr => {
object[] values = new object[dr.FieldCount]; object[] values = new object[dr.FieldCount];
dr.GetValues(values); dr.GetValues(values);
ret.Add(values); ret.Add(values);
}, cmdType, cmdText, cmdParms); }, cmdType, cmdText, cmdParms);
return ret.ToArray(); return ret.ToArray();
} }
public DataTable ExecuteDataTable(string cmdText, object parms = null) => ExecuteDataTable(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); 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, 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(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTable(null, cmdType, cmdText, cmdParms); public DataTable ExecuteDataTable(DbConnection connection, string cmdText, object parms = null) => ExecuteDataTable(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public DataTable ExecuteDataTable(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { 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(); var ret = new DataTable();
ExecuteReader(transaction, dr => { ExecuteReader(transaction, connection, dr => {
if (ret.Columns.Count == 0) if (ret.Columns.Count == 0)
for (var a = 0; a < dr.FieldCount; a++) ret.Columns.Add(dr.GetName(a)); for (var a = 0; a < dr.FieldCount; a++) ret.Columns.Add(dr.GetName(a));
object[] values = new object[ret.Columns.Count]; object[] values = new object[ret.Columns.Count];
@ -217,21 +231,24 @@ namespace FreeSql.Internal.CommonProvider {
}, cmdType, cmdText, cmdParms); }, cmdType, cmdText, cmdParms);
return ret; return ret;
} }
public int ExecuteNonQuery(string cmdText, object parms = null) => ExecuteNonQuery(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); 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, 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(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQuery(null, cmdType, cmdText, cmdParms); public int ExecuteNonQuery(DbConnection connection, string cmdText, object parms = null) => ExecuteNonQuery(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public int ExecuteNonQuery(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { 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; if (string.IsNullOrEmpty(cmdText)) return 0;
var dt = DateTime.Now; var dt = DateTime.Now;
var logtxt = new StringBuilder(); var logtxt = new StringBuilder();
var logtxt_dt = DateTime.Now; var logtxt_dt = DateTime.Now;
Object<DbConnection> conn = null; Object<DbConnection> conn = null;
var pc = PrepareCommand(transaction, cmdType, cmdText, cmdParms, logtxt); var pc = PrepareCommand(transaction, connection, cmdType, cmdText, cmdParms, logtxt);
int val = 0; int val = 0;
Exception ex = null; Exception ex = null;
try { try {
if (pc.cmd.Connection == null) pc.cmd.Connection = (conn = this.MasterPool.Get()).Value; if (pc.Connection == null) pc.Connection = (conn = this.MasterPool.Get()).Value;
val = pc.cmd.ExecuteNonQuery(); val = pc.ExecuteNonQuery();
} catch (Exception ex2) { } catch (Exception ex2) {
ex = ex2; ex = ex2;
} }
@ -241,25 +258,28 @@ namespace FreeSql.Internal.CommonProvider {
ReturnConnection(MasterPool, conn, ex); //this.MasterPool.Return(conn, ex); 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"); 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); LoggerException(this.MasterPool, pc, ex, dt, logtxt);
pc.cmd.Parameters.Clear(); pc.Parameters.Clear();
return val; return val;
} }
public object ExecuteScalar(string cmdText, object parms = null) => ExecuteScalar(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); 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, 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(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalar(null, cmdType, cmdText, cmdParms); public object ExecuteScalar(DbConnection connection, string cmdText, object parms = null) => ExecuteScalar(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object ExecuteScalar(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { 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; if (string.IsNullOrEmpty(cmdText)) return null;
var dt = DateTime.Now; var dt = DateTime.Now;
var logtxt = new StringBuilder(); var logtxt = new StringBuilder();
var logtxt_dt = DateTime.Now; var logtxt_dt = DateTime.Now;
Object<DbConnection> conn = null; Object<DbConnection> conn = null;
var pc = PrepareCommand(transaction, cmdType, cmdText, cmdParms, logtxt); var pc = PrepareCommand(transaction, connection, cmdType, cmdText, cmdParms, logtxt);
object val = null; object val = null;
Exception ex = null; Exception ex = null;
try { try {
if (pc.cmd.Connection == null) pc.cmd.Connection = (conn = this.MasterPool.Get()).Value; if (pc.Connection == null) pc.Connection = (conn = this.MasterPool.Get()).Value;
val = pc.cmd.ExecuteScalar(); val = pc.ExecuteScalar();
} catch (Exception ex2) { } catch (Exception ex2) {
ex = ex2; ex = ex2;
} }
@ -269,12 +289,12 @@ namespace FreeSql.Internal.CommonProvider {
ReturnConnection(MasterPool, conn, ex); //this.MasterPool.Return(conn, ex); 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"); 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); LoggerException(this.MasterPool, pc, ex, dt, logtxt);
pc.cmd.Parameters.Clear(); pc.Parameters.Clear();
return val; 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; var dt = DateTime.Now;
DbCommand cmd = CreateCommand(); DbCommand cmd = CreateCommand();
cmd.CommandType = cmdType; cmd.CommandType = cmdType;
@ -296,14 +316,15 @@ namespace FreeSql.Internal.CommonProvider {
cmd.Connection = tran.Connection; cmd.Connection = tran.Connection;
cmd.Transaction = tran; cmd.Transaction = tran;
if (IsTracePerformance) logtxt.Append(" PrepareCommand_tran!=null: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n"); 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; if (IsTracePerformance) dt = DateTime.Now;
AutoCommitTransaction(); AutoCommitTransaction();
if (IsTracePerformance) logtxt.Append(" AutoCommitTransaction: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n"); if (IsTracePerformance) logtxt.Append(" AutoCommitTransaction: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n");
AopCommandExecuting?.Invoke(cmd); AopCommandExecuting?.Invoke(cmd);
return (tran, cmd); return cmd;
} }
} }
} }

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

@ -9,16 +9,19 @@ using System.Threading.Tasks;
namespace FreeSql.Internal.CommonProvider { namespace FreeSql.Internal.CommonProvider {
partial class AdoProvider { partial class AdoProvider {
public Task<List<T>> QueryAsync<T>(string cmdText, object parms = null) => QueryAsync<T>(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task<List<T>> QueryAsync<T>(string cmdText, object parms = null) => QueryAsync<T>(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<List<T>> QueryAsync<T>(DbTransaction transaction, string cmdText, object parms = null) => QueryAsync<T>(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task<List<T>> QueryAsync<T>(DbTransaction transaction, string cmdText, object parms = null) => QueryAsync<T>(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<List<T>> QueryAsync<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T>(null, cmdType, cmdText, cmdParms); public Task<List<T>> QueryAsync<T>(DbConnection connection, string cmdText, object parms = null) => QueryAsync<T>(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
async public Task<List<T>> QueryAsync<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { public Task<List<T>> QueryAsync<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T>(null, null, cmdType, cmdText, cmdParms);
public Task<List<T>> QueryAsync<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T>(transaction, null, cmdType, cmdText, cmdParms);
public Task<List<T>> QueryAsync<T>(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T>(null, connection, cmdType, cmdText, cmdParms);
async Task<List<T>> QueryAsync<T>(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var ret = new List<T>(); var ret = new List<T>();
if (string.IsNullOrEmpty(cmdText)) return ret; if (string.IsNullOrEmpty(cmdText)) return ret;
var type = typeof(T); var type = typeof(T);
int[] indexes = null; int[] indexes = null;
var props = dicQueryTypeGetProperties.GetOrAdd(type, k => type.GetProperties()); var props = dicQueryTypeGetProperties.GetOrAdd(type, k => type.GetProperties());
await ExecuteReaderAsync(transaction, dr => { await ExecuteReaderAsync(transaction, connection, dr => {
if (indexes == null) { if (indexes == null) {
var dic = new Dictionary<string, int>(StringComparer.CurrentCultureIgnoreCase); var dic = new Dictionary<string, int>(StringComparer.CurrentCultureIgnoreCase);
for (var a = 0; a < dr.FieldCount; a++) for (var a = 0; a < dr.FieldCount; a++)
@ -30,10 +33,13 @@ namespace FreeSql.Internal.CommonProvider {
}, cmdType, cmdText, cmdParms); }, cmdType, cmdText, cmdParms);
return ret; return ret;
} }
public Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(null, null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(transaction, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(transaction, null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(null, readerHander, cmdType, cmdText, cmdParms); public Task ExecuteReaderAsync(DbConnection connection, Func<DbDataReader, Task> readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(null, connection, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
async public Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { public Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(null, null, readerHander, cmdType, cmdText, cmdParms);
public Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(transaction, null, readerHander, cmdType, cmdText, cmdParms);
public Task ExecuteReaderAsync(DbConnection connection, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(null, connection, readerHander, cmdType, cmdText, cmdParms);
async Task ExecuteReaderAsync(DbTransaction transaction, DbConnection connection, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
if (string.IsNullOrEmpty(cmdText)) return; if (string.IsNullOrEmpty(cmdText)) return;
var dt = DateTime.Now; var dt = DateTime.Now;
var logtxt = new StringBuilder(); var logtxt = new StringBuilder();
@ -41,23 +47,25 @@ namespace FreeSql.Internal.CommonProvider {
var pool = this.MasterPool; var pool = this.MasterPool;
var isSlave = false; var isSlave = false;
//读写分离规则 if (transaction == null && connection == null) {
if (this.SlavePools.Any() && cmdText.StartsWith("SELECT ", StringComparison.CurrentCultureIgnoreCase)) { //读写分离规则
var availables = slaveUnavailables == 0 ? if (this.SlavePools.Any() && cmdText.StartsWith("SELECT ", StringComparison.CurrentCultureIgnoreCase)) {
//查从库 var availables = slaveUnavailables == 0 ?
this.SlavePools : ( //查从库
//查主库 this.SlavePools : (
slaveUnavailables == this.SlavePools.Count ? new List<ObjectPool<DbConnection>>() : //查主库
//查从库可用 slaveUnavailables == this.SlavePools.Count ? new List<ObjectPool<DbConnection>>() :
this.SlavePools.Where(sp => sp.IsAvailable).ToList()); //查从库可用
if (availables.Any()) { this.SlavePools.Where(sp => sp.IsAvailable).ToList());
isSlave = true; if (availables.Any()) {
pool = availables.Count == 1 ? this.SlavePools[0] : availables[slaveRandom.Next(availables.Count)]; isSlave = true;
pool = availables.Count == 1 ? this.SlavePools[0] : availables[slaveRandom.Next(availables.Count)];
}
} }
} }
Object<DbConnection> conn = null; Object<DbConnection> 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"); 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; Exception ex = null;
try { try {
@ -127,24 +135,30 @@ namespace FreeSql.Internal.CommonProvider {
LoggerException(pool, cmd, ex, dt, logtxt); LoggerException(pool, cmd, ex, dt, logtxt);
cmd.Parameters.Clear(); cmd.Parameters.Clear();
} }
public Task<object[][]> ExecuteArrayAsync(string cmdText, object parms = null) => ExecuteArrayAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task<object[][]> ExecuteArrayAsync(string cmdText, object parms = null) => ExecuteArrayAsync(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteArrayAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteArrayAsync(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<object[][]> ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArrayAsync(null, cmdType, cmdText, cmdParms); public Task<object[][]> ExecuteArrayAsync(DbConnection connection, string cmdText, object parms = null) => ExecuteArrayAsync(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
async public Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { public Task<object[][]> ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArrayAsync(null, null, cmdType, cmdText, cmdParms);
public Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArrayAsync(transaction, null, cmdType, cmdText, cmdParms);
public Task<object[][]> ExecuteArrayAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArrayAsync(null, connection, cmdType, cmdText, cmdParms);
async Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
List<object[]> ret = new List<object[]>(); List<object[]> ret = new List<object[]>();
await ExecuteReaderAsync(transaction, async dr => { await ExecuteReaderAsync(transaction, connection, async dr => {
object[] values = new object[dr.FieldCount]; object[] values = new object[dr.FieldCount];
for (int a = 0; a < values.Length; a++) if (!await dr.IsDBNullAsync(a)) values[a] = await dr.GetFieldValueAsync<object>(a); for (int a = 0; a < values.Length; a++) if (!await dr.IsDBNullAsync(a)) values[a] = await dr.GetFieldValueAsync<object>(a);
ret.Add(values); ret.Add(values);
}, cmdType, cmdText, cmdParms); }, cmdType, cmdText, cmdParms);
return ret.ToArray(); return ret.ToArray();
} }
public Task<DataTable> ExecuteDataTableAsync(string cmdText, object parms = null) => ExecuteDataTableAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task<DataTable> ExecuteDataTableAsync(string cmdText, object parms = null) => ExecuteDataTableAsync(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTableAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTableAsync(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<DataTable> ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTableAsync(null, cmdType, cmdText, cmdParms); public Task<DataTable> ExecuteDataTableAsync(DbConnection connection, string cmdText, object parms = null) => ExecuteDataTableAsync(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
async public Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { public Task<DataTable> ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTableAsync(null, null, cmdType, cmdText, cmdParms);
public Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTableAsync(transaction, null, cmdType, cmdText, cmdParms);
public Task<DataTable> ExecuteDataTableAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTableAsync(null, connection, cmdType, cmdText, cmdParms);
async Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var ret = new DataTable(); var ret = new DataTable();
await ExecuteReaderAsync(transaction, async dr => { await ExecuteReaderAsync(transaction, connection, async dr => {
if (ret.Columns.Count == 0) if (ret.Columns.Count == 0)
for (var a = 0; a < dr.FieldCount; a++) ret.Columns.Add(dr.GetName(a)); for (var a = 0; a < dr.FieldCount; a++) ret.Columns.Add(dr.GetName(a));
object[] values = new object[ret.Columns.Count]; object[] values = new object[ret.Columns.Count];
@ -153,16 +167,19 @@ namespace FreeSql.Internal.CommonProvider {
}, cmdType, cmdText, cmdParms); }, cmdType, cmdText, cmdParms);
return ret; return ret;
} }
public Task<int> ExecuteNonQueryAsync(string cmdText, object parms = null) => ExecuteNonQueryAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task<int> ExecuteNonQueryAsync(string cmdText, object parms = null) => ExecuteNonQueryAsync(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<int> ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQueryAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task<int> ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQueryAsync(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<int> ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(null, cmdType, cmdText, cmdParms); public Task<int> ExecuteNonQueryAsync(DbConnection connection, string cmdText, object parms = null) => ExecuteNonQueryAsync(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
async public Task<int> ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { public Task<int> ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(null, null, cmdType, cmdText, cmdParms);
public Task<int> ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(transaction, null, cmdType, cmdText, cmdParms);
public Task<int> ExecuteNonQueryAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(null, connection, cmdType, cmdText, cmdParms);
async Task<int> ExecuteNonQueryAsync(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
if (string.IsNullOrEmpty(cmdText)) return 0; if (string.IsNullOrEmpty(cmdText)) return 0;
var dt = DateTime.Now; var dt = DateTime.Now;
var logtxt = new StringBuilder(); var logtxt = new StringBuilder();
var logtxt_dt = DateTime.Now; var logtxt_dt = DateTime.Now;
Object<DbConnection> conn = null; Object<DbConnection> conn = null;
var cmd = PrepareCommandAsync(transaction, cmdType, cmdText, cmdParms, logtxt); var cmd = PrepareCommandAsync(transaction, connection, cmdType, cmdText, cmdParms, logtxt);
int val = 0; int val = 0;
Exception ex = null; Exception ex = null;
try { try {
@ -181,16 +198,19 @@ namespace FreeSql.Internal.CommonProvider {
cmd.Parameters.Clear(); cmd.Parameters.Clear();
return val; return val;
} }
public Task<object> ExecuteScalarAsync(string cmdText, object parms = null) => ExecuteScalarAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task<object> ExecuteScalarAsync(string cmdText, object parms = null) => ExecuteScalarAsync(null, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<object> ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalarAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task<object> ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalarAsync(transaction, null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<object> ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(null, cmdType, cmdText, cmdParms); public Task<object> ExecuteScalarAsync(DbConnection connection, string cmdText, object parms = null) => ExecuteScalarAsync(null, connection, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
async public Task<object> ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { public Task<object> ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(null, null, cmdType, cmdText, cmdParms);
public Task<object> ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(transaction, null, cmdType, cmdText, cmdParms);
public Task<object> ExecuteScalarAsync(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(null, connection, cmdType, cmdText, cmdParms);
async Task<object> ExecuteScalarAsync(DbTransaction transaction, DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
if (string.IsNullOrEmpty(cmdText)) return null; if (string.IsNullOrEmpty(cmdText)) return null;
var dt = DateTime.Now; var dt = DateTime.Now;
var logtxt = new StringBuilder(); var logtxt = new StringBuilder();
var logtxt_dt = DateTime.Now; var logtxt_dt = DateTime.Now;
Object<DbConnection> conn = null; Object<DbConnection> conn = null;
var cmd = PrepareCommandAsync(transaction, cmdType, cmdText, cmdParms, logtxt); var cmd = PrepareCommandAsync(transaction, connection, cmdType, cmdText, cmdParms, logtxt);
object val = null; object val = null;
Exception ex = null; Exception ex = null;
try { try {
@ -210,7 +230,7 @@ namespace FreeSql.Internal.CommonProvider {
return val; 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; DateTime dt = DateTime.Now;
DbCommand cmd = CreateCommand(); DbCommand cmd = CreateCommand();
cmd.CommandType = cmdType; cmd.CommandType = cmdType;
@ -231,7 +251,8 @@ namespace FreeSql.Internal.CommonProvider {
cmd.Connection = tran.Connection; cmd.Connection = tran.Connection;
cmd.Transaction = tran; cmd.Transaction = tran;
if (IsTracePerformance) logtxt.Append(" PrepareCommandAsync_tran!=null: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n"); if (IsTracePerformance) logtxt.Append(" PrepareCommandAsync_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"); if (IsTracePerformance) logtxt.Append(" PrepareCommandAsync ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms cmdParms: ").Append(cmd.Parameters.Count).Append("\r\n");

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

@ -20,6 +20,7 @@ namespace FreeSql.Internal.CommonProvider {
protected int _whereTimes = 0; protected int _whereTimes = 0;
protected List<DbParameter> _params = new List<DbParameter>(); protected List<DbParameter> _params = new List<DbParameter>();
protected DbTransaction _transaction; protected DbTransaction _transaction;
protected DbConnection _connection;
public DeleteProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) { public DeleteProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) {
_orm = orm; _orm = orm;
@ -42,6 +43,10 @@ namespace FreeSql.Internal.CommonProvider {
_transaction = transaction; _transaction = transaction;
return this; return this;
} }
public IDelete<T1> WithConnection(DbConnection coinnection) {
_connection = coinnection;
return this;
}
public int ExecuteAffrows() { public int ExecuteAffrows() {
var sql = this.ToSql(); var sql = this.ToSql();

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

@ -22,6 +22,7 @@ namespace FreeSql.Internal.CommonProvider {
protected bool _noneParameter; protected bool _noneParameter;
protected DbParameter[] _params; protected DbParameter[] _params;
protected DbTransaction _transaction; protected DbTransaction _transaction;
protected DbConnection _connection;
public InsertProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression) { public InsertProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression) {
_orm = orm; _orm = orm;
@ -42,6 +43,11 @@ namespace FreeSql.Internal.CommonProvider {
_transaction = transaction; _transaction = transaction;
return this; return this;
} }
public IInsert<T1> WithConnection(DbConnection coinnection) {
_connection = coinnection;
return this;
}
public IInsert<T1> NoneParameter() { public IInsert<T1> NoneParameter() {
_noneParameter = true; _noneParameter = true;
return this; return this;

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

@ -28,6 +28,7 @@ namespace FreeSql.Internal.CommonProvider {
protected CommonUtils _commonUtils; protected CommonUtils _commonUtils;
protected CommonExpression _commonExpression; protected CommonExpression _commonExpression;
protected DbTransaction _transaction; protected DbTransaction _transaction;
protected DbConnection _connection;
protected Action<object> _trackToList; protected Action<object> _trackToList;
internal static void CopyData(Select0Provider<TSelect, T1> from, object to, ReadOnlyCollection<ParameterExpression> lambParms) { internal static void CopyData(Select0Provider<TSelect, T1> from, object to, ReadOnlyCollection<ParameterExpression> lambParms) {
@ -61,6 +62,7 @@ namespace FreeSql.Internal.CommonProvider {
//toType.GetField("_commonUtils", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._commonUtils); //toType.GetField("_commonUtils", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._commonUtils);
//toType.GetField("_commonExpression", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._commonExpression); //toType.GetField("_commonExpression", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._commonExpression);
toType.GetField("_transaction", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._transaction); 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); toType.GetField("_trackToList", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._trackToList);
} }
@ -82,6 +84,10 @@ namespace FreeSql.Internal.CommonProvider {
_transaction = transaction; _transaction = transaction;
return this as TSelect; return this as TSelect;
} }
public TSelect WithConnection(DbConnection coinnection) {
_connection = coinnection;
return this as TSelect;
}
public bool Any() { public bool Any() {
this.Limit(1); this.Limit(1);
@ -201,14 +207,14 @@ namespace FreeSql.Internal.CommonProvider {
if (_cache.seconds > 0 && string.IsNullOrEmpty(_cache.key)) _cache.key = sql; if (_cache.seconds > 0 && string.IsNullOrEmpty(_cache.key)) _cache.key = sql;
return _orm.Cache.Shell(_cache.key, _cache.seconds, () => 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<DataTable> ToDataTableAsync(string field = null) { public Task<DataTable> ToDataTableAsync(string field = null) {
var sql = this.ToSql(field); var sql = this.ToSql(field);
if (_cache.seconds > 0 && string.IsNullOrEmpty(_cache.key)) _cache.key = sql; if (_cache.seconds > 0 && string.IsNullOrEmpty(_cache.key)) _cache.key = sql;
return _orm.Cache.ShellAsync(_cache.key, _cache.seconds, () => 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<TTuple> ToList<TTuple>(string field) { public List<TTuple> ToList<TTuple>(string field) {
@ -218,7 +224,7 @@ namespace FreeSql.Internal.CommonProvider {
return _orm.Cache.Shell(_cache.key, _cache.seconds, () => { return _orm.Cache.Shell(_cache.key, _cache.seconds, () => {
List<TTuple> ret = new List<TTuple>(); List<TTuple> ret = new List<TTuple>();
Type type = typeof(TTuple); 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); var read = Utils.ExecuteArrayRowReadClassOrTuple(type, null, dr, 0, _commonUtils);
ret.Add((TTuple)read.Value); ret.Add((TTuple)read.Value);
}, CommandType.Text, sql, _params.ToArray()); }, CommandType.Text, sql, _params.ToArray());

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

@ -26,6 +26,7 @@ namespace FreeSql.Internal.CommonProvider {
protected List<DbParameter> _paramsSource = new List<DbParameter>(); protected List<DbParameter> _paramsSource = new List<DbParameter>();
protected bool _noneParameter; protected bool _noneParameter;
protected DbTransaction _transaction; protected DbTransaction _transaction;
protected DbConnection _connection;
public UpdateProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) { public UpdateProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) {
_orm = orm; _orm = orm;
@ -51,6 +52,11 @@ namespace FreeSql.Internal.CommonProvider {
_transaction = transaction; _transaction = transaction;
return this; return this;
} }
public IUpdate<T1> WithConnection(DbConnection coinnection) {
_connection = coinnection;
return this;
}
public IUpdate<T1> NoneParameter() { public IUpdate<T1> NoneParameter() {
_noneParameter = true; _noneParameter = true;
return this; return this;

12
FreeSql/MySql/MySqlAdo/MySqlAdo.cs
View File

@ -14,11 +14,13 @@ namespace FreeSql.MySql {
public MySqlAdo() : base(null, null, DataType.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) { public MySqlAdo(CommonUtils util, ICache cache, ILogger log, string masterConnectionString, string[] slaveConnectionStrings) : base(cache, log, DataType.MySql) {
base._util = util; base._util = util;
MasterPool = new MySqlConnectionPool("主库", masterConnectionString, null, null); if (!string.IsNullOrEmpty(masterConnectionString)) {
if (slaveConnectionStrings != null) { MasterPool = new MySqlConnectionPool("主库", masterConnectionString, null, null);
foreach (var slaveConnectionString in slaveConnectionStrings) { if (slaveConnectionStrings != null) {
var slavePool = new MySqlConnectionPool($"从库{SlavePools.Count + 1}", slaveConnectionString, () => Interlocked.Decrement(ref slaveUnavailables), () => Interlocked.Increment(ref slaveUnavailables)); foreach (var slaveConnectionString in slaveConnectionStrings) {
SlavePools.Add(slavePool); var slavePool = new MySqlConnectionPool($"从库{SlavePools.Count + 1}", slaveConnectionString, () => Interlocked.Decrement(ref slaveUnavailables), () => Interlocked.Increment(ref slaveUnavailables));
SlavePools.Add(slavePool);
}
} }
} }
} }

30
FreeSql/MySql/MySqlConnectionExtensions.cs Normal file
View File

@ -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<int> _curd = new MySqlProvider<int>(null, new LoggerFactory().CreateLogger("MySqlConnectionExtensions"), null, null);
public static ISelect<T1> Select<T1>(this MySqlConnection that) where T1 : class => _curd.Select<T1>().WithConnection(that);
public static ISelect<T1> Select<T1>(this MySqlConnection that, object dywhere) where T1 : class => _curd.Select<T1>(dywhere).WithConnection(that);
public static IInsert<T1> Insert<T1>(this MySqlConnection that) where T1 : class => _curd.Insert<T1>().WithConnection(that);
public static IInsert<T1> Insert<T1>(this MySqlConnection that, T1 source) where T1 : class => _curd.Insert<T1>().WithConnection(that).AppendData(source);
public static IInsert<T1> Insert<T1>(this MySqlConnection that, T1[] source) where T1 : class => _curd.Insert<T1>().WithConnection(that).AppendData(source);
public static IInsert<T1> Insert<T1>(this MySqlConnection that, IEnumerable<T1> source) where T1 : class => _curd.Insert<T1>().WithConnection(that).AppendData(source);
public static IUpdate<T1> Update<T1>(this MySqlConnection that) where T1 : class => _curd.Update<T1>().WithConnection(that);
public static IUpdate<T1> Update<T1>(this MySqlConnection that, object dywhere) where T1 : class => _curd.Update<T1>(dywhere).WithConnection(that);
public static IDelete<T1> Delete<T1>(this MySqlConnection that) where T1 : class => _curd.Delete<T1>().WithConnection(that);
public static IDelete<T1> Delete<T1>(this MySqlConnection that, object dywhere) where T1 : class => _curd.Delete<T1>(dywhere).WithConnection(that);
public static List<T> Query<T>(this MySqlConnection that, string cmdText, object parms = null) => _curd.Ado.Query<T>(that, cmdText, parms);
public static List<T> Query<T>(this MySqlConnection that, CommandType cmdType, string cmdText, params MySqlParameter[] cmdParms) => _curd.Ado.Query<T>(that, cmdText, cmdParms);
}
}