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

补充 IAdo 相关方法

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

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

@ -1,84 +0,0 @@
using FreeSql.DataAnnotations;
using MySql.Data.MySqlClient;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Xunit;
namespace FreeSql.Tests.MySql {
public class MySqlConnectionExtensions {
string _connectString = "Data Source=127.0.0.1;Port=3306;User ID=root;Password=root;Initial Catalog=cccddd;Charset=utf8;SslMode=none;Max pool size=10";
[Fact]
public void Insert() {
var affrows = 0;
using (var conn = new MySqlConnection(_connectString)) {
var item = new TestConnectionExt { title = "testinsert" };
affrows = conn.Insert<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;
}
}
}

2
FreeSql/FreeSql.csproj
View File

@ -2,7 +2,7 @@
<PropertyGroup> <PropertyGroup>
<TargetFramework>netstandard2.0</TargetFramework> <TargetFramework>netstandard2.0</TargetFramework>
<Version>0.4.9</Version> <Version>0.4.10</Version>
<GeneratePackageOnBuild>true</GeneratePackageOnBuild> <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
<Authors>YeXiangQin</Authors> <Authors>YeXiangQin</Authors>
<Description>FreeSql is the most convenient ORM in dotnet. It supports Mysql, Postgresql, SqlServer, Oracle and Sqlite.</Description> <Description>FreeSql is the most convenient ORM in dotnet. It supports Mysql, Postgresql, SqlServer, Oracle and Sqlite.</Description>

48
FreeSql/Interface/IAdo.cs
View File

@ -62,7 +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); void ExecuteReader(DbConnection connection, DbTransaction transaction, 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>
@ -70,7 +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); void ExecuteReader(DbConnection connection, DbTransaction transaction, Action<DbDataReader> readerHander, string cmdText, object parms = null);
/// <summary> /// <summary>
/// 查询 /// 查询
/// </summary> /// </summary>
@ -78,7 +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); object[][] ExecuteArray(DbConnection connection, DbTransaction transaction, 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>
@ -87,7 +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); object[][] ExecuteArray(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary> /// <summary>
/// 查询 /// 查询
/// </summary> /// </summary>
@ -95,7 +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); DataTable ExecuteDataTable(DbConnection connection, DbTransaction transaction, 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>
@ -104,7 +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); DataTable ExecuteDataTable(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary> /// <summary>
/// 在【主库】执行 /// 在【主库】执行
/// </summary> /// </summary>
@ -113,7 +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); int ExecuteNonQuery(DbConnection connection, DbTransaction transaction, 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>
@ -122,7 +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); int ExecuteNonQuery(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary> /// <summary>
/// 在【主库】执行 /// 在【主库】执行
/// </summary> /// </summary>
@ -131,7 +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); object ExecuteScalar(DbConnection connection, DbTransaction transaction, 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>
@ -140,7 +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); object ExecuteScalar(DbConnection connection, DbTransaction transaction, 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 })
@ -152,7 +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); List<T> Query<T>(DbConnection connection, DbTransaction transaction, 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>
@ -162,7 +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); List<T> Query<T>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
#region async #region async
/// <summary> /// <summary>
@ -174,7 +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); Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, 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>
@ -182,7 +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); Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func<DbDataReader, Task> readerHander, string cmdText, object parms = null);
/// <summary> /// <summary>
/// 查询 /// 查询
/// </summary> /// </summary>
@ -190,7 +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); Task<object[][]> ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, 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>
@ -199,7 +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); Task<object[][]> ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary> /// <summary>
/// 查询 /// 查询
/// </summary> /// </summary>
@ -207,7 +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); Task<DataTable> ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, 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>
@ -216,7 +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); Task<DataTable> ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary> /// <summary>
/// 在【主库】执行 /// 在【主库】执行
/// </summary> /// </summary>
@ -225,7 +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); Task<int> ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, 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>
@ -234,7 +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); Task<int> ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary> /// <summary>
/// 在【主库】执行 /// 在【主库】执行
/// </summary> /// </summary>
@ -243,7 +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); Task<object> ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, 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>
@ -252,7 +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); Task<object> ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, 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 })
@ -264,7 +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); Task<List<T>> QueryAsync<T>(DbConnection connection, DbTransaction transaction, 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>
@ -274,7 +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); Task<List<T>> QueryAsync<T>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
#endregion #endregion
} }
} }

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

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

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

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

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

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

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

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

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

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

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

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

