tk/FreeSql
1
0
Fork 0
mirror of https://github.com/nsnail/FreeSql.git synced 2025-11-04 17:20:49 +08:00
Code Issues Packages Projects Releases Wiki Activity

## v0.3.11

Browse Source 
- 增加 ISelect、IInsert、IUpdate、IDelete WithTransaction 方法，将事务对象暴露给外部；
- 增加 IAdo ExecuteXxx 系列方法重载，支持事务对象的传入；
This commit is contained in:
28810
2019-03-11 17:26:27 +08:00
parent c14dd0c169
commit 4f66c3b9eb
29 changed files with 216 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Examples/repository_01/Startup.cs
View File

@@ -67,7 +67,7 @@ namespace repository_01 {
var builder = new ContainerBuilder(); var builder = new ContainerBuilder();
builder.RegisterFreeRepositoryAddFilter<Song>(() => a => a.Title == DateTime.Now.ToString() + System.Threading.Thread.CurrentThread.ManagedThreadId); builder.RegisterFreeRepositoryAndFilter<Song>(() => a => a.Title == DateTime.Now.ToString() + System.Threading.Thread.CurrentThread.ManagedThreadId);
//builder.RegisterFreeGuidRepository<Song>(a => a.Id == 1, oldname => $"{oldname}_{DateTime.Now.Year}"); //builder.RegisterFreeGuidRepository<Song>(a => a.Id == 1, oldname => $"{oldname}_{DateTime.Now.Year}");
builder.Populate(services); builder.Populate(services);

4
FreeSql.Repository/DependencyInjection.cs → FreeSql.Repository/Extenssions/AutofacExtenssions.cs
View File

@@ -6,10 +6,10 @@ using System.Collections.Concurrent;
using System.Linq.Expressions; using System.Linq.Expressions;
using System.Reflection; using System.Reflection;
public static class FreeSqlRepositoryAutofacDependencyInjection { public static class FreeSqlRepositoryAutofacExtenssions {
public static void RegisterFreeRepository(this ContainerBuilder builder) => RegisterFreeRepositoryPrivate<bool>(builder, null, null); public static void RegisterFreeRepository(this ContainerBuilder builder) => RegisterFreeRepositoryPrivate<bool>(builder, null, null);
public static void RegisterFreeRepositoryAddFilter<TEntity>(this ContainerBuilder builder, Func<Expression<Func<TEntity, bool>>> filterHandler) => RegisterFreeRepositoryPrivate<TEntity>(builder, filterHandler, null); public static void RegisterFreeRepositoryAndFilter<TEntity>(this ContainerBuilder builder, Func<Expression<Func<TEntity, bool>>> filterHandler) => RegisterFreeRepositoryPrivate<TEntity>(builder, filterHandler, null);
static ConcurrentDictionary<Type, Delegate> _dicRegisterFreeRepositorySetFilterFunc = new ConcurrentDictionary<Type, Delegate>(); static ConcurrentDictionary<Type, Delegate> _dicRegisterFreeRepositorySetFilterFunc = new ConcurrentDictionary<Type, Delegate>();
static ConcurrentDictionary<Type, Delegate> _dicRegisterFreeRepositorySetAsTableFunc = new ConcurrentDictionary<Type, Delegate>(); static ConcurrentDictionary<Type, Delegate> _dicRegisterFreeRepositorySetAsTableFunc = new ConcurrentDictionary<Type, Delegate>();

2
FreeSql.Repository/IFreeSqlExtenssions.cs → FreeSql.Repository/Extenssions/IFreeSqlExtenssions.cs
View File

@@ -5,7 +5,7 @@ using System.Collections.Concurrent;
using System.Text; using System.Text;
using System.Linq.Expressions; using System.Linq.Expressions;
public static class IFreeSqlExtenssions { public static class FreeSqlRepositoryIFreeSqlExtenssions {
/// <summary> /// <summary>
/// 返回默认仓库类 /// 返回默认仓库类

2
FreeSql.Repository/FreeSql.Repository.csproj
View File

@@ -2,7 +2,7 @@
<PropertyGroup> <PropertyGroup>
<TargetFramework>netstandard2.0</TargetFramework> <TargetFramework>netstandard2.0</TargetFramework>
<Version>0.1.14</Version> <Version>0.3.11</Version>
<Authors>YeXiangQin</Authors> <Authors>YeXiangQin</Authors>
<Description>FreeSql 通用仓库层实现，支持 MySql/SqlServer/PostgreSQL/Oracle/Sqlite，读写分离、分表分库。</Description> <Description>FreeSql 通用仓库层实现，支持 MySql/SqlServer/PostgreSQL/Oracle/Sqlite，读写分离、分表分库。</Description>
<PackageProjectUrl>https://github.com/2881099/FreeSql</PackageProjectUrl> <PackageProjectUrl>https://github.com/2881099/FreeSql</PackageProjectUrl>

2
FreeSql/FreeSql.csproj
View File

@@ -2,7 +2,7 @@
<PropertyGroup> <PropertyGroup>
<TargetFramework>netstandard2.0</TargetFramework> <TargetFramework>netstandard2.0</TargetFramework>
<Version>0.1.14</Version> <Version>0.3.11</Version>
<GeneratePackageOnBuild>true</GeneratePackageOnBuild> <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
<Authors>YeXiangQin</Authors> <Authors>YeXiangQin</Authors>
<Description>打造 .NETCore 最方便的 ORM，DbFirst 与 CodeFirst 混合使用，提供从实体同步数据库，或者从数据库生成实体代码，支持 MySql/SqlServer/PostgreSQL/Oracle/Sqlite，读写分离、分表分库。</Description> <Description>打造 .NETCore 最方便的 ORM，DbFirst 与 CodeFirst 混合使用，提供从实体同步数据库，或者从数据库生成实体代码，支持 MySql/SqlServer/PostgreSQL/Oracle/Sqlite，读写分离、分表分库。</Description>

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

@@ -1,10 +1,19 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Data.Common;
using System.Linq.Expressions; using System.Linq.Expressions;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql { namespace FreeSql {
public interface IDelete<T1> where T1 : class { public interface IDelete<T1> where T1 : class {
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="transaction"></param>
/// <returns></returns>
IDelete<T1> WithTransaction(DbTransaction transaction);
/// <summary> /// <summary>
/// lambda表达式条件，仅支持实体基础成员（不包含导航对象） /// lambda表达式条件，仅支持实体基础成员（不包含导航对象）
/// </summary> /// </summary>

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

@@ -1,11 +1,19 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Data.Common;
using System.Linq.Expressions; using System.Linq.Expressions;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql { namespace FreeSql {
public interface IInsert<T1> where T1 : class { public interface IInsert<T1> where T1 : class {
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="transaction"></param>
/// <returns></returns>
IInsert<T1> WithTransaction(DbTransaction transaction);
/// <summary> /// <summary>
/// 追加准备插入的实体 /// 追加准备插入的实体
/// </summary> /// </summary>

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

@@ -1,5 +1,6 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Data.Common;
using System.Linq.Expressions; using System.Linq.Expressions;
using System.Text; using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
@@ -7,6 +8,13 @@ using System.Threading.Tasks;
namespace FreeSql { namespace FreeSql {
public interface ISelect0<TSelect, T1> { public interface ISelect0<TSelect, T1> {
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="transaction"></param>
/// <returns></returns>
TSelect WithTransaction(DbTransaction transaction);
/// <summary> /// <summary>
/// 执行SQL查询，返回 T1 实体所有字段的记录，记录不存在时返回 Count 为 0 的列表 /// 执行SQL查询，返回 T1 实体所有字段的记录，记录不存在时返回 Count 为 0 的列表
/// </summary> /// </summary>

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

@@ -1,11 +1,19 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Data.Common;
using System.Linq.Expressions; using System.Linq.Expressions;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql { namespace FreeSql {
public interface IUpdate<T1> where T1 : class { public interface IUpdate<T1> where T1 : class {
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="transaction"></param>
/// <returns></returns>
IUpdate<T1> WithTransaction(DbTransaction transaction);
/// <summary> /// <summary>
/// 更新数据，设置更新的实体 /// 更新数据，设置更新的实体
/// </summary> /// </summary>

24
FreeSql/Interface/IAdo.cs
View File

@@ -61,18 +61,21 @@ namespace FreeSql {
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <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);
/// <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>
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <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);
/// <summary> /// <summary>
/// 查询 /// 查询
/// </summary> /// </summary>
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <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);
/// <summary> /// <summary>
/// 查询，ExecuteArray("select * from user where age > @age", new { age = 25 }) /// 查询，ExecuteArray("select * from user where age > @age", new { age = 25 })
/// </summary> /// </summary>
@@ -80,12 +83,14 @@ namespace FreeSql {
/// <param name="parms"></param> /// <param name="parms"></param>
/// <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);
/// <summary> /// <summary>
/// 查询 /// 查询
/// </summary> /// </summary>
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <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);
/// <summary> /// <summary>
/// 查询，ExecuteDataTable("select * from user where age > @age", new { age = 25 }) /// 查询，ExecuteDataTable("select * from user where age > @age", new { age = 25 })
/// </summary> /// </summary>
@@ -93,6 +98,7 @@ namespace FreeSql {
/// <param name="parms"></param> /// <param name="parms"></param>
/// <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);
/// <summary> /// <summary>
/// 在【主库】执行 /// 在【主库】执行
/// </summary> /// </summary>
@@ -100,6 +106,7 @@ namespace FreeSql {
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <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);
/// <summary> /// <summary>
/// 在【主库】执行，ExecuteNonQuery("delete from user where age > @age", new { age = 25 }) /// 在【主库】执行，ExecuteNonQuery("delete from user where age > @age", new { age = 25 })
/// </summary> /// </summary>
@@ -107,6 +114,7 @@ namespace FreeSql {
/// <param name="parms"></param> /// <param name="parms"></param>
/// <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);
/// <summary> /// <summary>
/// 在【主库】执行 /// 在【主库】执行
/// </summary> /// </summary>
@@ -114,6 +122,7 @@ namespace FreeSql {
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <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);
/// <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>
@@ -121,6 +130,7 @@ namespace FreeSql {
/// <param name="parms"></param> /// <param name="parms"></param>
/// <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);
/// <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 })
@@ -131,6 +141,7 @@ namespace FreeSql {
/// <param name="cmdParms"></param> /// <param name="cmdParms"></param>
/// <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);
/// <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>
@@ -139,6 +150,7 @@ namespace FreeSql {
/// <param name="parms"></param> /// <param name="parms"></param>
/// <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);
#region async #region async
/// <summary> /// <summary>
@@ -149,18 +161,21 @@ namespace FreeSql {
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <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);
/// <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>
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <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);
/// <summary> /// <summary>
/// 查询 /// 查询
/// </summary> /// </summary>
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <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);
/// <summary> /// <summary>
/// 查询，ExecuteArrayAsync("select * from user where age > @age", new { age = 25 }) /// 查询，ExecuteArrayAsync("select * from user where age > @age", new { age = 25 })
/// </summary> /// </summary>
@@ -168,12 +183,14 @@ namespace FreeSql {
/// <param name="parms"></param> /// <param name="parms"></param>
/// <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);
/// <summary> /// <summary>
/// 查询 /// 查询
/// </summary> /// </summary>
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <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);
/// <summary> /// <summary>
/// 查询，ExecuteDataTableAsync("select * from user where age > @age", new { age = 25 }) /// 查询，ExecuteDataTableAsync("select * from user where age > @age", new { age = 25 })
/// </summary> /// </summary>
@@ -181,6 +198,7 @@ namespace FreeSql {
/// <param name="parms"></param> /// <param name="parms"></param>
/// <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);
/// <summary> /// <summary>
/// 在【主库】执行 /// 在【主库】执行
/// </summary> /// </summary>
@@ -188,6 +206,7 @@ namespace FreeSql {
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <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);
/// <summary> /// <summary>
/// 在【主库】执行，ExecuteNonQueryAsync("delete from user where age > @age", new { age = 25 }) /// 在【主库】执行，ExecuteNonQueryAsync("delete from user where age > @age", new { age = 25 })
/// </summary> /// </summary>
@@ -195,6 +214,7 @@ namespace FreeSql {
/// <param name="parms"></param> /// <param name="parms"></param>
/// <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);
/// <summary> /// <summary>
/// 在【主库】执行 /// 在【主库】执行
/// </summary> /// </summary>
@@ -202,6 +222,7 @@ namespace FreeSql {
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <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);
/// <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>
@@ -209,6 +230,7 @@ namespace FreeSql {
/// <param name="parms"></param> /// <param name="parms"></param>
/// <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);
/// <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 })
@@ -219,6 +241,7 @@ namespace FreeSql {
/// <param name="cmdParms"></param> /// <param name="cmdParms"></param>
/// <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);
/// <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>
@@ -227,6 +250,7 @@ namespace FreeSql {
/// <param name="parms"></param> /// <param name="parms"></param>
/// <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);
#endregion #endregion
} }
} }

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

@@ -58,7 +58,13 @@ namespace FreeSql.Internal.CommonProvider {
log.Append(e.Message); log.Append(e.Message);
_log.LogError(log.ToString()); _log.LogError(log.ToString());
RollbackTransaction(); if (cmd.Transaction != null) {
var curTran = TransactionCurrentThread;
if (cmd.Transaction != TransactionCurrentThread) {
//cmd.Transaction.Rollback();
} else
RollbackTransaction();
}
AopCommandExecuted?.Invoke(cmd, log.ToString()); AopCommandExecuted?.Invoke(cmd, log.ToString());
@@ -67,13 +73,15 @@ 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>(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public List<T> Query<T>(string cmdText, object parms = null) => Query<T>(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public List<T> Query<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { public List<T> Query<T>(DbTransaction transaction, string cmdText, object parms = null) => Query<T>(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public List<T> Query<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => Query<T>(null, cmdType, cmdText, cmdParms);
public List<T> Query<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var ret = new List<T>(); var ret = new List<T>();
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(dr => { ExecuteReader(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++)
@@ -84,8 +92,10 @@ namespace FreeSql.Internal.CommonProvider {
}, cmdType, cmdText, cmdParms); }, cmdType, cmdText, cmdParms);
return ret; return ret;
} }
public void ExecuteReader(Action<DbDataReader> readerHander, string cmdText, object parms = null) => ExecuteReader(readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public void ExecuteReader(Action<DbDataReader> readerHander, string cmdText, object parms = null) => ExecuteReader(null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public void ExecuteReader(Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { public void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, string cmdText, object parms = null) => ExecuteReader(transaction, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public void ExecuteReader(Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReader(null, readerHander, cmdType, cmdText, cmdParms);
public void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
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;
@@ -108,7 +118,7 @@ namespace FreeSql.Internal.CommonProvider {
} }
Object<DbConnection> conn = null; Object<DbConnection> conn = null;
var pc = PrepareCommand(cmdType, cmdText, cmdParms, logtxt); var pc = PrepareCommand(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 {
@@ -178,20 +188,24 @@ namespace FreeSql.Internal.CommonProvider {
LoggerException(pool, pc.cmd, ex, dt, logtxt); LoggerException(pool, pc.cmd, ex, dt, logtxt);
pc.cmd.Parameters.Clear(); pc.cmd.Parameters.Clear();
} }
public object[][] ExecuteArray(string cmdText, object parms = null) => ExecuteArray(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public object[][] ExecuteArray(string cmdText, object parms = null) => ExecuteArray(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object[][] ExecuteArray(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { public object[][] ExecuteArray(DbTransaction transaction, string cmdText, object parms = null) => ExecuteArray(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object[][] ExecuteArray(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArray(null, cmdType, cmdText, cmdParms);
public object[][] ExecuteArray(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
List<object[]> ret = new List<object[]>(); List<object[]> ret = new List<object[]>();
ExecuteReader(dr => { ExecuteReader(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);
}, cmdType, cmdText, cmdParms); }, cmdType, cmdText, cmdParms);
return ret.ToArray(); return ret.ToArray();
} }
public DataTable ExecuteDataTable(string cmdText, object parms = null) => ExecuteDataTable(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public DataTable ExecuteDataTable(string cmdText, object parms = null) => ExecuteDataTable(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public DataTable ExecuteDataTable(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { public DataTable ExecuteDataTable(DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTable(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public DataTable ExecuteDataTable(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTable(null, cmdType, cmdText, cmdParms);
public DataTable ExecuteDataTable(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var ret = new DataTable(); var ret = new DataTable();
ExecuteReader(dr => { ExecuteReader(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];
@@ -200,13 +214,15 @@ namespace FreeSql.Internal.CommonProvider {
}, cmdType, cmdText, cmdParms); }, cmdType, cmdText, cmdParms);
return ret; return ret;
} }
public int ExecuteNonQuery(string cmdText, object parms = null) => ExecuteNonQuery(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public int ExecuteNonQuery(string cmdText, object parms = null) => ExecuteNonQuery(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public int ExecuteNonQuery(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { public int ExecuteNonQuery(DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQuery(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public int ExecuteNonQuery(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQuery(null, cmdType, cmdText, cmdParms);
public int ExecuteNonQuery(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
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(cmdType, cmdText, cmdParms, logtxt); var pc = PrepareCommand(transaction, cmdType, cmdText, cmdParms, logtxt);
int val = 0; int val = 0;
Exception ex = null; Exception ex = null;
try { try {
@@ -225,13 +241,15 @@ namespace FreeSql.Internal.CommonProvider {
pc.cmd.Parameters.Clear(); pc.cmd.Parameters.Clear();
return val; return val;
} }
public object ExecuteScalar(string cmdText, object parms = null) => ExecuteScalar(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public object ExecuteScalar(string cmdText, object parms = null) => ExecuteScalar(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object ExecuteScalar(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { public object ExecuteScalar(DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalar(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public object ExecuteScalar(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalar(null, cmdType, cmdText, cmdParms);
public object ExecuteScalar(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
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(cmdType, cmdText, cmdParms, logtxt); var pc = PrepareCommand(transaction, cmdType, cmdText, cmdParms, logtxt);
object val = null; object val = null;
Exception ex = null; Exception ex = null;
try { try {
@@ -251,7 +269,7 @@ namespace FreeSql.Internal.CommonProvider {
return val; return val;
} }
private (DbTransaction tran, DbCommand cmd) PrepareCommand(CommandType cmdType, string cmdText, DbParameter[] cmdParms, StringBuilder logtxt) { private (DbTransaction tran, DbCommand cmd) PrepareCommand(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, StringBuilder logtxt) {
var dt = DateTime.Now; var dt = DateTime.Now;
DbCommand cmd = CreateCommand(); DbCommand cmd = CreateCommand();
cmd.CommandType = cmdType; cmd.CommandType = cmdType;
@@ -265,7 +283,7 @@ namespace FreeSql.Internal.CommonProvider {
} }
} }
var tran = TransactionCurrentThread; 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 (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) {

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

@@ -9,13 +9,15 @@ 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>(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task<List<T>> QueryAsync<T>(string cmdText, object parms = null) => QueryAsync<T>(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
async public Task<List<T>> QueryAsync<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { public Task<List<T>> QueryAsync<T>(DbTransaction transaction, string cmdText, object parms = null) => QueryAsync<T>(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<List<T>> QueryAsync<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T>(null, cmdType, cmdText, cmdParms);
async public Task<List<T>> QueryAsync<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var ret = new List<T>(); var ret = new List<T>();
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(dr => { await ExecuteReaderAsync(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++)
@@ -27,8 +29,10 @@ namespace FreeSql.Internal.CommonProvider {
}, cmdType, cmdText, cmdParms); }, cmdType, cmdText, cmdParms);
return ret; return ret;
} }
public Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
async public Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { public Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(transaction, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(null, readerHander, cmdType, cmdText, cmdParms);
async public Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
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;
@@ -51,7 +55,7 @@ namespace FreeSql.Internal.CommonProvider {
} }
Object<DbConnection> conn = null; Object<DbConnection> conn = null;
var cmd = PrepareCommandAsync(cmdType, cmdText, cmdParms, logtxt); var cmd = PrepareCommandAsync(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 {
@@ -121,20 +125,24 @@ namespace FreeSql.Internal.CommonProvider {
LoggerException(pool, cmd, ex, dt, logtxt); LoggerException(pool, cmd, ex, dt, logtxt);
cmd.Parameters.Clear(); cmd.Parameters.Clear();
} }
public Task<object[][]> ExecuteArrayAsync(string cmdText, object parms = null) => ExecuteArrayAsync(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task<object[][]> ExecuteArrayAsync(string cmdText, object parms = null) => ExecuteArrayAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
async public Task<object[][]> ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { public Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteArrayAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<object[][]> ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArrayAsync(null, cmdType, cmdText, cmdParms);
async public Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
List<object[]> ret = new List<object[]>(); List<object[]> ret = new List<object[]>();
await ExecuteReaderAsync(async dr => { await ExecuteReaderAsync(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);
}, cmdType, cmdText, cmdParms); }, cmdType, cmdText, cmdParms);
return ret.ToArray(); return ret.ToArray();
} }
public Task<DataTable> ExecuteDataTableAsync(string cmdText, object parms = null) => ExecuteDataTableAsync(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task<DataTable> ExecuteDataTableAsync(string cmdText, object parms = null) => ExecuteDataTableAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
async public Task<DataTable> ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { public Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTableAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<DataTable> ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTableAsync(null, cmdType, cmdText, cmdParms);
async public Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
var ret = new DataTable(); var ret = new DataTable();
await ExecuteReaderAsync(async dr => { await ExecuteReaderAsync(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];
@@ -143,13 +151,15 @@ namespace FreeSql.Internal.CommonProvider {
}, cmdType, cmdText, cmdParms); }, cmdType, cmdText, cmdParms);
return ret; return ret;
} }
public Task<int> ExecuteNonQueryAsync(string cmdText, object parms = null) => ExecuteNonQueryAsync(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task<int> ExecuteNonQueryAsync(string cmdText, object parms = null) => ExecuteNonQueryAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
async public Task<int> ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { public Task<int> ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQueryAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<int> ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(null, cmdType, cmdText, cmdParms);
async public Task<int> ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
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(cmdType, cmdText, cmdParms, logtxt); var cmd = PrepareCommandAsync(transaction, cmdType, cmdText, cmdParms, logtxt);
int val = 0; int val = 0;
Exception ex = null; Exception ex = null;
try { try {
@@ -168,13 +178,15 @@ namespace FreeSql.Internal.CommonProvider {
cmd.Parameters.Clear(); cmd.Parameters.Clear();
return val; return val;
} }
public Task<object> ExecuteScalarAsync(string cmdText, object parms = null) => ExecuteScalarAsync(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms)); public Task<object> ExecuteScalarAsync(string cmdText, object parms = null) => ExecuteScalarAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
async public Task<object> ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) { public Task<object> ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalarAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
public Task<object> ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(null, cmdType, cmdText, cmdParms);
async public Task<object> ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
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(cmdType, cmdText, cmdParms, logtxt); var cmd = PrepareCommandAsync(transaction, cmdType, cmdText, cmdParms, logtxt);
object val = null; object val = null;
Exception ex = null; Exception ex = null;
try { try {
@@ -194,7 +206,7 @@ namespace FreeSql.Internal.CommonProvider {
return val; return val;
} }
private DbCommand PrepareCommandAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, StringBuilder logtxt) { private DbCommand PrepareCommandAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, StringBuilder logtxt) {
DateTime dt = DateTime.Now; DateTime dt = DateTime.Now;
DbCommand cmd = CreateCommand(); DbCommand cmd = CreateCommand();
cmd.CommandType = cmdType; cmd.CommandType = cmdType;
@@ -208,7 +220,16 @@ namespace FreeSql.Internal.CommonProvider {
} }
} }
if (IsTracePerformance) logtxt.Append(" PrepareCommand_tran==null: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms cmdParms: ").Append(cmd.Parameters.Count).Append("\r\n"); var tran = transaction;
if (tran != null) {
if (IsTracePerformance) dt = DateTime.Now;
cmd.Connection = tran.Connection;
cmd.Transaction = tran;
if (IsTracePerformance) logtxt.Append(" PrepareCommandAsync_tran!=null: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n");
}
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;

22
FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderTransaction.cs
View File

@@ -47,9 +47,6 @@ namespace FreeSql.Internal.CommonProvider {
} }
public void TransactionPreRemoveCache(params string[] key) => PreRemove(key); public void TransactionPreRemoveCache(params string[] key) => PreRemove(key);
/// <summary>
/// 启动事务
/// </summary>
public void BeginTransaction(TimeSpan timeout) { public void BeginTransaction(TimeSpan timeout) {
int tid = Thread.CurrentThread.ManagedThreadId; int tid = Thread.CurrentThread.ManagedThreadId;
Transaction2 tran = null; Transaction2 tran = null;
@@ -60,6 +57,7 @@ namespace FreeSql.Internal.CommonProvider {
tran = new Transaction2(conn, conn.Value.BeginTransaction(), timeout); tran = new Transaction2(conn, conn.Value.BeginTransaction(), timeout);
} catch(Exception ex) { } catch(Exception ex) {
_log.LogError($"数据库出错（开启事务）{ex.Message} \r\n{ex.StackTrace}"); _log.LogError($"数据库出错（开启事务）{ex.Message} \r\n{ex.StackTrace}");
MasterPool.Return(conn);
throw ex; throw ex;
} }
if (_trans.ContainsKey(tid)) CommitTransaction(); if (_trans.ContainsKey(tid)) CommitTransaction();
@@ -68,9 +66,6 @@ namespace FreeSql.Internal.CommonProvider {
_trans.Add(tid, tran); _trans.Add(tid, tran);
} }
/// <summary>
/// 自动提交事务
/// </summary>
private void AutoCommitTransaction() { private void AutoCommitTransaction() {
if (_trans.Count > 0) { if (_trans.Count > 0) {
Transaction2[] trans = null; Transaction2[] trans = null;
@@ -110,13 +105,7 @@ namespace FreeSql.Internal.CommonProvider {
private void CommitTransaction(bool isCommit) { private void CommitTransaction(bool isCommit) {
if (_trans.TryGetValue(Thread.CurrentThread.ManagedThreadId, out var tran)) CommitTransaction(isCommit, tran); if (_trans.TryGetValue(Thread.CurrentThread.ManagedThreadId, out var tran)) CommitTransaction(isCommit, tran);
} }
/// <summary>
/// 提交事务
/// </summary>
public void CommitTransaction() => CommitTransaction(true); public void CommitTransaction() => CommitTransaction(true);
/// <summary>
/// 回滚事务
/// </summary>
public void RollbackTransaction() => CommitTransaction(false); public void RollbackTransaction() => CommitTransaction(false);
public void Dispose() { public void Dispose() {
@@ -126,18 +115,9 @@ namespace FreeSql.Internal.CommonProvider {
foreach (Transaction2 tran in trans) CommitTransaction(false, tran); foreach (Transaction2 tran in trans) CommitTransaction(false, tran);
} }
/// <summary>
/// 开启事务（不支持异步），60秒未执行完将自动提交
/// </summary>
/// <param name="handler">事务体 () => {}</param>
public void Transaction(Action handler) { public void Transaction(Action handler) {
Transaction(handler, TimeSpan.FromSeconds(60)); Transaction(handler, TimeSpan.FromSeconds(60));
} }
/// <summary>
/// 开启事务（不支持异步）
/// </summary>
/// <param name="handler">事务体 () => {}</param>
/// <param name="timeout">超时，未执行完将自动提交</param>
public void Transaction(Action handler, TimeSpan timeout) { public void Transaction(Action handler, TimeSpan timeout) {
try { try {
BeginTransaction(timeout); BeginTransaction(timeout);

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

@@ -19,6 +19,7 @@ namespace FreeSql.Internal.CommonProvider {
protected StringBuilder _where = new StringBuilder(); protected StringBuilder _where = new StringBuilder();
protected int _whereTimes = 0; protected int _whereTimes = 0;
protected List<DbParameter> _params = new List<DbParameter>(); protected List<DbParameter> _params = new List<DbParameter>();
protected DbTransaction _transaction;
public DeleteProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) { public DeleteProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) {
_orm = orm; _orm = orm;
@@ -29,15 +30,20 @@ namespace FreeSql.Internal.CommonProvider {
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure<T1>(); if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure<T1>();
} }
public IDelete<T1> WithTransaction(DbTransaction transaction) {
_transaction = transaction;
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;
return _orm.Ado.ExecuteNonQuery(CommandType.Text, sql, _params.ToArray()); return _orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, sql, _params.ToArray());
} }
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;
return await _orm.Ado.ExecuteNonQueryAsync(CommandType.Text, sql, _params.ToArray()); return await _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, sql, _params.ToArray());
} }
public abstract List<T1> ExecuteDeleted(); public abstract List<T1> ExecuteDeleted();
public abstract Task<List<T1>> ExecuteDeletedAsync(); public abstract Task<List<T1>> ExecuteDeletedAsync();

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

@@ -19,6 +19,7 @@ namespace FreeSql.Internal.CommonProvider {
protected TableInfo _table; protected TableInfo _table;
protected Func<string, string> _tableRule; protected Func<string, string> _tableRule;
protected DbParameter[] _params; protected DbParameter[] _params;
protected DbTransaction _transaction;
public InsertProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression) { public InsertProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression) {
_orm = orm; _orm = orm;
@@ -28,6 +29,11 @@ namespace FreeSql.Internal.CommonProvider {
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure<T1>(); if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure<T1>();
} }
public IInsert<T1> WithTransaction(DbTransaction transaction) {
_transaction = transaction;
return this;
}
public IInsert<T1> AppendData(T1 source) { public IInsert<T1> AppendData(T1 source) {
if (source != null) _source.Add(source); if (source != null) _source.Add(source);
return this; return this;
@@ -37,8 +43,8 @@ namespace FreeSql.Internal.CommonProvider {
return this; return this;
} }
public int ExecuteAffrows() => _orm.Ado.ExecuteNonQuery(CommandType.Text, this.ToSql(), _params); public int ExecuteAffrows() => _orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, this.ToSql(), _params);
public Task<int> ExecuteAffrowsAsync() => _orm.Ado.ExecuteNonQueryAsync(CommandType.Text, this.ToSql(), _params); public Task<int> ExecuteAffrowsAsync() => _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, this.ToSql(), _params);
public abstract long ExecuteIdentity(); public abstract long ExecuteIdentity();
public abstract Task<long> ExecuteIdentityAsync(); public abstract Task<long> ExecuteIdentityAsync();
public abstract List<T1> ExecuteInserted(); public abstract List<T1> ExecuteInserted();

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

@@ -25,6 +25,7 @@ namespace FreeSql.Internal.CommonProvider {
protected IFreeSql _orm; protected IFreeSql _orm;
protected CommonUtils _commonUtils; protected CommonUtils _commonUtils;
protected CommonExpression _commonExpression; protected CommonExpression _commonExpression;
protected DbTransaction _transaction;
internal static void CopyData(Select0Provider<TSelect, T1> from, object to) { internal static void CopyData(Select0Provider<TSelect, T1> from, object to) {
var toType = to?.GetType(); var toType = to?.GetType();
@@ -44,6 +45,7 @@ namespace FreeSql.Internal.CommonProvider {
//toType.GetField("_orm", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._orm); //toType.GetField("_orm", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._orm);
//toType.GetField("_commonUtils", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._commonUtils); //toType.GetField("_commonUtils", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._commonUtils);
//toType.GetField("_commonExpression", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._commonExpression); //toType.GetField("_commonExpression", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._commonExpression);
toType.GetField("_transaction", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._transaction);
} }
public Select0Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) { public Select0Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) {
@@ -55,6 +57,11 @@ namespace FreeSql.Internal.CommonProvider {
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure<T1>(); if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure<T1>();
} }
public TSelect WithTransaction(DbTransaction transaction) {
_transaction = transaction;
return this as TSelect;
}
public bool Any() { public bool Any() {
this.Limit(1); this.Limit(1);
return this.ToList<int>("1").FirstOrDefault() == 1; return this.ToList<int>("1").FirstOrDefault() == 1;
@@ -152,7 +159,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(dr => { _orm.Ado.ExecuteReader(_transaction, dr => {
var read = Utils.ExecuteArrayRowReadClassOrTuple(type, null, dr); var read = Utils.ExecuteArrayRowReadClassOrTuple(type, null, dr);
ret.Add((TTuple)read.Value); ret.Add((TTuple)read.Value);
}, CommandType.Text, sql, _params.ToArray()); }, CommandType.Text, sql, _params.ToArray());
@@ -166,7 +173,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(dr => { await _orm.Ado.ExecuteReaderAsync(_transaction, dr => {
var read = Utils.ExecuteArrayRowReadClassOrTuple(type, null, dr); var read = Utils.ExecuteArrayRowReadClassOrTuple(type, null, dr);
ret.Add((TTuple)read.Value); ret.Add((TTuple)read.Value);
return Task.CompletedTask; return Task.CompletedTask;
@@ -181,7 +188,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(dr => { _orm.Ado.ExecuteReader(_transaction, dr => {
ret.Add(af.Read(dr)); ret.Add(af.Read(dr));
}, CommandType.Text, sql, _params.ToArray()); }, CommandType.Text, sql, _params.ToArray());
return ret; return ret;
@@ -194,7 +201,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(dr => { await _orm.Ado.ExecuteReaderAsync(_transaction, dr => {
ret.Add(af.Read(dr)); ret.Add(af.Read(dr));
return Task.CompletedTask; return Task.CompletedTask;
}, CommandType.Text, sql, _params.ToArray()); }, CommandType.Text, sql, _params.ToArray());
@@ -220,7 +227,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(dr => { _orm.Ado.ExecuteReader(_transaction, dr => {
var index = -1; var index = -1;
ret.Add((TReturn)_commonExpression.ReadAnonymous(af.map, dr, ref index)); ret.Add((TReturn)_commonExpression.ReadAnonymous(af.map, dr, ref index));
}, CommandType.Text, sql, _params.ToArray()); }, CommandType.Text, sql, _params.ToArray());
@@ -234,7 +241,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(dr => { await _orm.Ado.ExecuteReaderAsync(_transaction, dr => {
var index = -1; var index = -1;
ret.Add((TReturn)_commonExpression.ReadAnonymous(af.map, dr, ref index)); ret.Add((TReturn)_commonExpression.ReadAnonymous(af.map, dr, ref index));
return Task.CompletedTask; return Task.CompletedTask;

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

@@ -22,6 +22,7 @@ namespace FreeSql.Internal.CommonProvider {
protected StringBuilder _set = new StringBuilder(); protected StringBuilder _set = new StringBuilder();
protected List<DbParameter> _params = new List<DbParameter>(); protected List<DbParameter> _params = new List<DbParameter>();
protected List<DbParameter> _paramsSource = new List<DbParameter>(); protected List<DbParameter> _paramsSource = new List<DbParameter>();
protected DbTransaction _transaction;
public UpdateProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) { public UpdateProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) {
_orm = orm; _orm = orm;
@@ -32,15 +33,20 @@ namespace FreeSql.Internal.CommonProvider {
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure<T1>(); if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure<T1>();
} }
public IUpdate<T1> WithTransaction(DbTransaction transaction) {
_transaction = transaction;
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;
return _orm.Ado.ExecuteNonQuery(CommandType.Text, sql, _params.Concat(_paramsSource).ToArray()); return _orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, sql, _params.Concat(_paramsSource).ToArray());
} }
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;
return await _orm.Ado.ExecuteNonQueryAsync(CommandType.Text, sql, _params.Concat(_paramsSource).ToArray()); return await _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, sql, _params.Concat(_paramsSource).ToArray());
} }
public abstract List<T1> ExecuteUpdated(); public abstract List<T1> ExecuteUpdated();
public abstract Task<List<T1>> ExecuteUpdatedAsync(); public abstract Task<List<T1>> ExecuteUpdatedAsync();

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;
} }
return _orm.Ado.Query<T1>(CommandType.Text, sb.ToString(), _params.ToArray()); return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params.ToArray());
} }
async public override Task<List<T1>> ExecuteDeletedAsync() { async public override Task<List<T1>> ExecuteDeletedAsync() {
var sql = this.ToSql(); var sql = this.ToSql();
@@ -39,7 +39,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>(CommandType.Text, sb.ToString(), _params.ToArray()); return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params.ToArray());
} }
} }
} }

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

@@ -15,13 +15,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(CommandType.Text, string.Concat(sql, "; SELECT LAST_INSERT_ID();"), _params)), out var trylng) ? trylng : 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;
} }
async public override Task<long> ExecuteIdentityAsync() { async public override Task<long> ExecuteIdentityAsync() {
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(CommandType.Text, string.Concat(sql, "; SELECT LAST_INSERT_ID();"), _params)), out var trylng) ? trylng : 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;
} }
public override List<T1> ExecuteInserted() { public override List<T1> ExecuteInserted() {
@@ -37,7 +37,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>(CommandType.Text, sb.ToString(), _params); return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params);
} }
async public override Task<List<T1>> ExecuteInsertedAsync() { async public override Task<List<T1>> ExecuteInsertedAsync() {
var sql = this.ToSql(); var sql = this.ToSql();
@@ -52,7 +52,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>(CommandType.Text, sb.ToString(), _params); return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params);
} }
} }
} }

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

@@ -27,7 +27,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>(CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
} }
async public override Task<List<T1>> ExecuteUpdatedAsync() { async public override Task<List<T1>> ExecuteUpdatedAsync() {
var sql = this.ToSql(); var sql = this.ToSql();
@@ -42,7 +42,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>(CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
} }
protected override void ToSqlCase(StringBuilder caseWhen, ColumnInfo[] primarys) { protected override void ToSqlCase(StringBuilder caseWhen, ColumnInfo[] primarys) {

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

@@ -75,13 +75,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(CommandType.Text, sql, _params); _orm.Ado.ExecuteNonQuery(_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(CommandType.Text, $"{sql} RETURNING {identColName} INTO {identParam.ParameterName}", _params.Concat(new[] { identParam }).ToArray()); _orm.Ado.ExecuteNonQuery(_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 public override Task<long> ExecuteIdentityAsync() { async public override Task<long> ExecuteIdentityAsync() {
@@ -89,13 +89,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(CommandType.Text, sql, _params); await _orm.Ado.ExecuteNonQueryAsync(_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(CommandType.Text, $"{sql} RETURNING {identColName} INTO {identParam.ParameterName}", _params.Concat(new[] { identParam }).ToArray()); await _orm.Ado.ExecuteNonQueryAsync(_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;
} }
@@ -142,7 +142,7 @@ namespace FreeSql.Oracle.Curd {
//end loop; //end loop;
//end; //end;
//"); //");
// return _orm.Ado.Query<T1>(CommandType.Text, sb.ToString(), _params); // return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params);
} }
public override Task<List<T1>> ExecuteInsertedAsync() { public override Task<List<T1>> ExecuteInsertedAsync() {
throw new NotImplementedException(); throw new NotImplementedException();

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;
} }
return _orm.Ado.Query<T1>(CommandType.Text, sb.ToString(), _params.ToArray()); return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params.ToArray());
} }
async public override Task<List<T1>> ExecuteDeletedAsync() { async public override Task<List<T1>> ExecuteDeletedAsync() {
var sql = this.ToSql(); var sql = this.ToSql();
@@ -39,7 +39,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>(CommandType.Text, sb.ToString(), _params.ToArray()); return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params.ToArray());
} }
} }
} }

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

@@ -18,10 +18,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(CommandType.Text, sql, _params); _orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, sql, _params);
return 0; return 0;
} }
return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(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(_transaction, CommandType.Text, string.Concat(sql, " RETURNING ", _commonUtils.QuoteSqlName(identCols.First().Value.Attribute.Name)), _params)), out var trylng) ? trylng : 0;
} }
async public override Task<long> ExecuteIdentityAsync() { async public override Task<long> ExecuteIdentityAsync() {
var sql = this.ToSql(); var sql = this.ToSql();
@@ -29,10 +29,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(CommandType.Text, sql, _params); await _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, sql, _params);
return 0; return 0;
} }
return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(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(_transaction, CommandType.Text, string.Concat(sql, " RETURNING ", _commonUtils.QuoteSqlName(identCols.First().Value.Attribute.Name)), _params)), out var trylng) ? trylng : 0;
} }
public override List<T1> ExecuteInserted() { public override List<T1> ExecuteInserted() {
@@ -48,7 +48,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>(CommandType.Text, sb.ToString(), _params); return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params);
} }
async public override Task<List<T1>> ExecuteInsertedAsync() { async public override Task<List<T1>> ExecuteInsertedAsync() {
var sql = this.ToSql(); var sql = this.ToSql();
@@ -63,7 +63,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>(CommandType.Text, sb.ToString(), _params); return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params);
} }
} }
} }

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

@@ -27,7 +27,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>(CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
} }
async public override Task<List<T1>> ExecuteUpdatedAsync() { async public override Task<List<T1>> ExecuteUpdatedAsync() {
var sql = this.ToSql(); var sql = this.ToSql();
@@ -42,7 +42,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>(CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
} }
protected override void ToSqlCase(StringBuilder caseWhen, ColumnInfo[] primarys) { protected override void ToSqlCase(StringBuilder caseWhen, ColumnInfo[] primarys) {

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));
return _orm.Ado.Query<T1>(CommandType.Text, sb.ToString(), _params.ToArray()); return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params.ToArray());
} }
async public override Task<List<T1>> ExecuteDeletedAsync() { async public override Task<List<T1>> ExecuteDeletedAsync() {
var sql = this.ToSql(); var sql = this.ToSql();
@@ -50,7 +50,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));
return await _orm.Ado.QueryAsync<T1>(CommandType.Text, sb.ToString(), _params.ToArray()); return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params.ToArray());
} }
} }
} }

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

@@ -16,13 +16,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(CommandType.Text, string.Concat(sql, "; SELECT SCOPE_IDENTITY();"), _params)), out var trylng) ? trylng : 0; return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_transaction, CommandType.Text, string.Concat(sql, "; SELECT SCOPE_IDENTITY();"), _params)), out var trylng) ? trylng : 0;
} }
async public override Task<long> ExecuteIdentityAsync() { async public override Task<long> ExecuteIdentityAsync() {
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(CommandType.Text, string.Concat(sql, "; SELECT SCOPE_IDENTITY();"), _params)), out var trylng) ? trylng : 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;
} }
public override List<T1> ExecuteInserted() { public override List<T1> ExecuteInserted() {
@@ -43,7 +43,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>(CommandType.Text, sb.ToString(), _params); return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params);
} }
async public override Task<List<T1>> ExecuteInsertedAsync() { async public override Task<List<T1>> ExecuteInsertedAsync() {
var sql = this.ToSql(); var sql = this.ToSql();
@@ -63,7 +63,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>(CommandType.Text, sb.ToString(), _params); return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params);
} }
} }
} }

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