4
FreeSql/MySql/Curd/MySqlDelete.cs
View File

@ -24,7 +24,7 @@ namespace FreeSql.MySql.Curd {
sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
++colidx; ++colidx;
} }
var ret = _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params.ToArray()); var ret = _orm.Ado.Query<T1>(_connection, _transaction, CommandType.Text, sb.ToString(), _params.ToArray());
this.ClearData(); this.ClearData();
return ret; return ret;
} }
@ -41,7 +41,7 @@ namespace FreeSql.MySql.Curd {
sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
++colidx; ++colidx;
} }
var ret = await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params.ToArray()); var ret = await _orm.Ado.QueryAsync<T1>(_connection, _transaction, CommandType.Text, sb.ToString(), _params.ToArray());
this.ClearData(); this.ClearData();
return ret; return ret;
} }

8
FreeSql/MySql/Curd/MySqlInsert.cs
View File

@ -23,13 +23,13 @@ namespace FreeSql.MySql.Curd {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_transaction, CommandType.Text, string.Concat(sql, "; SELECT LAST_INSERT_ID();"), _params)), out var trylng) ? trylng : 0; return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_connection, _transaction, CommandType.Text, string.Concat(sql, "; SELECT LAST_INSERT_ID();"), _params)), out var trylng) ? trylng : 0;
} }
async internal override Task<long> RawExecuteIdentityAsync() { async internal override Task<long> RawExecuteIdentityAsync() {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_transaction, CommandType.Text, string.Concat(sql, "; SELECT LAST_INSERT_ID();"), _params)), out var trylng) ? trylng : 0; return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, string.Concat(sql, "; SELECT LAST_INSERT_ID();"), _params)), out var trylng) ? trylng : 0;
} }
internal override List<T1> RawExecuteInserted() { internal override List<T1> RawExecuteInserted() {
var sql = this.ToSql(); var sql = this.ToSql();
@ -44,7 +44,7 @@ namespace FreeSql.MySql.Curd {
sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
++colidx; ++colidx;
} }
return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params); return _orm.Ado.Query<T1>(_connection, _transaction, CommandType.Text, sb.ToString(), _params);
} }
async internal override Task<List<T1>> RawExecuteInsertedAsync() { async internal override Task<List<T1>> RawExecuteInsertedAsync() {
var sql = this.ToSql(); var sql = this.ToSql();
@ -59,7 +59,7 @@ namespace FreeSql.MySql.Curd {
sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
++colidx; ++colidx;
} }
return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params); return await _orm.Ado.QueryAsync<T1>(_connection, _transaction, CommandType.Text, sb.ToString(), _params);
} }
} }
} }

4
FreeSql/MySql/Curd/MySqlUpdate.cs
View File

@ -33,7 +33,7 @@ namespace FreeSql.MySql.Curd {
sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
++colidx; ++colidx;
} }
var ret = _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); var ret = _orm.Ado.Query<T1>(_connection, _transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
ValidateVersionAndThrow(ret.Count); ValidateVersionAndThrow(ret.Count);
return ret; return ret;
} }
@ -50,7 +50,7 @@ namespace FreeSql.MySql.Curd {
sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
++colidx; ++colidx;
} }
var ret = await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); var ret = await _orm.Ado.QueryAsync<T1>(_connection, _transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
ValidateVersionAndThrow(ret.Count); ValidateVersionAndThrow(ret.Count);
return ret; return ret;
} }

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

@ -14,13 +14,12 @@ 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;
if (!string.IsNullOrEmpty(masterConnectionString)) { if (!string.IsNullOrEmpty(masterConnectionString))
MasterPool = new MySqlConnectionPool("主库", masterConnectionString, null, null); MasterPool = new MySqlConnectionPool("主库", masterConnectionString, null, null);
if (slaveConnectionStrings != null) { if (slaveConnectionStrings != null) {
foreach (var slaveConnectionString in slaveConnectionStrings) { foreach (var slaveConnectionString in slaveConnectionStrings) {
var slavePool = new MySqlConnectionPool($"从库{SlavePools.Count + 1}", slaveConnectionString, () => Interlocked.Decrement(ref slaveUnavailables), () => Interlocked.Increment(ref slaveUnavailables)); var slavePool = new MySqlConnectionPool($"从库{SlavePools.Count + 1}", slaveConnectionString, () => Interlocked.Decrement(ref slaveUnavailables), () => Interlocked.Increment(ref slaveUnavailables));
SlavePools.Add(slavePool); SlavePools.Add(slavePool);
}
} }
} }
} }

30
FreeSql/MySql/MySqlConnectionExtensions.cs
View File

@ -1,30 +0,0 @@
using FreeSql.MySql;
using FreeSql.MySql.Curd;
using Microsoft.Extensions.Logging;
using MySql.Data.MySqlClient;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Text;
namespace FreeSql {
public static class MySqlConnectionExtensions {
static IFreeSql<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);
}
}

12
FreeSql/MySql/MySqlProvider.cs
View File

@ -13,12 +13,12 @@ namespace FreeSql.MySql {
class MySqlProvider<TMark> : IFreeSql<TMark> { class MySqlProvider<TMark> : IFreeSql<TMark> {
static MySqlProvider() { static MySqlProvider() {
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(MygisPoint), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(MygisPoint)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(MygisLineString), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(MygisLineString)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(MygisPolygon), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(MygisPolygon)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(MygisMultiPoint), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(MygisMultiPoint)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(MygisMultiLineString), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(MygisMultiLineString)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(MygisMultiPolygon), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(MygisMultiPolygon)] = true;
} }
public ISelect<T1> Select<T1>() where T1 : class => new MySqlSelect<T1>(this, this.InternalCommonUtils, this.InternalCommonExpression, null); public ISelect<T1> Select<T1>() where T1 : class => new MySqlSelect<T1>(this, this.InternalCommonUtils, this.InternalCommonExpression, null);

8
FreeSql/Oracle/Curd/OracleInsert.cs
View File

@ -88,13 +88,13 @@ namespace FreeSql.Oracle.Curd {
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
if (_identCol == null || _source.Count > 1) { if (_identCol == null || _source.Count > 1) {
_orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, sql, _params); _orm.Ado.ExecuteNonQuery(_connection, _transaction, CommandType.Text, sql, _params);
return 0; return 0;
} }
var identColName = _commonUtils.QuoteSqlName(_identCol.Attribute.Name); var identColName = _commonUtils.QuoteSqlName(_identCol.Attribute.Name);
var identParam = _commonUtils.AppendParamter(null, $"{_identCol.CsName}99", _identCol.CsType, 0) as OracleParameter; var identParam = _commonUtils.AppendParamter(null, $"{_identCol.CsName}99", _identCol.CsType, 0) as OracleParameter;
identParam.Direction = ParameterDirection.Output; identParam.Direction = ParameterDirection.Output;
_orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, $"{sql} RETURNING {identColName} INTO {identParam.ParameterName}", _params.Concat(new[] { identParam }).ToArray()); _orm.Ado.ExecuteNonQuery(_connection, _transaction, CommandType.Text, $"{sql} RETURNING {identColName} INTO {identParam.ParameterName}", _params.Concat(new[] { identParam }).ToArray());
return long.TryParse(string.Concat(identParam.Value), out var trylng) ? trylng : 0; return long.TryParse(string.Concat(identParam.Value), out var trylng) ? trylng : 0;
} }
async internal override Task<long> RawExecuteIdentityAsync() { async internal override Task<long> RawExecuteIdentityAsync() {
@ -102,13 +102,13 @@ namespace FreeSql.Oracle.Curd {
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
if (_identCol == null || _source.Count > 1) { if (_identCol == null || _source.Count > 1) {
await _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, sql, _params); await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _params);
return 0; return 0;
} }
var identColName = _commonUtils.QuoteSqlName(_identCol.Attribute.Name); var identColName = _commonUtils.QuoteSqlName(_identCol.Attribute.Name);
var identParam = _commonUtils.AppendParamter(null, $"{_identCol.CsName}99", _identCol.CsType, 0) as OracleParameter; var identParam = _commonUtils.AppendParamter(null, $"{_identCol.CsName}99", _identCol.CsType, 0) as OracleParameter;
identParam.Direction = ParameterDirection.Output; identParam.Direction = ParameterDirection.Output;
await _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, $"{sql} RETURNING {identColName} INTO {identParam.ParameterName}", _params.Concat(new[] { identParam }).ToArray()); await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, $"{sql} RETURNING {identColName} INTO {identParam.ParameterName}", _params.Concat(new[] { identParam }).ToArray());
return long.TryParse(string.Concat(identParam.Value), out var trylng) ? trylng : 0; return long.TryParse(string.Concat(identParam.Value), out var trylng) ? trylng : 0;
} }