@@ -33,7 +33,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));
return _orm.Ado.Query<T1>(CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
} }
async public override Task<List<T1>> ExecuteUpdatedAsync() { async public override Task<List<T1>> ExecuteUpdatedAsync() {
var sql = this.ToSql(); var sql = this.ToSql();
@@ -53,7 +53,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));
return await _orm.Ado.QueryAsync<T1>(CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray()); return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
} }
protected override void ToSqlCase(StringBuilder caseWhen, ColumnInfo[] primarys) { protected override void ToSqlCase(StringBuilder caseWhen, ColumnInfo[] primarys) {

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

@@ -16,13 +16,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(CommandType.Text, string.Concat(sql, "; SELECT last_insert_rowid();"), _params)), out var trylng) ? trylng : 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;
} }
async public override Task<long> ExecuteIdentityAsync() { async public override Task<long> ExecuteIdentityAsync() {
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(CommandType.Text, string.Concat(sql, "; SELECT last_insert_rowid();"), _params)), out var trylng) ? trylng : 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;
} }
public override List<T1> ExecuteInserted() { public override List<T1> ExecuteInserted() {

4
readme.md
View File

@@ -1,7 +1,7 @@
FreeSql 是一个功能强大的 .NETStandard 库，用于对象关系映射程序(O/RM)，便于开发人员能够使用 .NETStandard 对象来处理数据库，不必经常编写大部分数据访问代码。支持 .NETCore 2.1+ 或 .NETFramework 4.6.1+。 FreeSql 是一个功能强大的 .NETStandard 库，用于对象关系映射程序(O/RM)，便于开发人员能够使用 .NETStandard 对象来处理数据库，不必经常编写大部分数据访问代码。支持 .NETCore 2.1+ 或 .NETFramework 4.6.1+。
| Package Name | NuGet | Downloads | | | Package Name | NuGet | Downloads |
|--------------| ------- | ---- | -- | |--------------| ------- | ---- |
| FreeSql | [![nuget](https://img.shields.io/nuget/v/FreeSql.svg?style=flat-square)](https://www.nuget.org/packages/FreeSql) | [![stats](https://img.shields.io/nuget/dt/FreeSql.svg?style=flat-square)](https://www.nuget.org/stats/packages/FreeSql?groupby=Version) | | FreeSql | [![nuget](https://img.shields.io/nuget/v/FreeSql.svg?style=flat-square)](https://www.nuget.org/packages/FreeSql) | [![stats](https://img.shields.io/nuget/dt/FreeSql.svg?style=flat-square)](https://www.nuget.org/stats/packages/FreeSql?groupby=Version) |
| [FreeSql.Repository](https://github.com/2881099/FreeSql/wiki/Repository) | [![nuget](https://img.shields.io/nuget/v/FreeSql.Repository.svg?style=flat-square)](https://www.nuget.org/packages/FreeSql.Repository) | [![stats](https://img.shields.io/nuget/dt/FreeSql.Repository.svg?style=flat-square)](https://www.nuget.org/stats/packages/FreeSql.Repository?groupby=Version) | | [FreeSql.Repository](https://github.com/2881099/FreeSql/wiki/Repository) | [![nuget](https://img.shields.io/nuget/v/FreeSql.Repository.svg?style=flat-square)](https://www.nuget.org/packages/FreeSql.Repository) | [![stats](https://img.shields.io/nuget/dt/FreeSql.Repository.svg?style=flat-square)](https://www.nuget.org/stats/packages/FreeSql.Repository?groupby=Version) |