3
FreeSql/Oracle/OracleAdo/OracleAdo.cs
View File

@ -13,7 +13,8 @@ namespace FreeSql.Oracle {
public OracleAdo() : base(null, null, DataType.Oracle) { } public OracleAdo() : base(null, null, DataType.Oracle) { }
public OracleAdo(CommonUtils util, ICache cache, ILogger log, string masterConnectionString, string[] slaveConnectionStrings) : base(cache, log, DataType.Oracle) { public OracleAdo(CommonUtils util, ICache cache, ILogger log, string masterConnectionString, string[] slaveConnectionStrings) : base(cache, log, DataType.Oracle) {
base._util = util; base._util = util;
MasterPool = new OracleConnectionPool("主库", masterConnectionString, null, null); if (!string.IsNullOrEmpty(masterConnectionString))
MasterPool = new OracleConnectionPool("主库", masterConnectionString, null, null);
if (slaveConnectionStrings != null) { if (slaveConnectionStrings != null) {
foreach (var slaveConnectionString in slaveConnectionStrings) { foreach (var slaveConnectionString in slaveConnectionStrings) {
var slavePool = new OracleConnectionPool($"从库{SlavePools.Count + 1}", slaveConnectionString, () => Interlocked.Decrement(ref slaveUnavailables), () => Interlocked.Increment(ref slaveUnavailables)); var slavePool = new OracleConnectionPool($"从库{SlavePools.Count + 1}", slaveConnectionString, () => Interlocked.Decrement(ref slaveUnavailables), () => Interlocked.Increment(ref slaveUnavailables));

4
FreeSql/PostgreSQL/Curd/PostgreSQLDelete.cs
View File

@ -24,7 +24,7 @@ namespace FreeSql.PostgreSQL.Curd {
sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
++colidx; ++colidx;
} }
var ret = _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params.ToArray()); var ret = _orm.Ado.Query<T1>(_connection, _transaction, CommandType.Text, sb.ToString(), _params.ToArray());
this.ClearData(); this.ClearData();
return ret; return ret;
} }
@ -41,7 +41,7 @@ namespace FreeSql.PostgreSQL.Curd {
sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
++colidx; ++colidx;
} }
var ret = await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params.ToArray()); var ret = await _orm.Ado.QueryAsync<T1>(_connection, _transaction, CommandType.Text, sb.ToString(), _params.ToArray());
this.ClearData(); this.ClearData();
return ret; return ret;
} }

12
FreeSql/PostgreSQL/Curd/PostgreSQLInsert.cs
View File

@ -26,10 +26,10 @@ namespace FreeSql.PostgreSQL.Curd {
var identCols = _table.Columns.Where(a => a.Value.Attribute.IsIdentity == true); var identCols = _table.Columns.Where(a => a.Value.Attribute.IsIdentity == true);
if (identCols.Any() == false) { if (identCols.Any() == false) {
_orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, sql, _params); _orm.Ado.ExecuteNonQuery(_connection, _transaction, CommandType.Text, sql, _params);
return 0; return 0;
} }
return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_transaction, CommandType.Text, string.Concat(sql, " RETURNING ", _commonUtils.QuoteSqlName(identCols.First().Value.Attribute.Name)), _params)), out var trylng) ? trylng : 0; return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_connection, _transaction, CommandType.Text, string.Concat(sql, " RETURNING ", _commonUtils.QuoteSqlName(identCols.First().Value.Attribute.Name)), _params)), out var trylng) ? trylng : 0;
} }
async internal override Task<long> RawExecuteIdentityAsync() { async internal override Task<long> RawExecuteIdentityAsync() {
var sql = this.ToSql(); var sql = this.ToSql();
@ -37,10 +37,10 @@ namespace FreeSql.PostgreSQL.Curd {
var identCols = _table.Columns.Where(a => a.Value.Attribute.IsIdentity == true); var identCols = _table.Columns.Where(a => a.Value.Attribute.IsIdentity == true);
if (identCols.Any() == false) { if (identCols.Any() == false) {
await _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, sql, _params); await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _params);
return 0; return 0;
} }
return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_transaction, CommandType.Text, string.Concat(sql, " RETURNING ", _commonUtils.QuoteSqlName(identCols.First().Value.Attribute.Name)), _params)), out var trylng) ? trylng : 0; return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, string.Concat(sql, " RETURNING ", _commonUtils.QuoteSqlName(identCols.First().Value.Attribute.Name)), _params)), out var trylng) ? trylng : 0;
} }
internal override List<T1> RawExecuteInserted() { internal override List<T1> RawExecuteInserted() {
@ -56,7 +56,7 @@ namespace FreeSql.PostgreSQL.Curd {
sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
++colidx; ++colidx;
} }
return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params); return _orm.Ado.Query<T1>(_connection, _transaction, CommandType.Text, sb.ToString(), _params);
} }
async internal override Task<List<T1>> RawExecuteInsertedAsync() { async internal override Task<List<T1>> RawExecuteInsertedAsync() {
var sql = this.ToSql(); var sql = this.ToSql();
@ -71,7 +71,7 @@ namespace FreeSql.PostgreSQL.Curd {
sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
++colidx; ++colidx;
} }
return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params); return await _orm.Ado.QueryAsync<T1>(_connection, _transaction, CommandType.Text, sb.ToString(), _params);
} }
} }
} }

4
FreeSql/PostgreSQL/Curd/PostgreSQLUpdate.cs
View File

@ -33,7 +33,7 @@ namespace FreeSql.PostgreSQL.Curd {
sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
++colidx; ++colidx;
} }
var ret = _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); var ret = _orm.Ado.Query<T1>(_connection, _transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
ValidateVersionAndThrow(ret.Count); ValidateVersionAndThrow(ret.Count);
return ret; return ret;
} }
@ -50,7 +50,7 @@ namespace FreeSql.PostgreSQL.Curd {
sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName)); sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
++colidx; ++colidx;
} }
var ret = await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); var ret = await _orm.Ado.QueryAsync<T1>(_connection, _transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
ValidateVersionAndThrow(ret.Count); ValidateVersionAndThrow(ret.Count);
return ret; return ret;
} }

3
FreeSql/PostgreSQL/PostgreSQLAdo/PostgreSQLAdo.cs
View File

@ -15,7 +15,8 @@ namespace FreeSql.PostgreSQL {
public PostgreSQLAdo() : base(null, null, DataType.PostgreSQL) { } public PostgreSQLAdo() : base(null, null, DataType.PostgreSQL) { }
public PostgreSQLAdo(CommonUtils util, ICache cache, ILogger log, string masterConnectionString, string[] slaveConnectionStrings) : base(cache, log, DataType.PostgreSQL) { public PostgreSQLAdo(CommonUtils util, ICache cache, ILogger log, string masterConnectionString, string[] slaveConnectionStrings) : base(cache, log, DataType.PostgreSQL) {
base._util = util; base._util = util;
MasterPool = new PostgreSQLConnectionPool("主库", masterConnectionString, null, null); if (!string.IsNullOrEmpty(masterConnectionString))
MasterPool = new PostgreSQLConnectionPool("主库", masterConnectionString, null, null);
if (slaveConnectionStrings != null) { if (slaveConnectionStrings != null) {
foreach (var slaveConnectionString in slaveConnectionStrings) { foreach (var slaveConnectionString in slaveConnectionStrings) {
var slavePool = new PostgreSQLConnectionPool($"从库{SlavePools.Count + 1}", slaveConnectionString, () => Interlocked.Decrement(ref slaveUnavailables), () => Interlocked.Increment(ref slaveUnavailables)); var slavePool = new PostgreSQLConnectionPool($"从库{SlavePools.Count + 1}", slaveConnectionString, () => Interlocked.Decrement(ref slaveUnavailables), () => Interlocked.Increment(ref slaveUnavailables));

54
FreeSql/PostgreSQL/PostgreSQLProvider.cs
View File

@ -19,33 +19,33 @@ namespace FreeSql.PostgreSQL {
class PostgreSQLProvider<TMark> : IFreeSql<TMark> { class PostgreSQLProvider<TMark> : IFreeSql<TMark> {
static PostgreSQLProvider() { static PostgreSQLProvider() {
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(BitArray), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(BitArray)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlPoint), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlPoint)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlLine), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlLine)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlLSeg), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlLSeg)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlBox), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlBox)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlPath), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlPath)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlPolygon), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlPolygon)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlCircle), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlCircle)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof((IPAddress Address, int Subnet)), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof((IPAddress Address, int Subnet))] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(IPAddress), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(IPAddress)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(PhysicalAddress), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(PhysicalAddress)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlRange<int>), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlRange<int>)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlRange<long>), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlRange<long>)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlRange<decimal>), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlRange<decimal>)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(NpgsqlRange<DateTime>), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(NpgsqlRange<DateTime>)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(PostgisPoint), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(PostgisPoint)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(PostgisLineString), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(PostgisLineString)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(PostgisPolygon), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(PostgisPolygon)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(PostgisMultiPoint), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(PostgisMultiPoint)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(PostgisMultiLineString), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(PostgisMultiLineString)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(PostgisMultiPolygon), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(PostgisMultiPolygon)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(PostgisGeometry), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(PostgisGeometry)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(PostgisGeometryCollection), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(PostgisGeometryCollection)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(Dictionary<string, string>), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(Dictionary<string, string>)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(JToken), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(JToken)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(JObject), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(JObject)] = true;
Utils.dicExecuteArrayRowReadClassOrTuple.Add(typeof(JArray), true); Utils.dicExecuteArrayRowReadClassOrTuple[typeof(JArray)] = true;
} }
public ISelect<T1> Select<T1>() where T1 : class => new PostgreSQLSelect<T1>(this, this.InternalCommonUtils, this.InternalCommonExpression, null); public ISelect<T1> Select<T1>() where T1 : class => new PostgreSQLSelect<T1>(this, this.InternalCommonUtils, this.InternalCommonExpression, null);

4
FreeSql/SqlServer/Curd/SqlServerDelete.cs
View File

@ -30,7 +30,7 @@ namespace FreeSql.SqlServer.Curd {
sb.Insert(0, sql.Substring(0, validx)); sb.Insert(0, sql.Substring(0, validx));
sb.Append(sql.Substring(validx)); sb.Append(sql.Substring(validx));
var ret = _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params.ToArray()); var ret = _orm.Ado.Query<T1>(_connection, _transaction, CommandType.Text, sb.ToString(), _params.ToArray());
this.ClearData(); this.ClearData();
return ret; return ret;
} }
@ -52,7 +52,7 @@ namespace FreeSql.SqlServer.Curd {
sb.Insert(0, sql.Substring(0, validx)); sb.Insert(0, sql.Substring(0, validx));
sb.Append(sql.Substring(validx)); sb.Append(sql.Substring(validx));
var ret = await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params.ToArray()); var ret = await _orm.Ado.QueryAsync<T1>(_connection, _transaction, CommandType.Text, sb.ToString(), _params.ToArray());
this.ClearData(); this.ClearData();
return ret; return ret;
} }

8
FreeSql/SqlServer/Curd/SqlServerInsert.cs
View File

@ -26,13 +26,13 @@ namespace FreeSql.SqlServer.Curd {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_transaction, CommandType.Text, string.Concat(sql, "; SELECT SCOPE_IDENTITY();"), _params)), out var trylng) ? trylng : 0; return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_connection, _transaction, CommandType.Text, string.Concat(sql, "; SELECT SCOPE_IDENTITY();"), _params)), out var trylng) ? trylng : 0;
} }
async internal override Task<long> RawExecuteIdentityAsync() { async internal override Task<long> RawExecuteIdentityAsync() {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_transaction, CommandType.Text, string.Concat(sql, "; SELECT SCOPE_IDENTITY();"), _params)), out var trylng) ? trylng : 0; return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, string.Concat(sql, "; SELECT SCOPE_IDENTITY();"), _params)), out var trylng) ? trylng : 0;
} }
internal override List<T1> RawExecuteInserted() { internal override List<T1> RawExecuteInserted() {
@ -53,7 +53,7 @@ namespace FreeSql.SqlServer.Curd {
sb.Insert(0, sql.Substring(0, validx + 1)); sb.Insert(0, sql.Substring(0, validx + 1));
sb.Append(sql.Substring(validx + 1)); sb.Append(sql.Substring(validx + 1));
return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params); return _orm.Ado.Query<T1>(_connection, _transaction, CommandType.Text, sb.ToString(), _params);
} }
async internal override Task<List<T1>> RawExecuteInsertedAsync() { async internal override Task<List<T1>> RawExecuteInsertedAsync() {
var sql = this.ToSql(); var sql = this.ToSql();
@ -73,7 +73,7 @@ namespace FreeSql.SqlServer.Curd {
sb.Insert(0, sql.Substring(0, validx + 1)); sb.Insert(0, sql.Substring(0, validx + 1));
sb.Append(sql.Substring(validx + 1)); sb.Append(sql.Substring(validx + 1));
return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params); return await _orm.Ado.QueryAsync<T1>(_connection, _transaction, CommandType.Text, sb.ToString(), _params);
} }
} }
} }

4
FreeSql/SqlServer/Curd/SqlServerUpdate.cs
View File

@ -39,7 +39,7 @@ namespace FreeSql.SqlServer.Curd {
sb.Insert(0, sql.Substring(0, validx)); sb.Insert(0, sql.Substring(0, validx));
sb.Append(sql.Substring(validx)); sb.Append(sql.Substring(validx));
var ret = _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); var ret = _orm.Ado.Query<T1>(_connection, _transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
ValidateVersionAndThrow(ret.Count); ValidateVersionAndThrow(ret.Count);
return ret; return ret;
} }
@ -61,7 +61,7 @@ namespace FreeSql.SqlServer.Curd {
sb.Insert(0, sql.Substring(0, validx)); sb.Insert(0, sql.Substring(0, validx));
sb.Append(sql.Substring(validx)); sb.Append(sql.Substring(validx));
var ret = await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); var ret = await _orm.Ado.QueryAsync<T1>(_connection, _transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
ValidateVersionAndThrow(ret.Count); ValidateVersionAndThrow(ret.Count);
return ret; return ret;
} }

3
FreeSql/SqlServer/SqlServerAdo/SqlServerAdo.cs
View File

@ -13,7 +13,8 @@ namespace FreeSql.SqlServer {
public SqlServerAdo() : base(null, null, DataType.SqlServer) { } public SqlServerAdo() : base(null, null, DataType.SqlServer) { }
public SqlServerAdo(CommonUtils util, ICache cache, ILogger log, string masterConnectionString, string[] slaveConnectionStrings) : base(cache, log, DataType.SqlServer) { public SqlServerAdo(CommonUtils util, ICache cache, ILogger log, string masterConnectionString, string[] slaveConnectionStrings) : base(cache, log, DataType.SqlServer) {
base._util = util; base._util = util;
MasterPool = new SqlServerConnectionPool("主库", masterConnectionString, null, null); if (!string.IsNullOrEmpty(masterConnectionString))
MasterPool = new SqlServerConnectionPool("主库", masterConnectionString, null, null);
if (slaveConnectionStrings != null) { if (slaveConnectionStrings != null) {
foreach (var slaveConnectionString in slaveConnectionStrings) { foreach (var slaveConnectionString in slaveConnectionStrings) {
var slavePool = new SqlServerConnectionPool($"从库{SlavePools.Count + 1}", slaveConnectionString, () => Interlocked.Decrement(ref slaveUnavailables), () => Interlocked.Increment(ref slaveUnavailables)); var slavePool = new SqlServerConnectionPool($"从库{SlavePools.Count + 1}", slaveConnectionString, () => Interlocked.Decrement(ref slaveUnavailables), () => Interlocked.Increment(ref slaveUnavailables));

11
FreeSql/SqlServer/SqlServerProvider.cs
View File

@ -40,12 +40,13 @@ namespace FreeSql.SqlServer {
this.DbFirst = new SqlServerDbFirst(this, this.InternalCommonUtils, this.InternalCommonExpression); this.DbFirst = new SqlServerDbFirst(this, this.InternalCommonUtils, this.InternalCommonExpression);
this.CodeFirst = new SqlServerCodeFirst(this, this.InternalCommonUtils, this.InternalCommonExpression); this.CodeFirst = new SqlServerCodeFirst(this, this.InternalCommonUtils, this.InternalCommonExpression);
using (var conn = this.Ado.MasterPool.Get()) { if (this.Ado.MasterPool != null)
try { using (var conn = this.Ado.MasterPool.Get()) {
(this.InternalCommonUtils as SqlServerUtils).IsSelectRowNumber = int.Parse(conn.Value.ServerVersion.Split('.')[0]) <= 10; try {
} catch { (this.InternalCommonUtils as SqlServerUtils).IsSelectRowNumber = int.Parse(conn.Value.ServerVersion.Split('.')[0]) <= 10;
} catch {
}
} }
}
} }
internal CommonUtils InternalCommonUtils { get; } internal CommonUtils InternalCommonUtils { get; }

4
FreeSql/Sqlite/Curd/SqliteInsert.cs
View File

@ -25,13 +25,13 @@ namespace FreeSql.Sqlite.Curd {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_transaction, CommandType.Text, string.Concat(sql, "; SELECT last_insert_rowid();"), _params)), out var trylng) ? trylng : 0; return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_connection, _transaction, CommandType.Text, string.Concat(sql, "; SELECT last_insert_rowid();"), _params)), out var trylng) ? trylng : 0;
} }
async internal override Task<long> RawExecuteIdentityAsync() { async internal override Task<long> RawExecuteIdentityAsync() {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_transaction, CommandType.Text, string.Concat(sql, "; SELECT last_insert_rowid();"), _params)), out var trylng) ? trylng : 0; return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, string.Concat(sql, "; SELECT last_insert_rowid();"), _params)), out var trylng) ? trylng : 0;
} }
internal override List<T1> RawExecuteInserted() { internal override List<T1> RawExecuteInserted() {
var sql = this.ToSql(); var sql = this.ToSql();

3
FreeSql/Sqlite/SqliteAdo/SqliteAdo.cs
View File

@ -13,7 +13,8 @@ namespace FreeSql.Sqlite {
public SqliteAdo() : base(null, null, DataType.Sqlite) { } public SqliteAdo() : base(null, null, DataType.Sqlite) { }
public SqliteAdo(CommonUtils util, ICache cache, ILogger log, string masterConnectionString, string[] slaveConnectionStrings) : base(cache, log, DataType.Sqlite) { public SqliteAdo(CommonUtils util, ICache cache, ILogger log, string masterConnectionString, string[] slaveConnectionStrings) : base(cache, log, DataType.Sqlite) {
base._util = util; base._util = util;
MasterPool = new SqliteConnectionPool("主库", masterConnectionString, null, null); if (!string.IsNullOrEmpty(masterConnectionString))
MasterPool = new SqliteConnectionPool("主库", masterConnectionString, null, null);
if (slaveConnectionStrings != null) { if (slaveConnectionStrings != null) {
foreach (var slaveConnectionString in slaveConnectionStrings) { foreach (var slaveConnectionString in slaveConnectionStrings) {
var slavePool = new SqliteConnectionPool($"从库{SlavePools.Count + 1}", slaveConnectionString, () => Interlocked.Decrement(ref slaveUnavailables), () => Interlocked.Increment(ref slaveUnavailables)); var slavePool = new SqliteConnectionPool($"从库{SlavePools.Count + 1}", slaveConnectionString, () => Interlocked.Decrement(ref slaveUnavailables), () => Interlocked.Increment(ref slaveUnavailables));