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

- 增加 Async CancellationToken IInsert/IUdate/IInsertOrUpdate；

Browse Source
This commit is contained in:
2881099 2020-11-12 06:35:29 +08:00
parent 2222fa269e
commit 8bbb7329f9
45 changed files with 492 additions and 433 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
FreeSql.DbContext/FreeSql.DbContext.xml
View File

@ -130,6 +130,13 @@
清空状态数据 清空状态数据
</summary> </summary>
</member> </member>
<member name="M:FreeSql.DbSet`1.RemoveAsync(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
根据 lambda 条件删除数据
</summary>
<param name="predicate"></param>
<returns></returns>
</member>
<member name="M:FreeSql.DbSet`1.Add(`0)"> <member name="M:FreeSql.DbSet`1.Add(`0)">
<summary> <summary>
添加 添加
@ -502,5 +509,14 @@
<param name="that"></param> <param name="that"></param>
<returns></returns> <returns></returns>
</member> </member>
<member name="M:Microsoft.Extensions.DependencyInjection.FreeSqlRepositoryDependencyInjection.AddFreeRepository(Microsoft.Extensions.DependencyInjection.IServiceCollection,System.Action{FreeSql.FluentDataFilter},System.Reflection.Assembly[])">
<summary>
批量注入 Repository，可以参考代码自行调整
</summary>
<param name="services"></param>
<param name="globalDataFilter"></param>
<param name="assemblies"></param>
<returns></returns>
</member>
</members> </members>
</doc> </doc>

34
FreeSql/FreeSql.xml
View File

@ -3013,7 +3013,7 @@
<param name="parms"></param> <param name="parms"></param>
<returns></returns> <returns></returns>
</member> </member>
<member name="M:FreeSql.IAdo.ExecuteConnectTestAsync(System.Int32)"> <member name="M:FreeSql.IAdo.ExecuteConnectTestAsync(System.Int32,System.Threading.CancellationToken)">
<summary> <summary>
测试数据库是否连接正确，本方法执行如下命令：<para></para> 测试数据库是否连接正确，本方法执行如下命令：<para></para>
MySql/SqlServer/PostgreSQL/达梦/人大金仓/神通: SELECT 1<para></para> MySql/SqlServer/PostgreSQL/达梦/人大金仓/神通: SELECT 1<para></para>
@ -3022,7 +3022,7 @@
<param name="commandTimeout">命令超时设置(秒)</param> <param name="commandTimeout">命令超时设置(秒)</param>
<returns>true: 成功, false: 失败</returns> <returns>true: 成功, false: 失败</returns>
</member> </member>
<member name="M:FreeSql.IAdo.ExecuteReaderAsync(System.Func{FreeSql.Internal.Model.FetchCallbackArgs{System.Data.Common.DbDataReader},System.Threading.Tasks.Task},System.Data.CommandType,System.String,System.Data.Common.DbParameter[])"> <member name="M:FreeSql.IAdo.ExecuteReaderAsync(System.Func{FreeSql.Internal.Model.FetchCallbackArgs{System.Data.Common.DbDataReader},System.Threading.Tasks.Task},System.Data.CommandType,System.String,System.Data.Common.DbParameter[],System.Threading.CancellationToken)">
<summary> <summary>
查询，若使用读写分离，查询【从库】条件cmdText.StartsWith("SELECT ")，否则查询【主库】 查询，若使用读写分离，查询【从库】条件cmdText.StartsWith("SELECT ")，否则查询【主库】
</summary> </summary>
@ -3031,7 +3031,7 @@
<param name="cmdText"></param> <param name="cmdText"></param>
<param name="cmdParms"></param> <param name="cmdParms"></param>
</member> </member>
<member name="M:FreeSql.IAdo.ExecuteReaderAsync(System.Func{FreeSql.Internal.Model.FetchCallbackArgs{System.Data.Common.DbDataReader},System.Threading.Tasks.Task},System.String,System.Object)"> <member name="M:FreeSql.IAdo.ExecuteReaderAsync(System.Func{FreeSql.Internal.Model.FetchCallbackArgs{System.Data.Common.DbDataReader},System.Threading.Tasks.Task},System.String,System.Object,System.Threading.CancellationToken)">
<summary> <summary>
查询，ExecuteReaderAsync(dr => {}, "select * from user where age > ?age", new { age = 25 })<para></para> 查询，ExecuteReaderAsync(dr => {}, "select * from user where age > ?age", new { age = 25 })<para></para>
提示：parms 参数还可以传 Dictionary&lt;string, object&gt; 提示：parms 参数还可以传 Dictionary&lt;string, object&gt;
@ -3039,14 +3039,14 @@
<param name="cmdText"></param> <param name="cmdText"></param>
<param name="parms"></param> <param name="parms"></param>
</member> </member>
<member name="M:FreeSql.IAdo.ExecuteArrayAsync(System.Data.CommandType,System.String,System.Data.Common.DbParameter[])"> <member name="M:FreeSql.IAdo.ExecuteArrayAsync(System.Data.CommandType,System.String,System.Data.Common.DbParameter[],System.Threading.CancellationToken)">
<summary> <summary>
查询 查询
</summary> </summary>
<param name="cmdText"></param> <param name="cmdText"></param>
<param name="cmdParms"></param> <param name="cmdParms"></param>
</member> </member>
<member name="M:FreeSql.IAdo.ExecuteArrayAsync(System.String,System.Object)"> <member name="M:FreeSql.IAdo.ExecuteArrayAsync(System.String,System.Object,System.Threading.CancellationToken)">
<summary> <summary>
查询，ExecuteArrayAsync("select * from user where age > ?age", new { age = 25 })<para></para> 查询，ExecuteArrayAsync("select * from user where age > ?age", new { age = 25 })<para></para>
提示：parms 参数还可以传 Dictionary&lt;string, object&gt; 提示：parms 参数还可以传 Dictionary&lt;string, object&gt;
@ -3055,14 +3055,14 @@
<param name="parms"></param> <param name="parms"></param>
<returns></returns> <returns></returns>
</member> </member>
<member name="M:FreeSql.IAdo.ExecuteDataSetAsync(System.Data.CommandType,System.String,System.Data.Common.DbParameter[])"> <member name="M:FreeSql.IAdo.ExecuteDataSetAsync(System.Data.CommandType,System.String,System.Data.Common.DbParameter[],System.Threading.CancellationToken)">
<summary> <summary>
查询 查询
</summary> </summary>
<param name="cmdText"></param> <param name="cmdText"></param>
<param name="cmdParms"></param> <param name="cmdParms"></param>
</member> </member>
<member name="M:FreeSql.IAdo.ExecuteDataSetAsync(System.String,System.Object)"> <member name="M:FreeSql.IAdo.ExecuteDataSetAsync(System.String,System.Object,System.Threading.CancellationToken)">
<summary> <summary>
查询，ExecuteDataSetAsync("select * from user where age > ?age; select 2", new { age = 25 })<para></para> 查询，ExecuteDataSetAsync("select * from user where age > ?age; select 2", new { age = 25 })<para></para>
提示：parms 参数还可以传 Dictionary&lt;string, object&gt; 提示：parms 参数还可以传 Dictionary&lt;string, object&gt;
@ -3071,14 +3071,14 @@
<param name="parms"></param> <param name="parms"></param>
<returns></returns> <returns></returns>
</member> </member>
<member name="M:FreeSql.IAdo.ExecuteDataTableAsync(System.Data.CommandType,System.String,System.Data.Common.DbParameter[])"> <member name="M:FreeSql.IAdo.ExecuteDataTableAsync(System.Data.CommandType,System.String,System.Data.Common.DbParameter[],System.Threading.CancellationToken)">
<summary> <summary>
查询 查询
</summary> </summary>
<param name="cmdText"></param> <param name="cmdText"></param>
<param name="cmdParms"></param> <param name="cmdParms"></param>
</member> </member>
<member name="M:FreeSql.IAdo.ExecuteDataTableAsync(System.String,System.Object)"> <member name="M:FreeSql.IAdo.ExecuteDataTableAsync(System.String,System.Object,System.Threading.CancellationToken)">
<summary> <summary>
查询，ExecuteDataTableAsync("select * from user where age > ?age", new { age = 25 })<para></para> 查询，ExecuteDataTableAsync("select * from user where age > ?age", new { age = 25 })<para></para>
提示：parms 参数还可以传 Dictionary&lt;string, object&gt; 提示：parms 参数还可以传 Dictionary&lt;string, object&gt;
@ -3087,7 +3087,7 @@
<param name="parms"></param> <param name="parms"></param>
<returns></returns> <returns></returns>
</member> </member>
<member name="M:FreeSql.IAdo.ExecuteNonQueryAsync(System.Data.CommandType,System.String,System.Data.Common.DbParameter[])"> <member name="M:FreeSql.IAdo.ExecuteNonQueryAsync(System.Data.CommandType,System.String,System.Data.Common.DbParameter[],System.Threading.CancellationToken)">
<summary> <summary>
在【主库】执行 在【主库】执行
</summary> </summary>
@ -3095,7 +3095,7 @@
<param name="cmdText"></param> <param name="cmdText"></param>
<param name="cmdParms"></param> <param name="cmdParms"></param>
</member> </member>
<member name="M:FreeSql.IAdo.ExecuteNonQueryAsync(System.String,System.Object)"> <member name="M:FreeSql.IAdo.ExecuteNonQueryAsync(System.String,System.Object,System.Threading.CancellationToken)">
<summary> <summary>
在【主库】执行，ExecuteNonQueryAsync("delete from user where age > ?age", new { age = 25 })<para></para> 在【主库】执行，ExecuteNonQueryAsync("delete from user where age > ?age", new { age = 25 })<para></para>
提示：parms 参数还可以传 Dictionary&lt;string, object&gt; 提示：parms 参数还可以传 Dictionary&lt;string, object&gt;
@ -3104,7 +3104,7 @@
<param name="parms"></param> <param name="parms"></param>
<returns></returns> <returns></returns>
</member> </member>
<member name="M:FreeSql.IAdo.ExecuteScalarAsync(System.Data.CommandType,System.String,System.Data.Common.DbParameter[])"> <member name="M:FreeSql.IAdo.ExecuteScalarAsync(System.Data.CommandType,System.String,System.Data.Common.DbParameter[],System.Threading.CancellationToken)">
<summary> <summary>
在【主库】执行 在【主库】执行
</summary> </summary>
@ -3112,7 +3112,7 @@
<param name="cmdText"></param> <param name="cmdText"></param>
<param name="cmdParms"></param> <param name="cmdParms"></param>
</member> </member>
<member name="M:FreeSql.IAdo.ExecuteScalarAsync(System.String,System.Object)"> <member name="M:FreeSql.IAdo.ExecuteScalarAsync(System.String,System.Object,System.Threading.CancellationToken)">
<summary> <summary>
在【主库】执行，ExecuteScalarAsync("select 1 from user where age > ?age", new { age = 25 })<para></para> 在【主库】执行，ExecuteScalarAsync("select 1 from user where age > ?age", new { age = 25 })<para></para>
提示：parms 参数还可以传 Dictionary&lt;string, object&gt; 提示：parms 参数还可以传 Dictionary&lt;string, object&gt;
@ -3121,7 +3121,7 @@
<param name="parms"></param> <param name="parms"></param>
<returns></returns> <returns></returns>
</member> </member>
<member name="M:FreeSql.IAdo.QueryAsync``1(System.Data.CommandType,System.String,System.Data.Common.DbParameter[])"> <member name="M:FreeSql.IAdo.QueryAsync``1(System.Data.CommandType,System.String,System.Data.Common.DbParameter[],System.Threading.CancellationToken)">
<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 })
</summary> </summary>
@ -3131,7 +3131,7 @@
<param name="cmdParms"></param> <param name="cmdParms"></param>
<returns></returns> <returns></returns>
</member> </member>
<member name="M:FreeSql.IAdo.QueryAsync``1(System.String,System.Object)"> <member name="M:FreeSql.IAdo.QueryAsync``1(System.String,System.Object,System.Threading.CancellationToken)">
<summary> <summary>
执行SQL返回对象集合，QueryAsync&lt;User&gt;("select * from user where age > ?age", new { age = 25 })<para></para> 执行SQL返回对象集合，QueryAsync&lt;User&gt;("select * from user where age > ?age", new { age = 25 })<para></para>
提示：parms 参数还可以传 Dictionary&lt;string, object&gt; 提示：parms 参数还可以传 Dictionary&lt;string, object&gt;
@ -3141,7 +3141,7 @@
<param name="parms"></param> <param name="parms"></param>
<returns></returns> <returns></returns>
</member> </member>
<member name="M:FreeSql.IAdo.QueryAsync``2(System.Data.CommandType,System.String,System.Data.Common.DbParameter[])"> <member name="M:FreeSql.IAdo.QueryAsync``2(System.Data.CommandType,System.String,System.Data.Common.DbParameter[],System.Threading.CancellationToken)">
<summary> <summary>
执行SQL返回对象集合，Query&lt;User&gt;("select * from user where age > ?age; select * from address", new SqlParameter { ParameterName = "age", Value = 25 }) 执行SQL返回对象集合，Query&lt;User&gt;("select * from user where age > ?age; select * from address", new SqlParameter { ParameterName = "age", Value = 25 })
</summary> </summary>
@ -3151,7 +3151,7 @@
<param name="cmdParms"></param> <param name="cmdParms"></param>
<returns></returns> <returns></returns>
</member> </member>
<member name="M:FreeSql.IAdo.QueryAsync``2(System.String,System.Object)"> <member name="M:FreeSql.IAdo.QueryAsync``2(System.String,System.Object,System.Threading.CancellationToken)">
<summary> <summary>
执行SQL返回对象集合，Query&lt;User, Address&gt;("select * from user where age > ?age; select * from address", new { age = 25 })<para></para> 执行SQL返回对象集合，Query&lt;User, Address&gt;("select * from user where age > ?age; select * from address", new { age = 25 })<para></para>
提示：parms 参数还可以传 Dictionary&lt;string, object&gt; 提示：parms 参数还可以传 Dictionary&lt;string, object&gt;

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

@ -4,6 +4,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Data.Common; using System.Data.Common;
using System.Linq.Expressions; using System.Linq.Expressions;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql namespace FreeSql
@ -157,9 +158,9 @@ namespace FreeSql
#if net40 #if net40
#else #else
Task<int> ExecuteAffrowsAsync(); Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default);
Task<long> ExecuteIdentityAsync(); Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default);
Task<List<T1>> ExecuteInsertedAsync(); Task<List<T1>> ExecuteInsertedAsync(CancellationToken cancellationToken = default);
#endif #endif
} }
} }

3
FreeSql/Interface/Curd/IInsertOrUpdate.cs
View File

@ -2,6 +2,7 @@
using System.Collections.Generic; using System.Collections.Generic;
using System.Data.Common; using System.Data.Common;
using System.Linq.Expressions; using System.Linq.Expressions;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql namespace FreeSql
@ -86,7 +87,7 @@ namespace FreeSql
#if net40 #if net40
#else #else
Task<int> ExecuteAffrowsAsync(); Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default);
#endif #endif
} }
} }

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

@ -3,6 +3,7 @@ using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Data.Common; using System.Data.Common;
using System.Linq.Expressions; using System.Linq.Expressions;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql namespace FreeSql
@ -249,8 +250,8 @@ namespace FreeSql
#if net40 #if net40
#else #else
Task<int> ExecuteAffrowsAsync(); Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default);
Task<List<T1>> ExecuteUpdatedAsync(); Task<List<T1>> ExecuteUpdatedAsync(CancellationToken cancellationToken = default);
#endif #endif
} }
} }

137
FreeSql/Interface/IAdo.cs
View File

@ -6,6 +6,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Data.Common; using System.Data.Common;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql namespace FreeSql
@ -274,7 +275,7 @@ namespace FreeSql
/// </summary> /// </summary>
/// <param name="commandTimeout">命令超时设置(秒)</param> /// <param name="commandTimeout">命令超时设置(秒)</param>
/// <returns>true: 成功, false: 失败</returns> /// <returns>true: 成功, false: 失败</returns>
Task<bool> ExecuteConnectTestAsync(int commandTimeout = 0); Task<bool> ExecuteConnectTestAsync(int commandTimeout = 0, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 查询，若使用读写分离，查询【从库】条件cmdText.StartsWith("SELECT ")，否则查询【主库】 /// 查询，若使用读写分离，查询【从库】条件cmdText.StartsWith("SELECT ")，否则查询【主库】
@ -283,26 +284,26 @@ namespace FreeSql
/// <param name="cmdType"></param> /// <param name="cmdType"></param>
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <param name="cmdParms"></param> /// <param name="cmdParms"></param>
Task ExecuteReaderAsync(Func<FetchCallbackArgs<DbDataReader>, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task ExecuteReaderAsync(Func<FetchCallbackArgs<DbDataReader>, Task> readerHander, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task ExecuteReaderAsync(DbTransaction transaction, Func<FetchCallbackArgs<DbDataReader>, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task ExecuteReaderAsync(DbTransaction transaction, Func<FetchCallbackArgs<DbDataReader>, Task> readerHander, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func<FetchCallbackArgs<DbDataReader>, Task> readerHander, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func<FetchCallbackArgs<DbDataReader>, Task> readerHander, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 查询，ExecuteReaderAsync(dr => {}, "select * from user where age > ?age", new { age = 25 })<para></para> /// 查询，ExecuteReaderAsync(dr => {}, "select * from user where age > ?age", new { age = 25 })<para></para>
/// 提示：parms 参数还可以传 Dictionary&lt;string, object&gt; /// 提示：parms 参数还可以传 Dictionary&lt;string, object&gt;
/// </summary> /// </summary>
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <param name="parms"></param> /// <param name="parms"></param>
Task ExecuteReaderAsync(Func<FetchCallbackArgs<DbDataReader>, Task> readerHander, string cmdText, object parms = null); Task ExecuteReaderAsync(Func<FetchCallbackArgs<DbDataReader>, Task> readerHander, string cmdText, object parms = null, CancellationToken cancellationToken = default);
Task ExecuteReaderAsync(DbTransaction transaction, Func<FetchCallbackArgs<DbDataReader>, Task> readerHander, string cmdText, object parms = null); Task ExecuteReaderAsync(DbTransaction transaction, Func<FetchCallbackArgs<DbDataReader>, Task> readerHander, string cmdText, object parms = null, CancellationToken cancellationToken = default);
Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func<FetchCallbackArgs<DbDataReader>, Task> readerHander, string cmdText, object parms = null); Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func<FetchCallbackArgs<DbDataReader>, Task> readerHander, string cmdText, object parms = null, CancellationToken cancellationToken = default);
/// <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, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<object[][]> ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); Task<object[][]> ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 查询，ExecuteArrayAsync("select * from user where age > ?age", new { age = 25 })<para></para> /// 查询，ExecuteArrayAsync("select * from user where age > ?age", new { age = 25 })<para></para>
/// 提示：parms 参数还可以传 Dictionary&lt;string, object&gt; /// 提示：parms 参数还可以传 Dictionary&lt;string, object&gt;
@ -310,17 +311,17 @@ namespace FreeSql
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <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, CancellationToken cancellationToken = default);
Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null); Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default);
Task<object[][]> ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); Task<object[][]> ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 查询 /// 查询
/// </summary> /// </summary>
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <param name="cmdParms"></param> /// <param name="cmdParms"></param>
Task<DataSet> ExecuteDataSetAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<DataSet> ExecuteDataSetAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<DataSet> ExecuteDataSetAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<DataSet> ExecuteDataSetAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<DataSet> ExecuteDataSetAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); Task<DataSet> ExecuteDataSetAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 查询，ExecuteDataSetAsync("select * from user where age > ?age; select 2", new { age = 25 })<para></para> /// 查询，ExecuteDataSetAsync("select * from user where age > ?age; select 2", new { age = 25 })<para></para>
/// 提示：parms 参数还可以传 Dictionary&lt;string, object&gt; /// 提示：parms 参数还可以传 Dictionary&lt;string, object&gt;
@ -328,17 +329,17 @@ namespace FreeSql
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <param name="parms"></param> /// <param name="parms"></param>
/// <returns></returns> /// <returns></returns>
Task<DataSet> ExecuteDataSetAsync(string cmdText, object parms = null); Task<DataSet> ExecuteDataSetAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default);
Task<DataSet> ExecuteDataSetAsync(DbTransaction transaction, string cmdText, object parms = null); Task<DataSet> ExecuteDataSetAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default);
Task<DataSet> ExecuteDataSetAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); Task<DataSet> ExecuteDataSetAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default);
/// <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, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<DataTable> ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); Task<DataTable> ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 查询，ExecuteDataTableAsync("select * from user where age > ?age", new { age = 25 })<para></para> /// 查询，ExecuteDataTableAsync("select * from user where age > ?age", new { age = 25 })<para></para>
/// 提示：parms 参数还可以传 Dictionary&lt;string, object&gt; /// 提示：parms 参数还可以传 Dictionary&lt;string, object&gt;
@ -346,18 +347,18 @@ namespace FreeSql
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <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, CancellationToken cancellationToken = default);
Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null); Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default);
Task<DataTable> ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); Task<DataTable> ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 在【主库】执行 /// 在【主库】执行
/// </summary> /// </summary>
/// <param name="cmdType"></param> /// <param name="cmdType"></param>
/// <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, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<int> ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<int> ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<int> ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); Task<int> ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 在【主库】执行，ExecuteNonQueryAsync("delete from user where age > ?age", new { age = 25 })<para></para> /// 在【主库】执行，ExecuteNonQueryAsync("delete from user where age > ?age", new { age = 25 })<para></para>
/// 提示：parms 参数还可以传 Dictionary&lt;string, object&gt; /// 提示：parms 参数还可以传 Dictionary&lt;string, object&gt;
@ -365,18 +366,18 @@ namespace FreeSql
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <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, CancellationToken cancellationToken = default);
Task<int> ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null); Task<int> ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default);
Task<int> ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); Task<int> ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 在【主库】执行 /// 在【主库】执行
/// </summary> /// </summary>
/// <param name="cmdType"></param> /// <param name="cmdType"></param>
/// <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, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<object> ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<object> ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<object> ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); Task<object> ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 在【主库】执行，ExecuteScalarAsync("select 1 from user where age > ?age", new { age = 25 })<para></para> /// 在【主库】执行，ExecuteScalarAsync("select 1 from user where age > ?age", new { age = 25 })<para></para>
/// 提示：parms 参数还可以传 Dictionary&lt;string, object&gt; /// 提示：parms 参数还可以传 Dictionary&lt;string, object&gt;
@ -384,9 +385,9 @@ namespace FreeSql
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <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, CancellationToken cancellationToken = default);
Task<object> ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null); Task<object> ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default);
Task<object> ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); Task<object> ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default);
/// <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 })
@ -396,10 +397,10 @@ namespace FreeSql
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <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, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
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, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<List<T>> QueryAsync<T>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); Task<List<T>> QueryAsync<T>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<List<T>> QueryAsync<T>(Type resultType, DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); Task<List<T>> QueryAsync<T>(Type resultType, DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 执行SQL返回对象集合，QueryAsync&lt;User&gt;("select * from user where age > ?age", new { age = 25 })<para></para> /// 执行SQL返回对象集合，QueryAsync&lt;User&gt;("select * from user where age > ?age", new { age = 25 })<para></para>
/// 提示：parms 参数还可以传 Dictionary&lt;string, object&gt; /// 提示：parms 参数还可以传 Dictionary&lt;string, object&gt;
@ -408,9 +409,9 @@ namespace FreeSql
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <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, CancellationToken cancellationToken = default);
Task<List<T>> QueryAsync<T>(DbTransaction transaction, string cmdText, object parms = null); Task<List<T>> QueryAsync<T>(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default);
Task<List<T>> QueryAsync<T>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); Task<List<T>> QueryAsync<T>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 执行SQL返回对象集合，Query&lt;User&gt;("select * from user where age > ?age; select * from address", new SqlParameter { ParameterName = "age", Value = 25 }) /// 执行SQL返回对象集合，Query&lt;User&gt;("select * from user where age > ?age; select * from address", new SqlParameter { ParameterName = "age", Value = 25 })
@ -420,9 +421,9 @@ namespace FreeSql
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <param name="cmdParms"></param> /// <param name="cmdParms"></param>
/// <returns></returns> /// <returns></returns>
Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 执行SQL返回对象集合，Query&lt;User, Address&gt;("select * from user where age > ?age; select * from address", new { age = 25 })<para></para> /// 执行SQL返回对象集合，Query&lt;User, Address&gt;("select * from user where age > ?age; select * from address", new { age = 25 })<para></para>
/// 提示：parms 参数还可以传 Dictionary&lt;string, object&gt; /// 提示：parms 参数还可以传 Dictionary&lt;string, object&gt;
@ -431,28 +432,28 @@ namespace FreeSql
/// <param name="cmdText"></param> /// <param name="cmdText"></param>
/// <param name="parms"></param> /// <param name="parms"></param>
/// <returns></returns> /// <returns></returns>
Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(string cmdText, object parms = null); Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(string cmdText, object parms = null, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(DbTransaction transaction, string cmdText, object parms = null); Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(string cmdText, object parms = null); Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(string cmdText, object parms = null, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(DbTransaction transaction, string cmdText, object parms = null); Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(string cmdText, object parms = null); Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(string cmdText, object parms = null, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(DbTransaction transaction, string cmdText, object parms = null); Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(string cmdText, object parms = null); Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(string cmdText, object parms = null, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(DbTransaction transaction, string cmdText, object parms = null); Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default);
Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default);
#endregion #endregion
#endif #endif
} }

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

@ -6,6 +6,7 @@ using System.Data;
using System.Data.Common; using System.Data.Common;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
#if net40 #if net40
@ -14,7 +15,7 @@ namespace FreeSql.Internal.CommonProvider
{ {
partial class AdoProvider partial class AdoProvider
{ {
async public Task<bool> ExecuteConnectTestAsync(int commandTimeout = 0) async public Task<bool> ExecuteConnectTestAsync(int commandTimeout = 0, CancellationToken cancellationToken = default)
{ {
try try
{ {
@ -22,13 +23,13 @@ namespace FreeSql.Internal.CommonProvider
{ {
case DataType.Oracle: case DataType.Oracle:
case DataType.OdbcOracle: case DataType.OdbcOracle:
await ExecuteNonQueryAsync(null, null, CommandType.Text, " SELECT 1 FROM dual", commandTimeout); await ExecuteNonQueryAsync(null, null, CommandType.Text, " SELECT 1 FROM dual", commandTimeout, null, cancellationToken);
return true; return true;
case DataType.Firebird: case DataType.Firebird:
await ExecuteNonQueryAsync(null, null, CommandType.Text, " SELECT FIRST 1 1 FROM rdb$database", commandTimeout); await ExecuteNonQueryAsync(null, null, CommandType.Text, " SELECT FIRST 1 1 FROM rdb$database", commandTimeout, null, cancellationToken);
return true; return true;
} }
await ExecuteNonQueryAsync(null, null, CommandType.Text, " SELECT 1", commandTimeout); await ExecuteNonQueryAsync(null, null, CommandType.Text, " SELECT 1", commandTimeout, null, cancellationToken);
return true; return true;
} }
catch catch
@ -37,13 +38,13 @@ namespace FreeSql.Internal.CommonProvider
} }
} }
public Task<List<T>> QueryAsync<T>(string cmdText, object parms = null) => QueryAsync<T>(null, null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<List<T>> QueryAsync<T>(string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync<T>(null, null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<List<T>> QueryAsync<T>(DbTransaction transaction, string cmdText, object parms = null) => QueryAsync<T>(null, null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<List<T>> QueryAsync<T>(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync<T>(null, null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<List<T>> QueryAsync<T>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => QueryAsync<T>(null, connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<List<T>> QueryAsync<T>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync<T>(null, connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<List<T>> QueryAsync<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T>(null, null, null, cmdType, cmdText, 0, cmdParms); public Task<List<T>> QueryAsync<T>(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync<T>(null, null, null, cmdType, cmdText, 0, cmdParms, cancellationToken);
public Task<List<T>> QueryAsync<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T>(null, null, transaction, cmdType, cmdText, 0, cmdParms); public Task<List<T>> QueryAsync<T>(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync<T>(null, null, transaction, cmdType, cmdText, 0, cmdParms, cancellationToken);
public Task<List<T>> QueryAsync<T>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) => QueryAsync<T>(null, connection, transaction, cmdType, cmdText, cmdTimeout, cmdParms); public Task<List<T>> QueryAsync<T>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync<T>(null, connection, transaction, cmdType, cmdText, cmdTimeout, cmdParms, cancellationToken);
async public Task<List<T>> QueryAsync<T>(Type resultType, DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) async public Task<List<T>> QueryAsync<T>(Type resultType, DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default)
{ {
var ret = new List<T>(); var ret = new List<T>();
if (string.IsNullOrEmpty(cmdText)) return ret; if (string.IsNullOrEmpty(cmdText)) return ret;
@ -70,16 +71,16 @@ namespace FreeSql.Internal.CommonProvider
} }
ret.Add((T)Utils.ExecuteArrayRowReadClassOrTuple(flag, type, indexes, fetch.Object, 0, _util).Value); ret.Add((T)Utils.ExecuteArrayRowReadClassOrTuple(flag, type, indexes, fetch.Object, 0, _util).Value);
return Task.FromResult(false); return Task.FromResult(false);
}, cmdType, cmdText, cmdTimeout, cmdParms); }, cmdType, cmdText, cmdTimeout, cmdParms, cancellationToken);
return ret; return ret;
} }
#region QueryAsync multi #region QueryAsync multi
public Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(string cmdText, object parms = null) => QueryAsync<T1, T2>(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync<T1, T2>(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(DbTransaction transaction, string cmdText, object parms = null) => QueryAsync<T1, T2>(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync<T1, T2>(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => QueryAsync<T1, T2>(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync<T1, T2>(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T1, T2>(null, null, cmdType, cmdText, 0, cmdParms); public Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync<T1, T2>(null, null, cmdType, cmdText, 0, cmdParms, cancellationToken);
public Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T1, T2>(null, transaction, cmdType, cmdText, 0, cmdParms); public Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync<T1, T2>(null, transaction, cmdType, cmdText, 0, cmdParms, cancellationToken);
async public Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) async public Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default)
{ {
if (string.IsNullOrEmpty(cmdText)) return NativeTuple.Create(new List<T1>(), new List<T2>()); if (string.IsNullOrEmpty(cmdText)) return NativeTuple.Create(new List<T1>(), new List<T2>());
var ret1 = new List<T1>(); var ret1 = new List<T1>();
@ -133,16 +134,16 @@ namespace FreeSql.Internal.CommonProvider
break; break;
} }
return Task.FromResult(false); return Task.FromResult(false);
}, null, cmdType, cmdText, cmdTimeout, cmdParms); }, null, cmdType, cmdText, cmdTimeout, cmdParms, cancellationToken);
return NativeTuple.Create(ret1, ret2); return NativeTuple.Create(ret1, ret2);
} }
public Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(string cmdText, object parms = null) => QueryAsync<T1, T2, T3>(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync<T1, T2, T3>(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(DbTransaction transaction, string cmdText, object parms = null) => QueryAsync<T1, T2, T3>(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync<T1, T2, T3>(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => QueryAsync<T1, T2, T3>(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync<T1, T2, T3>(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T1, T2, T3>(null, null, cmdType, cmdText, 0, cmdParms); public Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync<T1, T2, T3>(null, null, cmdType, cmdText, 0, cmdParms, cancellationToken);
public Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T1, T2, T3>(null, transaction, cmdType, cmdText, 0, cmdParms); public Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync<T1, T2, T3>(null, transaction, cmdType, cmdText, 0, cmdParms, cancellationToken);
async public Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) async public Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default)
{ {
if (string.IsNullOrEmpty(cmdText)) return NativeTuple.Create(new List<T1>(), new List<T2>(), new List<T3>()); if (string.IsNullOrEmpty(cmdText)) return NativeTuple.Create(new List<T1>(), new List<T2>(), new List<T3>());
var ret1 = new List<T1>(); var ret1 = new List<T1>();
@ -219,16 +220,16 @@ namespace FreeSql.Internal.CommonProvider
break; break;
} }
return Task.FromResult(false); return Task.FromResult(false);
}, null, cmdType, cmdText, cmdTimeout, cmdParms); }, null, cmdType, cmdText, cmdTimeout, cmdParms, cancellationToken);
return NativeTuple.Create(ret1, ret2, ret3); return NativeTuple.Create(ret1, ret2, ret3);
} }
public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(string cmdText, object parms = null) => QueryAsync<T1, T2, T3, T4>(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync<T1, T2, T3, T4>(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(DbTransaction transaction, string cmdText, object parms = null) => QueryAsync<T1, T2, T3, T4>(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync<T1, T2, T3, T4>(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => QueryAsync<T1, T2, T3, T4>(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync<T1, T2, T3, T4>(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T1, T2, T3, T4>(null, null, cmdType, cmdText, 0, cmdParms); public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync<T1, T2, T3, T4>(null, null, cmdType, cmdText, 0, cmdParms, cancellationToken);
public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T1, T2, T3, T4>(null, transaction, cmdType, cmdText, 0, cmdParms); public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync<T1, T2, T3, T4>(null, transaction, cmdType, cmdText, 0, cmdParms, cancellationToken);
async public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) async public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default)
{ {
if (string.IsNullOrEmpty(cmdText)) return NativeTuple.Create(new List<T1>(), new List<T2>(), new List<T3>(), new List<T4>()); if (string.IsNullOrEmpty(cmdText)) return NativeTuple.Create(new List<T1>(), new List<T2>(), new List<T3>(), new List<T4>());
var ret1 = new List<T1>(); var ret1 = new List<T1>();
@ -328,16 +329,16 @@ namespace FreeSql.Internal.CommonProvider
break; break;
} }
return Task.FromResult(false); return Task.FromResult(false);
}, null, cmdType, cmdText, cmdTimeout, cmdParms); }, null, cmdType, cmdText, cmdTimeout, cmdParms, cancellationToken);
return NativeTuple.Create(ret1, ret2, ret3, ret4); return NativeTuple.Create(ret1, ret2, ret3, ret4);
} }
public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(string cmdText, object parms = null) => QueryAsync<T1, T2, T3, T4, T5>(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync<T1, T2, T3, T4, T5>(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(DbTransaction transaction, string cmdText, object parms = null) => QueryAsync<T1, T2, T3, T4, T5>(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync<T1, T2, T3, T4, T5>(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => QueryAsync<T1, T2, T3, T4, T5>(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync<T1, T2, T3, T4, T5>(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T1, T2, T3, T4, T5>(null, null, cmdType, cmdText, 0, cmdParms); public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync<T1, T2, T3, T4, T5>(null, null, cmdType, cmdText, 0, cmdParms, cancellationToken);
public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T1, T2, T3, T4, T5>(null, transaction, cmdType, cmdText, 0, cmdParms); public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync<T1, T2, T3, T4, T5>(null, transaction, cmdType, cmdText, 0, cmdParms, cancellationToken);
async public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) async public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default)
{ {
if (string.IsNullOrEmpty(cmdText)) return NativeTuple.Create(new List<T1>(), new List<T2>(), new List<T3>(), new List<T4>(), new List<T5>()); if (string.IsNullOrEmpty(cmdText)) return NativeTuple.Create(new List<T1>(), new List<T2>(), new List<T3>(), new List<T4>(), new List<T5>());
var ret1 = new List<T1>(); var ret1 = new List<T1>();
@ -460,18 +461,18 @@ namespace FreeSql.Internal.CommonProvider
break; break;
} }
return Task.FromResult(false); return Task.FromResult(false);
}, null, cmdType, cmdText, cmdTimeout, cmdParms); }, null, cmdType, cmdText, cmdTimeout, cmdParms, cancellationToken);
return NativeTuple.Create(ret1, ret2, ret3, ret4, ret5); return NativeTuple.Create(ret1, ret2, ret3, ret4, ret5);
} }
#endregion #endregion
public Task ExecuteReaderAsync(Func<FetchCallbackArgs<DbDataReader>, Task> fetchHandler, string cmdText, object parms = null) => ExecuteReaderAsync(null, null, fetchHandler, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task ExecuteReaderAsync(Func<FetchCallbackArgs<DbDataReader>, Task> fetchHandler, string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteReaderAsync(null, null, fetchHandler, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task ExecuteReaderAsync(DbTransaction transaction, Func<FetchCallbackArgs<DbDataReader>, Task> fetchHandler, string cmdText, object parms = null) => ExecuteReaderAsync(null, transaction, fetchHandler, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task ExecuteReaderAsync(DbTransaction transaction, Func<FetchCallbackArgs<DbDataReader>, Task> fetchHandler, string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteReaderAsync(null, transaction, fetchHandler, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func<FetchCallbackArgs<DbDataReader>, Task> fetchHandler, string cmdText, object parms = null) => ExecuteReaderAsync(connection, transaction, fetchHandler, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func<FetchCallbackArgs<DbDataReader>, Task> fetchHandler, string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteReaderAsync(connection, transaction, fetchHandler, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task ExecuteReaderAsync(Func<FetchCallbackArgs<DbDataReader>, Task> fetchHandler, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(null, null, fetchHandler, cmdType, cmdText, 0, cmdParms); public Task ExecuteReaderAsync(Func<FetchCallbackArgs<DbDataReader>, Task> fetchHandler, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteReaderAsync(null, null, fetchHandler, cmdType, cmdText, 0, cmdParms, cancellationToken);
public Task ExecuteReaderAsync(DbTransaction transaction, Func<FetchCallbackArgs<DbDataReader>, Task> fetchHandler, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(null, transaction, fetchHandler, cmdType, cmdText, 0, cmdParms); public Task ExecuteReaderAsync(DbTransaction transaction, Func<FetchCallbackArgs<DbDataReader>, Task> fetchHandler, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteReaderAsync(null, transaction, fetchHandler, cmdType, cmdText, 0, cmdParms, cancellationToken);
public Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func<FetchCallbackArgs<DbDataReader>, Task> fetchHandler, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) => ExecuteReaderMultipleAsync(1, connection, transaction, (fetch, result) => fetchHandler(fetch), null, cmdType, cmdText, cmdTimeout, cmdParms); public Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func<FetchCallbackArgs<DbDataReader>, Task> fetchHandler, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteReaderMultipleAsync(1, connection, transaction, (fetch, result) => fetchHandler(fetch), null, cmdType, cmdText, cmdTimeout, cmdParms, cancellationToken);
async Task ExecuteReaderMultipleAsync(int multipleResult, DbConnection connection, DbTransaction transaction, Func<FetchCallbackArgs<DbDataReader>, int, Task> fetchHandler, Action<DbDataReader, int> schemaHandler, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) async Task ExecuteReaderMultipleAsync(int multipleResult, DbConnection connection, DbTransaction transaction, Func<FetchCallbackArgs<DbDataReader>, int, Task> fetchHandler, Action<DbDataReader, int> schemaHandler, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default)
{ {
if (string.IsNullOrEmpty(cmdText)) return; if (string.IsNullOrEmpty(cmdText)) return;
var dt = DateTime.Now; var dt = DateTime.Now;
@ -501,7 +502,7 @@ namespace FreeSql.Internal.CommonProvider
} }
Object<DbConnection> conn = null; Object<DbConnection> conn = null;
var pc = await PrepareCommandAsync(connection, transaction, cmdType, cmdText, cmdTimeout, cmdParms, logtxt); var pc = await PrepareCommandAsync(connection, transaction, cmdType, cmdText, cmdTimeout, cmdParms, logtxt, cancellationToken);
if (IsTracePerformance) 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"); logtxt.Append("PrepareCommand: ").Append(DateTime.Now.Subtract(logtxt_dt).TotalMilliseconds).Append("ms Total: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n");
@ -534,7 +535,7 @@ namespace FreeSql.Internal.CommonProvider
LoggerException(pool, pc, new Exception($"连接失败，准备切换其他可用服务器"), dt, logtxt, false); LoggerException(pool, pc, new Exception($"连接失败，准备切换其他可用服务器"), dt, logtxt, false);
pc.cmd.Parameters.Clear(); pc.cmd.Parameters.Clear();
if (DataType == DataType.Sqlite) pc.cmd.Dispose(); if (DataType == DataType.Sqlite) pc.cmd.Dispose();
await ExecuteReaderMultipleAsync(multipleResult, connection, transaction, fetchHandler, schemaHandler, cmdType, cmdText, cmdTimeout, cmdParms); await ExecuteReaderMultipleAsync(multipleResult, connection, transaction, fetchHandler, schemaHandler, cmdType, cmdText, cmdTimeout, cmdParms, cancellationToken);
return; return;
} }
} }
@ -548,7 +549,7 @@ namespace FreeSql.Internal.CommonProvider
logtxt.Append("Pool.Get: ").Append(DateTime.Now.Subtract(logtxt_dt).TotalMilliseconds).Append("ms Total: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n"); logtxt.Append("Pool.Get: ").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 pc.cmd.ExecuteReaderAsync()) using (var dr = await pc.cmd.ExecuteReaderAsync(cancellationToken))
{ {
int resultIndex = 0; int resultIndex = 0;
var fetch = new FetchCallbackArgs<DbDataReader> { Object = dr }; var fetch = new FetchCallbackArgs<DbDataReader> { Object = dr };
@ -557,7 +558,7 @@ namespace FreeSql.Internal.CommonProvider
bool isfirst = true; bool isfirst = true;
while (true) while (true)
{ {
bool isread = await dr.ReadAsync(); bool isread = await dr.ReadAsync(cancellationToken);
if (schemaHandler != null && isfirst) if (schemaHandler != null && isfirst)
{ {
isfirst = false; isfirst = false;
@ -600,36 +601,36 @@ namespace FreeSql.Internal.CommonProvider
pc.cmd.Parameters.Clear(); pc.cmd.Parameters.Clear();
if (DataType == DataType.Sqlite) pc.cmd.Dispose(); if (DataType == DataType.Sqlite) pc.cmd.Dispose();
} }
public Task<object[][]> ExecuteArrayAsync(string cmdText, object parms = null) => ExecuteArrayAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<object[][]> ExecuteArrayAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteArrayAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteArrayAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteArrayAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<object[][]> ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteArrayAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<object[][]> ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteArrayAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<object[][]> ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArrayAsync(null, null, cmdType, cmdText, 0, cmdParms); public Task<object[][]> ExecuteArrayAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteArrayAsync(null, null, cmdType, cmdText, 0, cmdParms, cancellationToken);
public Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArrayAsync(null, transaction, cmdType, cmdText, 0, cmdParms); public Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteArrayAsync(null, transaction, cmdType, cmdText, 0, cmdParms, cancellationToken);
async public Task<object[][]> ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) async public Task<object[][]> ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default)
{ {
List<object[]> ret = new List<object[]>(); List<object[]> ret = new List<object[]>();
await ExecuteReaderAsync(connection, transaction, async fetch => await ExecuteReaderAsync(connection, transaction, async fetch =>
{ {
object[] values = new object[fetch.Object.FieldCount]; object[] values = new object[fetch.Object.FieldCount];
for (int a = 0; a < values.Length; a++) if (!await fetch.Object.IsDBNullAsync(a)) values[a] = await fetch.Object.GetFieldValueAsync<object>(a); for (int a = 0; a < values.Length; a++) if (!await fetch.Object.IsDBNullAsync(a, cancellationToken)) values[a] = await fetch.Object.GetFieldValueAsync<object>(a, cancellationToken);
ret.Add(values); ret.Add(values);
}, cmdType, cmdText, cmdTimeout, cmdParms); }, cmdType, cmdText, cmdTimeout, cmdParms, cancellationToken);
return ret.ToArray(); return ret.ToArray();
} }
public Task<DataSet> ExecuteDataSetAsync(string cmdText, object parms = null) => ExecuteDataSetAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<DataSet> ExecuteDataSetAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteDataSetAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<DataSet> ExecuteDataSetAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataSetAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<DataSet> ExecuteDataSetAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteDataSetAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<DataSet> ExecuteDataSetAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataSetAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<DataSet> ExecuteDataSetAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteDataSetAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<DataSet> ExecuteDataSetAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataSetAsync(null, null, cmdType, cmdText, 0, cmdParms); public Task<DataSet> ExecuteDataSetAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteDataSetAsync(null, null, cmdType, cmdText, 0, cmdParms, cancellationToken);
public Task<DataSet> ExecuteDataSetAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataSetAsync(null, transaction, cmdType, cmdText, 0, cmdParms); public Task<DataSet> ExecuteDataSetAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteDataSetAsync(null, transaction, cmdType, cmdText, 0, cmdParms, cancellationToken);
async public Task<DataSet> ExecuteDataSetAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) async public Task<DataSet> ExecuteDataSetAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default)
{ {
var ret = new DataSet(); var ret = new DataSet();
DataTable dt = null; DataTable dt = null;
await ExecuteReaderMultipleAsync(16, connection, transaction, async (fetch, result) => await ExecuteReaderMultipleAsync(16, connection, transaction, async (fetch, result) =>
{ {
object[] values = new object[dt.Columns.Count]; object[] values = new object[dt.Columns.Count];
for (int a = 0; a < values.Length; a++) if (!await fetch.Object.IsDBNullAsync(a)) values[a] = await fetch.Object.GetFieldValueAsync<object>(a); for (int a = 0; a < values.Length; a++) if (!await fetch.Object.IsDBNullAsync(a, cancellationToken)) values[a] = await fetch.Object.GetFieldValueAsync<object>(a, cancellationToken);
dt.Rows.Add(values); dt.Rows.Add(values);
}, (dr, result) => }, (dr, result) =>
{ {
@ -640,21 +641,21 @@ namespace FreeSql.Internal.CommonProvider
if (dt.Columns.Contains(name)) name = $"{name}_{Guid.NewGuid().ToString("N").Substring(0, 4)}"; if (dt.Columns.Contains(name)) name = $"{name}_{Guid.NewGuid().ToString("N").Substring(0, 4)}";
dt.Columns.Add(name, dr.GetFieldType(a)); dt.Columns.Add(name, dr.GetFieldType(a));
} }
}, cmdType, cmdText, cmdTimeout, cmdParms); }, cmdType, cmdText, cmdTimeout, cmdParms, cancellationToken);
return ret; return ret;
} }
public Task<DataTable> ExecuteDataTableAsync(string cmdText, object parms = null) => ExecuteDataTableAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<DataTable> ExecuteDataTableAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteDataTableAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTableAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteDataTableAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<DataTable> ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTableAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<DataTable> ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteDataTableAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<DataTable> ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTableAsync(null, null, cmdType, cmdText, 0, cmdParms); public Task<DataTable> ExecuteDataTableAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteDataTableAsync(null, null, cmdType, cmdText, 0, cmdParms, cancellationToken);
public Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTableAsync(null, transaction, cmdType, cmdText, 0, cmdParms); public Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteDataTableAsync(null, transaction, cmdType, cmdText, 0, cmdParms, cancellationToken);
async public Task<DataTable> ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) async public Task<DataTable> ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default)
{ {
var ret = new DataTable(); var ret = new DataTable();
await ExecuteReaderMultipleAsync(1, connection, transaction, async (fetch, result) => await ExecuteReaderMultipleAsync(1, connection, transaction, async (fetch, result) =>
{ {
object[] values = new object[ret.Columns.Count]; object[] values = new object[ret.Columns.Count];
for (int a = 0; a < values.Length; a++) if (!await fetch.Object.IsDBNullAsync(a)) values[a] = await fetch.Object.GetFieldValueAsync<object>(a); for (int a = 0; a < values.Length; a++) if (!await fetch.Object.IsDBNullAsync(a, cancellationToken)) values[a] = await fetch.Object.GetFieldValueAsync<object>(a, cancellationToken);
ret.Rows.Add(values); ret.Rows.Add(values);
}, (dr, result) => }, (dr, result) =>
{ {
@ -664,28 +665,28 @@ namespace FreeSql.Internal.CommonProvider
if (ret.Columns.Contains(name)) name = $"{name}_{Guid.NewGuid().ToString("N").Substring(0, 4)}"; if (ret.Columns.Contains(name)) name = $"{name}_{Guid.NewGuid().ToString("N").Substring(0, 4)}";
ret.Columns.Add(name, dr.GetFieldType(a)); ret.Columns.Add(name, dr.GetFieldType(a));
} }
}, cmdType, cmdText, cmdTimeout, cmdParms); }, cmdType, cmdText, cmdTimeout, cmdParms, cancellationToken);
return ret; return ret;
} }
public Task<int> ExecuteNonQueryAsync(string cmdText, object parms = null) => ExecuteNonQueryAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<int> ExecuteNonQueryAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteNonQueryAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<int> ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQueryAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<int> ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteNonQueryAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<int> ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQueryAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<int> ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteNonQueryAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<int> ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(null, null, cmdType, cmdText, 0, cmdParms); public Task<int> ExecuteNonQueryAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteNonQueryAsync(null, null, cmdType, cmdText, 0, cmdParms, cancellationToken);
public Task<int> ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(null, transaction, cmdType, cmdText, 0, cmdParms); public Task<int> ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteNonQueryAsync(null, transaction, cmdType, cmdText, 0, cmdParms, cancellationToken);
async public Task<int> ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) async public Task<int> ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default)
{ {
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 = await PrepareCommandAsync(connection, transaction, cmdType, cmdText, cmdTimeout, cmdParms, logtxt); var pc = await PrepareCommandAsync(connection, transaction, cmdType, cmdText, cmdTimeout, cmdParms, logtxt, cancellationToken);
int val = 0; int val = 0;
Exception ex = null; Exception ex = null;
try try
{ {
if (pc.cmd.Connection == null) pc.cmd.Connection = (conn = await this.MasterPool.GetAsync()).Value; if (pc.cmd.Connection == null) pc.cmd.Connection = (conn = await this.MasterPool.GetAsync()).Value;
val = await pc.cmd.ExecuteNonQueryAsync(); val = await pc.cmd.ExecuteNonQueryAsync(cancellationToken);
} }
catch (Exception ex2) catch (Exception ex2)
{ {
@ -703,25 +704,25 @@ namespace FreeSql.Internal.CommonProvider
if (DataType == DataType.Sqlite) pc.cmd.Dispose(); if (DataType == DataType.Sqlite) pc.cmd.Dispose();
return val; return val;
} }
public Task<object> ExecuteScalarAsync(string cmdText, object parms = null) => ExecuteScalarAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<object> ExecuteScalarAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteScalarAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<object> ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalarAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<object> ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteScalarAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<object> ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalarAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); public Task<object> ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteScalarAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken);
public Task<object> ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(null, null, cmdType, cmdText, 0, cmdParms); public Task<object> ExecuteScalarAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteScalarAsync(null, null, cmdType, cmdText, 0, cmdParms, cancellationToken);
public Task<object> ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(null, transaction, cmdType, cmdText, 0, cmdParms); public Task<object> ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteScalarAsync(null, transaction, cmdType, cmdText, 0, cmdParms, cancellationToken);
async public Task<object> ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) async public Task<object> ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default)
{ {
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 = await PrepareCommandAsync(connection, transaction, cmdType, cmdText, cmdTimeout, cmdParms, logtxt); var pc = await PrepareCommandAsync(connection, transaction, cmdType, cmdText, cmdTimeout, cmdParms, logtxt, cancellationToken);
object val = null; object val = null;
Exception ex = null; Exception ex = null;
try try
{ {
if (pc.cmd.Connection == null) pc.cmd.Connection = (conn = await this.MasterPool.GetAsync()).Value; if (pc.cmd.Connection == null) pc.cmd.Connection = (conn = await this.MasterPool.GetAsync()).Value;
val = await pc.cmd.ExecuteScalarAsync(); val = await pc.cmd.ExecuteScalarAsync(cancellationToken);
} }
catch (Exception ex2) catch (Exception ex2)
{ {
@ -740,7 +741,7 @@ namespace FreeSql.Internal.CommonProvider
return val; return val;
} }
async Task<PrepareCommandResult> PrepareCommandAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, StringBuilder logtxt) async Task<PrepareCommandResult> PrepareCommandAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, StringBuilder logtxt, CancellationToken cancellationToken = default)
{ {
DateTime dt = DateTime.Now; DateTime dt = DateTime.Now;
DbCommand cmd = CreateCommand(); DbCommand cmd = CreateCommand();
@ -774,7 +775,7 @@ namespace FreeSql.Internal.CommonProvider
if (connection.State != ConnectionState.Open) if (connection.State != ConnectionState.Open)
{ {
if (IsTracePerformance) dt = DateTime.Now; if (IsTracePerformance) dt = DateTime.Now;
await connection.OpenAsync(); await connection.OpenAsync(cancellationToken);
if (IsTracePerformance) logtxt.Append(" PrepareCommand_ConnectionOpen: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n"); if (IsTracePerformance) logtxt.Append(" PrepareCommand_ConnectionOpen: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n");
isclose = true; isclose = true;
} }

15
FreeSql/Internal/CommonProvider/InsertOrUpdateProvider.cs
View File

@ -8,6 +8,7 @@ using System.Linq;
using System.Linq.Expressions; using System.Linq.Expressions;
using System.Reflection; using System.Reflection;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Internal.CommonProvider namespace FreeSql.Internal.CommonProvider
@ -292,7 +293,7 @@ namespace FreeSql.Internal.CommonProvider
} }
#if net40 #if net40
#else #else
async public Task<int> RawExecuteAffrowsAsync() async public Task<int> RawExecuteAffrowsAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
@ -302,7 +303,7 @@ namespace FreeSql.Internal.CommonProvider
Exception exception = null; Exception exception = null;
try try
{ {
affrows = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); affrows = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -316,7 +317,7 @@ namespace FreeSql.Internal.CommonProvider
} }
return affrows; return affrows;
} }
async public Task<int> ExecuteAffrowsAsync() async public Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default)
{ {
var affrows = 0; var affrows = 0;
var ss = SplitSourceByIdentityValueIsNull(_source); var ss = SplitSourceByIdentityValueIsNull(_source);
@ -332,10 +333,10 @@ namespace FreeSql.Internal.CommonProvider
{ {
_source = ss.Item1; _source = ss.Item1;
_SplitSourceByIdentityValueIsNullFlag = 1; _SplitSourceByIdentityValueIsNullFlag = 1;
affrows += await this.RawExecuteAffrowsAsync(); affrows += await this.RawExecuteAffrowsAsync(cancellationToken);
_source = ss.Item2; _source = ss.Item2;
_SplitSourceByIdentityValueIsNullFlag = 2; _SplitSourceByIdentityValueIsNullFlag = 2;
affrows += await this.RawExecuteAffrowsAsync(); affrows += await this.RawExecuteAffrowsAsync(cancellationToken);
} }
else else
{ {
@ -348,10 +349,10 @@ namespace FreeSql.Internal.CommonProvider
{ {
_source = ss.Item1; _source = ss.Item1;
_SplitSourceByIdentityValueIsNullFlag = 1; _SplitSourceByIdentityValueIsNullFlag = 1;
affrows += await this.RawExecuteAffrowsAsync(); affrows += await this.RawExecuteAffrowsAsync(cancellationToken);
_source = ss.Item2; _source = ss.Item2;
_SplitSourceByIdentityValueIsNullFlag = 2; _SplitSourceByIdentityValueIsNullFlag = 2;
affrows += await this.RawExecuteAffrowsAsync(); affrows += await this.RawExecuteAffrowsAsync(cancellationToken);
_transaction.Commit(); _transaction.Commit();
_orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, "提交", null)); _orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, "提交", null));
} }

43
FreeSql/Internal/CommonProvider/InsertProviderAsync.cs
View File

@ -7,6 +7,7 @@ using System.Data.Common;
using System.Linq; using System.Linq;
using System.Linq.Expressions; using System.Linq.Expressions;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Internal.CommonProvider namespace FreeSql.Internal.CommonProvider
@ -16,7 +17,7 @@ namespace FreeSql.Internal.CommonProvider
{ {
#if net40 #if net40
#else #else
async protected Task<int> SplitExecuteAffrowsAsync(int valuesLimit, int parameterLimit) async protected Task<int> SplitExecuteAffrowsAsync(int valuesLimit, int parameterLimit, CancellationToken cancellationToken = default)
{ {
var ss = SplitSource(valuesLimit, parameterLimit); var ss = SplitSource(valuesLimit, parameterLimit);
var ret = 0; var ret = 0;
@ -28,7 +29,7 @@ namespace FreeSql.Internal.CommonProvider
if (ss.Length == 1) if (ss.Length == 1)
{ {
_batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, 1, 1)); _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, 1, 1));
ret = await this.RawExecuteAffrowsAsync(); ret = await this.RawExecuteAffrowsAsync(cancellationToken);
ClearData(); ClearData();
return ret; return ret;
} }
@ -49,7 +50,7 @@ namespace FreeSql.Internal.CommonProvider
{ {
_source = ss[a]; _source = ss[a];
_batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length)); _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length));
ret += await this.RawExecuteAffrowsAsync(); ret += await this.RawExecuteAffrowsAsync(cancellationToken);
} }
} }
else else
@ -66,7 +67,7 @@ namespace FreeSql.Internal.CommonProvider
{ {
_source = ss[a]; _source = ss[a];
_batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length)); _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length));
ret += await this.RawExecuteAffrowsAsync(); ret += await this.RawExecuteAffrowsAsync(cancellationToken);
} }
_transaction.Commit(); _transaction.Commit();
_orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, "提交", null)); _orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, "提交", null));
@ -95,7 +96,7 @@ namespace FreeSql.Internal.CommonProvider
return ret; return ret;
} }
async protected Task<long> SplitExecuteIdentityAsync(int valuesLimit, int parameterLimit) async protected Task<long> SplitExecuteIdentityAsync(int valuesLimit, int parameterLimit, CancellationToken cancellationToken = default)
{ {
var ss = SplitSource(valuesLimit, parameterLimit); var ss = SplitSource(valuesLimit, parameterLimit);
long ret = 0; long ret = 0;
@ -107,7 +108,7 @@ namespace FreeSql.Internal.CommonProvider
if (ss.Length == 1) if (ss.Length == 1)
{ {
_batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, 1, 1)); _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, 1, 1));
ret = await this.RawExecuteIdentityAsync(); ret = await this.RawExecuteIdentityAsync(cancellationToken);
ClearData(); ClearData();
return ret; return ret;
} }
@ -128,8 +129,8 @@ namespace FreeSql.Internal.CommonProvider
{ {
_source = ss[a]; _source = ss[a];
_batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length)); _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length));
if (a < ss.Length - 1) await this.RawExecuteAffrowsAsync(); if (a < ss.Length - 1) await this.RawExecuteAffrowsAsync(cancellationToken);
else ret = await this.RawExecuteIdentityAsync(); else ret = await this.RawExecuteIdentityAsync(cancellationToken);
} }
} }
else else
@ -146,8 +147,8 @@ namespace FreeSql.Internal.CommonProvider
{ {
_source = ss[a]; _source = ss[a];
_batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length)); _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length));
if (a < ss.Length - 1) await this.RawExecuteAffrowsAsync(); if (a < ss.Length - 1) await this.RawExecuteAffrowsAsync(cancellationToken);
else ret = await this.RawExecuteIdentityAsync(); else ret = await this.RawExecuteIdentityAsync(cancellationToken);
} }
_transaction.Commit(); _transaction.Commit();
_orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, "提交", null)); _orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, "提交", null));
@ -176,7 +177,7 @@ namespace FreeSql.Internal.CommonProvider
return ret; return ret;
} }
async protected Task<List<T1>> SplitExecuteInsertedAsync(int valuesLimit, int parameterLimit) async protected Task<List<T1>> SplitExecuteInsertedAsync(int valuesLimit, int parameterLimit, CancellationToken cancellationToken = default)
{ {
var ss = SplitSource(valuesLimit, parameterLimit); var ss = SplitSource(valuesLimit, parameterLimit);
var ret = new List<T1>(); var ret = new List<T1>();
@ -188,7 +189,7 @@ namespace FreeSql.Internal.CommonProvider
if (ss.Length == 1) if (ss.Length == 1)
{ {
_batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, 1, 1)); _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, 1, 1));
ret = await this.RawExecuteInsertedAsync(); ret = await this.RawExecuteInsertedAsync(cancellationToken);
ClearData(); ClearData();
return ret; return ret;
} }
@ -209,7 +210,7 @@ namespace FreeSql.Internal.CommonProvider
{ {
_source = ss[a]; _source = ss[a];
_batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length)); _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length));
ret.AddRange(await this.RawExecuteInsertedAsync()); ret.AddRange(await this.RawExecuteInsertedAsync(cancellationToken));
} }
} }
else else
@ -226,7 +227,7 @@ namespace FreeSql.Internal.CommonProvider
{ {
_source = ss[a]; _source = ss[a];
_batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length)); _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length));
ret.AddRange(await this.RawExecuteInsertedAsync()); ret.AddRange(await this.RawExecuteInsertedAsync(cancellationToken));
} }
_transaction.Commit(); _transaction.Commit();
_orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, "提交", null)); _orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, "提交", null));
@ -255,7 +256,7 @@ namespace FreeSql.Internal.CommonProvider
return ret; return ret;
} }
async protected virtual Task<int> RawExecuteAffrowsAsync() async protected virtual Task<int> RawExecuteAffrowsAsync(CancellationToken cancellationToken = default)
{ {
var sql = ToSql(); var sql = ToSql();
var before = new Aop.CurdBeforeEventArgs(_table.Type, _table, Aop.CurdType.Insert, sql, _params); var before = new Aop.CurdBeforeEventArgs(_table.Type, _table, Aop.CurdType.Insert, sql, _params);
@ -264,7 +265,7 @@ namespace FreeSql.Internal.CommonProvider
Exception exception = null; Exception exception = null;
try try
{ {
affrows = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); affrows = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -279,12 +280,12 @@ namespace FreeSql.Internal.CommonProvider
return affrows; return affrows;
} }
protected abstract Task<long> RawExecuteIdentityAsync(); protected abstract Task<long> RawExecuteIdentityAsync(CancellationToken cancellationToken = default);
protected abstract Task<List<T1>> RawExecuteInsertedAsync(); protected abstract Task<List<T1>> RawExecuteInsertedAsync(CancellationToken cancellationToken = default);
public abstract Task<int> ExecuteAffrowsAsync(); public abstract Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default);
public abstract Task<long> ExecuteIdentityAsync(); public abstract Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default);
public abstract Task<List<T1>> ExecuteInsertedAsync(); public abstract Task<List<T1>> ExecuteInsertedAsync(CancellationToken cancellationToken = default);
#endif #endif
} }
} }

27
FreeSql/Internal/CommonProvider/UpdateProviderAsync.cs
View File

@ -8,6 +8,7 @@ using System.Linq;
using System.Linq.Expressions; using System.Linq.Expressions;
using System.Reflection; using System.Reflection;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Internal.CommonProvider namespace FreeSql.Internal.CommonProvider
@ -17,14 +18,14 @@ namespace FreeSql.Internal.CommonProvider
{ {
#if net40 #if net40
#else #else
async protected Task<int> SplitExecuteAffrowsAsync(int valuesLimit, int parameterLimit) async protected Task<int> SplitExecuteAffrowsAsync(int valuesLimit, int parameterLimit, CancellationToken cancellationToken = default)
{ {
var ss = SplitSource(valuesLimit, parameterLimit); var ss = SplitSource(valuesLimit, parameterLimit);
var ret = 0; var ret = 0;
if (ss.Length <= 1) if (ss.Length <= 1)
{ {
if (_source?.Any() == true) _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, 1, 1)); if (_source?.Any() == true) _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, 1, 1));
ret = await this.RawExecuteAffrowsAsync(); ret = await this.RawExecuteAffrowsAsync(cancellationToken);
ClearData(); ClearData();
return ret; return ret;
} }
@ -45,7 +46,7 @@ namespace FreeSql.Internal.CommonProvider
{ {
_source = ss[a]; _source = ss[a];
_batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length)); _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length));
ret += await this.RawExecuteAffrowsAsync(); ret += await this.RawExecuteAffrowsAsync(cancellationToken);
} }
} }
else else
@ -62,7 +63,7 @@ namespace FreeSql.Internal.CommonProvider
{ {
_source = ss[a]; _source = ss[a];
_batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length)); _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length));
ret += await this.RawExecuteAffrowsAsync(); ret += await this.RawExecuteAffrowsAsync(cancellationToken);
} }
_transaction.Commit(); _transaction.Commit();
_orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, "提交", null)); _orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, "提交", null));
@ -90,14 +91,14 @@ namespace FreeSql.Internal.CommonProvider
ClearData(); ClearData();
return ret; return ret;
} }
async protected Task<List<T1>> SplitExecuteUpdatedAsync(int valuesLimit, int parameterLimit) async protected Task<List<T1>> SplitExecuteUpdatedAsync(int valuesLimit, int parameterLimit, CancellationToken cancellationToken = default)
{ {
var ss = SplitSource(valuesLimit, parameterLimit); var ss = SplitSource(valuesLimit, parameterLimit);
var ret = new List<T1>(); var ret = new List<T1>();
if (ss.Length <= 1) if (ss.Length <= 1)
{ {
if (_source?.Any() == true) _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, 1, 1)); if (_source?.Any() == true) _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, 1, 1));
ret = await this.RawExecuteUpdatedAsync(); ret = await this.RawExecuteUpdatedAsync(cancellationToken);
ClearData(); ClearData();
return ret; return ret;
} }
@ -118,7 +119,7 @@ namespace FreeSql.Internal.CommonProvider
{ {
_source = ss[a]; _source = ss[a];
_batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length)); _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length));
ret.AddRange(await this.RawExecuteUpdatedAsync()); ret.AddRange(await this.RawExecuteUpdatedAsync(cancellationToken));
} }
} }
else else
@ -135,7 +136,7 @@ namespace FreeSql.Internal.CommonProvider
{ {
_source = ss[a]; _source = ss[a];
_batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length)); _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length));
ret.AddRange(await this.RawExecuteUpdatedAsync()); ret.AddRange(await this.RawExecuteUpdatedAsync(cancellationToken));
} }
_transaction.Commit(); _transaction.Commit();
_orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, "提交", null)); _orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, "提交", null));
@ -164,7 +165,7 @@ namespace FreeSql.Internal.CommonProvider
return ret; return ret;
} }
async protected Task<int> RawExecuteAffrowsAsync() async protected Task<int> RawExecuteAffrowsAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
@ -175,7 +176,7 @@ namespace FreeSql.Internal.CommonProvider
Exception exception = null; Exception exception = null;
try try
{ {
affrows = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); affrows = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken);
ValidateVersionAndThrow(affrows, sql, dbParms); ValidateVersionAndThrow(affrows, sql, dbParms);
} }
catch (Exception ex) catch (Exception ex)
@ -190,10 +191,10 @@ namespace FreeSql.Internal.CommonProvider
} }
return affrows; return affrows;
} }
protected abstract Task<List<T1>> RawExecuteUpdatedAsync(); protected abstract Task<List<T1>> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default);
public abstract Task<int> ExecuteAffrowsAsync(); public abstract Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default);
public abstract Task<List<T1>> ExecuteUpdatedAsync(); public abstract Task<List<T1>> ExecuteUpdatedAsync(CancellationToken cancellationToken = default);
#endif #endif
} }
} }

21
FreeSql/Internal/Model/AdoCommandFluent.cs
View File

@ -5,6 +5,7 @@ using System.Data;
using System.Data.Common; using System.Data.Common;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Internal.Model namespace FreeSql.Internal.Model
@ -98,16 +99,16 @@ namespace FreeSql.Internal.Model
#if net40 #if net40
#else #else
public Task<int> ExecuteNonQueryAsync() => this.Ado.ExecuteNonQueryAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray()); public Task<int> ExecuteNonQueryAsync(CancellationToken cancellationToken = default) => this.Ado.ExecuteNonQueryAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray(), cancellationToken);
public Task<object> ExecuteScalarAsync() => this.Ado.ExecuteScalarAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray()); public Task<object> ExecuteScalarAsync(CancellationToken cancellationToken = default) => this.Ado.ExecuteScalarAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray(), cancellationToken);
public Task<DataTable> ExecuteDataTableAsync() => this.Ado.ExecuteDataTableAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray()); public Task<DataTable> ExecuteDataTableAsync(CancellationToken cancellationToken = default) => this.Ado.ExecuteDataTableAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray(), cancellationToken);
public Task<DataSet> ExecuteDataSetAsync() => this.Ado.ExecuteDataSetAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray()); public Task<DataSet> ExecuteDataSetAsync(CancellationToken cancellationToken = default) => this.Ado.ExecuteDataSetAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray(), cancellationToken);
public Task<object[][]> ExecuteArrayAsync() => this.Ado.ExecuteArrayAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray()); public Task<object[][]> ExecuteArrayAsync(CancellationToken cancellationToken = default) => this.Ado.ExecuteArrayAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray(), cancellationToken);
public Task<List<T>> QueryAsync<T>() => this.Ado.QueryAsync<T>(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray()); public Task<List<T>> QueryAsync<T>(CancellationToken cancellationToken = default) => this.Ado.QueryAsync<T>(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray(), cancellationToken);
public Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>() => this.Ado.QueryAsync<T1, T2>(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray()); public Task<NativeTuple<List<T1>, List<T2>>> QueryAsync<T1, T2>(CancellationToken cancellationToken = default) => this.Ado.QueryAsync<T1, T2>(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray(), cancellationToken);
public Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>() => this.Ado.QueryAsync<T1, T2, T3>(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray()); public Task<NativeTuple<List<T1>, List<T2>, List<T3>>> QueryAsync<T1, T2, T3>(CancellationToken cancellationToken = default) => this.Ado.QueryAsync<T1, T2, T3>(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray(), cancellationToken);
public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>() => this.Ado.QueryAsync<T1, T2, T3, T4>(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray()); public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>>> QueryAsync<T1, T2, T3, T4>(CancellationToken cancellationToken = default) => this.Ado.QueryAsync<T1, T2, T3, T4>(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray(), cancellationToken);
public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>() => this.Ado.QueryAsync<T1, T2, T3, T4, T5>(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray()); public Task<NativeTuple<List<T1>, List<T2>, List<T3>, List<T4>, List<T5>>> QueryAsync<T1, T2, T3, T4, T5>(CancellationToken cancellationToken = default) => this.Ado.QueryAsync<T1, T2, T3, T4, T5>(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray(), cancellationToken);
#endif #endif
} }
} }

17
Providers/FreeSql.Provider.Dameng/Curd/DamengInsert.cs
View File

@ -6,6 +6,7 @@ using System.Data;
using System.Data.Common; using System.Data.Common;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Dameng.Curd namespace FreeSql.Dameng.Curd
@ -153,11 +154,11 @@ namespace FreeSql.Dameng.Curd
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
public override Task<long> ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
public override Task<List<T1>> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<List<T1>> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
async protected override Task<long> RawExecuteIdentityAsync() async protected override Task<long> RawExecuteIdentityAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
@ -172,7 +173,7 @@ namespace FreeSql.Dameng.Curd
_orm.Aop.CurdBeforeHandler?.Invoke(this, before); _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
try try
{ {
ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -195,7 +196,7 @@ namespace FreeSql.Dameng.Curd
_orm.Aop.CurdBeforeHandler?.Invoke(this, before); _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
try try
{ {
await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken);
long.TryParse(string.Concat(identParam.Value), out ret); long.TryParse(string.Concat(identParam.Value), out ret);
} }
catch (Exception ex) catch (Exception ex)
@ -210,13 +211,13 @@ namespace FreeSql.Dameng.Curd
} }
return ret; return ret;
} }
async protected override Task<List<T1>> RawExecuteInsertedAsync() async protected override Task<List<T1>> RawExecuteInsertedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
var ret = _source.ToList(); var ret = _source.ToList();
await this.RawExecuteAffrowsAsync(); await this.RawExecuteAffrowsAsync(cancellationToken);
return ret; return ret;
} }
#endif #endif

7
Providers/FreeSql.Provider.Dameng/Curd/DamengUpdate.cs
View File

@ -4,6 +4,7 @@ using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Dameng.Curd namespace FreeSql.Dameng.Curd
@ -65,10 +66,10 @@ namespace FreeSql.Dameng.Curd
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
public override Task<List<T1>> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<List<T1>> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
protected override Task<List<T1>> RawExecuteUpdatedAsync() protected override Task<List<T1>> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default)
{ {
throw new NotImplementedException(); throw new NotImplementedException();
} }

21
Providers/FreeSql.Provider.Firebird/Curd/FirebirdInsert.cs
View File

@ -6,6 +6,7 @@ using System.Data;
using System.Data.Common; using System.Data.Common;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Firebird.Curd namespace FreeSql.Firebird.Curd
@ -123,19 +124,19 @@ namespace FreeSql.Firebird.Curd
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default)
{ {
base.NoneParameter(_source?.Count > 1); base.NoneParameter(_source?.Count > 1);
return base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); return base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
} }
public override Task<long> ExecuteIdentityAsync() public override Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default)
{ {
base.NoneParameter(_source?.Count > 1); base.NoneParameter(_source?.Count > 1);
return base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); return base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
} }
public override Task<List<T1>> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(1, 1000); public override Task<List<T1>> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(1, 1000, cancellationToken);
async protected override Task<long> RawExecuteIdentityAsync() async protected override Task<long> RawExecuteIdentityAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
@ -151,7 +152,7 @@ namespace FreeSql.Firebird.Curd
_orm.Aop.CurdBeforeHandler?.Invoke(this, before); _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
try try
{ {
ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -170,7 +171,7 @@ namespace FreeSql.Firebird.Curd
_orm.Aop.CurdBeforeHandler?.Invoke(this, before); _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
try try
{ {
long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params)), out ret); long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken)), out ret);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -184,7 +185,7 @@ namespace FreeSql.Firebird.Curd
} }
return ret; return ret;
} }
async protected override Task<List<T1>> RawExecuteInsertedAsync() async protected override Task<List<T1>> RawExecuteInsertedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
@ -206,7 +207,7 @@ namespace FreeSql.Firebird.Curd
Exception exception = null; Exception exception = null;
try try
{ {
ret = await _orm.Ado.QueryAsync<T1>(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); ret = await _orm.Ado.QueryAsync<T1>(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {

9
Providers/FreeSql.Provider.Firebird/Curd/FirebirdUpdate.cs
View File

@ -5,6 +5,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Firebird.Curd namespace FreeSql.Firebird.Curd
@ -99,10 +100,10 @@ namespace FreeSql.Firebird.Curd
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
public override Task<List<T1>> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<List<T1>> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
async protected override Task<List<T1>> RawExecuteUpdatedAsync() async protected override Task<List<T1>> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
@ -125,7 +126,7 @@ namespace FreeSql.Firebird.Curd
Exception exception = null; Exception exception = null;
try try
{ {
ret = await _orm.Ado.QueryAsync<T1>(_connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); ret = await _orm.Ado.QueryAsync<T1>(_connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken);
ValidateVersionAndThrow(ret.Count, sql, dbParms); ValidateVersionAndThrow(ret.Count, sql, dbParms);
} }
catch (Exception ex) catch (Exception ex)

17
Providers/FreeSql.Provider.KingbaseES/Curd/KingbaseESInsert.cs
View File

@ -6,6 +6,7 @@ using System.Data;
using System.Data.Common; using System.Data.Common;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.KingbaseES namespace FreeSql.KingbaseES
@ -122,11 +123,11 @@ namespace FreeSql.KingbaseES
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<long> ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<List<T1>> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<List<T1>> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
async protected override Task<long> RawExecuteIdentityAsync() async protected override Task<long> RawExecuteIdentityAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
@ -142,7 +143,7 @@ namespace FreeSql.KingbaseES
_orm.Aop.CurdBeforeHandler?.Invoke(this, before); _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
try try
{ {
ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -161,7 +162,7 @@ namespace FreeSql.KingbaseES
_orm.Aop.CurdBeforeHandler?.Invoke(this, before); _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
try try
{ {
long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params)), out ret); long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken)), out ret);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -175,7 +176,7 @@ namespace FreeSql.KingbaseES
} }
return ret; return ret;
} }
async protected override Task<List<T1>> RawExecuteInsertedAsync() async protected override Task<List<T1>> RawExecuteInsertedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
@ -197,7 +198,7 @@ namespace FreeSql.KingbaseES
Exception exception = null; Exception exception = null;
try try
{ {
ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {

9
Providers/FreeSql.Provider.KingbaseES/Curd/KingbaseESUpdate.cs
View File

@ -5,6 +5,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.KingbaseES namespace FreeSql.KingbaseES
@ -123,10 +124,10 @@ namespace FreeSql.KingbaseES
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<List<T1>> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<List<T1>> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
async protected override Task<List<T1>> RawExecuteUpdatedAsync() async protected override Task<List<T1>> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
@ -149,7 +150,7 @@ namespace FreeSql.KingbaseES
Exception exception = null; Exception exception = null;
try try
{ {
ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken);
ValidateVersionAndThrow(ret.Count, sql, dbParms); ValidateVersionAndThrow(ret.Count, sql, dbParms);
} }
catch (Exception ex) catch (Exception ex)

25
Providers/FreeSql.Provider.MsAccess/Curd/MsAccessInsert.cs
View File

@ -6,6 +6,7 @@ using System.Data;
using System.Data.Common; using System.Data.Common;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.MsAccess.Curd namespace FreeSql.MsAccess.Curd
@ -102,11 +103,11 @@ namespace FreeSql.MsAccess.Curd
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(1, 1000); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(1, 1000, cancellationToken);
public override Task<long> ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(1, 1000); public override Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(1, 1000, cancellationToken);
public override Task<List<T1>> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(1, 1000); public override Task<List<T1>> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(1, 1000, cancellationToken);
async protected override Task<int> RawExecuteAffrowsAsync() async protected override Task<int> RawExecuteAffrowsAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
var before = new Aop.CurdBeforeEventArgs(_table.Type, _table, Aop.CurdType.Insert, sql, _params); var before = new Aop.CurdBeforeEventArgs(_table.Type, _table, Aop.CurdType.Insert, sql, _params);
@ -115,7 +116,7 @@ namespace FreeSql.MsAccess.Curd
Exception exception = null; Exception exception = null;
try try
{ {
affrows = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); affrows = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -129,7 +130,7 @@ namespace FreeSql.MsAccess.Curd
} }
return affrows; return affrows;
} }
async protected override Task<long> RawExecuteIdentityAsync() async protected override Task<long> RawExecuteIdentityAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
@ -146,14 +147,14 @@ namespace FreeSql.MsAccess.Curd
using (var conn = await _orm.Ado.MasterPool.GetAsync()) using (var conn = await _orm.Ado.MasterPool.GetAsync())
{ {
_connection = conn.Value; _connection = conn.Value;
await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, "SELECT @@identity", _commandTimeout, _params)), out ret); long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, "SELECT @@identity", _commandTimeout, _params, cancellationToken)), out ret);
} }
} }
else else
{ {
await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, "SELECT @@identity", _commandTimeout, _params)), out ret); long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, "SELECT @@identity", _commandTimeout, _params, cancellationToken)), out ret);
} }
} }
catch (Exception ex) catch (Exception ex)
@ -169,13 +170,13 @@ namespace FreeSql.MsAccess.Curd
} }
return ret; return ret;
} }
async protected override Task<List<T1>> RawExecuteInsertedAsync() async protected override Task<List<T1>> RawExecuteInsertedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
var ret = _source.ToList(); var ret = _source.ToList();
await this.RawExecuteAffrowsAsync(); await this.RawExecuteAffrowsAsync(cancellationToken);
return ret; return ret;
} }
#endif #endif

7
Providers/FreeSql.Provider.MsAccess/Curd/MsAccessUpdate.cs
View File

@ -5,6 +5,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.MsAccess.Curd namespace FreeSql.MsAccess.Curd
@ -68,10 +69,10 @@ namespace FreeSql.MsAccess.Curd
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(1, 1000); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(1, 1000, cancellationToken);
public override Task<List<T1>> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(1, 1000); public override Task<List<T1>> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(1, 1000, cancellationToken);
protected override Task<List<T1>> RawExecuteUpdatedAsync() protected override Task<List<T1>> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default)
{ {
throw new NotImplementedException(); throw new NotImplementedException();
} }

15
Providers/FreeSql.Provider.MySql/Curd/MySqlInsert.cs
View File

@ -5,6 +5,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Data.Common; using System.Data.Common;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.MySql.Curd namespace FreeSql.MySql.Curd
@ -106,11 +107,11 @@ namespace FreeSql.MySql.Curd
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<long> ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<List<T1>> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<List<T1>> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
async protected override Task<long> RawExecuteIdentityAsync() async protected override Task<long> RawExecuteIdentityAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
@ -122,7 +123,7 @@ namespace FreeSql.MySql.Curd
Exception exception = null; Exception exception = null;
try try
{ {
ret = long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params)), out var trylng) ? trylng : 0; ret = long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken)), out var trylng) ? trylng : 0;
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -136,7 +137,7 @@ namespace FreeSql.MySql.Curd
} }
return ret; return ret;
} }
async protected override Task<List<T1>> RawExecuteInsertedAsync() async protected override Task<List<T1>> RawExecuteInsertedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
@ -158,7 +159,7 @@ namespace FreeSql.MySql.Curd
Exception exception = null; Exception exception = null;
try try
{ {
ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {

9
Providers/FreeSql.Provider.MySql/Curd/MySqlUpdate.cs
View File

@ -5,6 +5,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.MySql.Curd namespace FreeSql.MySql.Curd
@ -106,10 +107,10 @@ namespace FreeSql.MySql.Curd
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<List<T1>> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<List<T1>> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
async protected override Task<List<T1>> RawExecuteUpdatedAsync() async protected override Task<List<T1>> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
@ -132,7 +133,7 @@ namespace FreeSql.MySql.Curd
Exception exception = null; Exception exception = null;
try try
{ {
ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken);
ValidateVersionAndThrow(ret.Count, sql, dbParms); ValidateVersionAndThrow(ret.Count, sql, dbParms);
} }
catch (Exception ex) catch (Exception ex)

17
Providers/FreeSql.Provider.Odbc/Dameng/Curd/OdbcDamengInsert.cs
View File

@ -6,6 +6,7 @@ using System.Data;
using System.Data.Common; using System.Data.Common;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Odbc.Dameng namespace FreeSql.Odbc.Dameng
@ -153,11 +154,11 @@ namespace FreeSql.Odbc.Dameng
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
public override Task<long> ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
public override Task<List<T1>> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<List<T1>> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
async protected override Task<long> RawExecuteIdentityAsync() async protected override Task<long> RawExecuteIdentityAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
@ -172,7 +173,7 @@ namespace FreeSql.Odbc.Dameng
_orm.Aop.CurdBeforeHandler?.Invoke(this, before); _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
try try
{ {
ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -195,7 +196,7 @@ namespace FreeSql.Odbc.Dameng
_orm.Aop.CurdBeforeHandler?.Invoke(this, before); _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
try try
{ {
await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken);
long.TryParse(string.Concat(identParam.Value), out ret); long.TryParse(string.Concat(identParam.Value), out ret);
} }
catch (Exception ex) catch (Exception ex)
@ -210,13 +211,13 @@ namespace FreeSql.Odbc.Dameng
} }
return ret; return ret;
} }
async protected override Task<List<T1>> RawExecuteInsertedAsync() async protected override Task<List<T1>> RawExecuteInsertedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
var ret = _source.ToList(); var ret = _source.ToList();
await this.RawExecuteAffrowsAsync(); await this.RawExecuteAffrowsAsync(cancellationToken);
return ret; return ret;
} }
#endif #endif

7
Providers/FreeSql.Provider.Odbc/Dameng/Curd/OdbcDamengUpdate.cs
View File

@ -5,6 +5,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Odbc.Dameng namespace FreeSql.Odbc.Dameng
@ -66,10 +67,10 @@ namespace FreeSql.Odbc.Dameng
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
public override Task<List<T1>> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<List<T1>> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
protected override Task<List<T1>> RawExecuteUpdatedAsync() protected override Task<List<T1>> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default)
{ {
throw new NotImplementedException(); throw new NotImplementedException();
} }

15
Providers/FreeSql.Provider.Odbc/Default/Curd/OdbcInsert.cs
View File

@ -5,6 +5,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Data.Common; using System.Data.Common;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Odbc.Default namespace FreeSql.Odbc.Default
@ -65,11 +66,11 @@ namespace FreeSql.Odbc.Default
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : _utils.Adapter.InsertBatchSplitLimit, _batchParameterLimit > 0 ? _batchParameterLimit : 255); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : _utils.Adapter.InsertBatchSplitLimit, _batchParameterLimit > 0 ? _batchParameterLimit : 255, cancellationToken);
public override Task<long> ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : _utils.Adapter.InsertBatchSplitLimit, _batchParameterLimit > 0 ? _batchParameterLimit : 255); public override Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : _utils.Adapter.InsertBatchSplitLimit, _batchParameterLimit > 0 ? _batchParameterLimit : 255, cancellationToken);
public override Task<List<T1>> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : _utils.Adapter.InsertBatchSplitLimit, _batchParameterLimit > 0 ? _batchParameterLimit : 255); public override Task<List<T1>> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : _utils.Adapter.InsertBatchSplitLimit, _batchParameterLimit > 0 ? _batchParameterLimit : 255, cancellationToken);
async protected override Task<long> RawExecuteIdentityAsync() async protected override Task<long> RawExecuteIdentityAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
@ -88,8 +89,8 @@ namespace FreeSql.Odbc.Default
poolConn = _orm.Ado.MasterPool.Get(); poolConn = _orm.Ado.MasterPool.Get();
conn = poolConn.Value; conn = poolConn.Value;
} }
await _orm.Ado.ExecuteNonQueryAsync(conn, _transaction, CommandType.Text, sql, _commandTimeout, _params); await _orm.Ado.ExecuteNonQueryAsync(conn, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
ret = long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(conn, _transaction, CommandType.Text, $" {_utils.Adapter.InsertAfterGetIdentitySql}", _commandTimeout)), out var trylng) ? trylng : 0; ret = long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(conn, _transaction, CommandType.Text, $" {_utils.Adapter.InsertAfterGetIdentitySql}", _commandTimeout, null, cancellationToken)), out var trylng) ? trylng : 0;
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -106,7 +107,7 @@ namespace FreeSql.Odbc.Default
} }
return ret; return ret;
} }
protected override Task<List<T1>> RawExecuteInsertedAsync() => throw new NotImplementedException("FreeSql.Odbc.Default 未实现该功能"); protected override Task<List<T1>> RawExecuteInsertedAsync(CancellationToken cancellationToken = default) => throw new NotImplementedException("FreeSql.Odbc.Default 未实现该功能");
#endif #endif
} }
} }

7
Providers/FreeSql.Provider.Odbc/Default/Curd/OdbcUpdate.cs
View File

@ -5,6 +5,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Odbc.Default namespace FreeSql.Odbc.Default
@ -61,10 +62,10 @@ namespace FreeSql.Odbc.Default
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : _utils.Adapter.UpdateBatchSplitLimit, _batchParameterLimit > 0 ? _batchParameterLimit : 255); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : _utils.Adapter.UpdateBatchSplitLimit, _batchParameterLimit > 0 ? _batchParameterLimit : 255, cancellationToken);
public override Task<List<T1>> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : _utils.Adapter.UpdateBatchSplitLimit, _batchParameterLimit > 0 ? _batchParameterLimit : 255); public override Task<List<T1>> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : _utils.Adapter.UpdateBatchSplitLimit, _batchParameterLimit > 0 ? _batchParameterLimit : 255, cancellationToken);
protected override Task<List<T1>> RawExecuteUpdatedAsync() => throw new NotImplementedException("FreeSql.Odbc.Default 未实现该功能"); protected override Task<List<T1>> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default) => throw new NotImplementedException("FreeSql.Odbc.Default 未实现该功能");
#endif #endif
} }
} }

17
Providers/FreeSql.Provider.Odbc/KingbaseES/Curd/OdbcKingbaseESInsert.cs
View File

@ -6,6 +6,7 @@ using System.Data;
using System.Data.Common; using System.Data.Common;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Odbc.KingbaseES namespace FreeSql.Odbc.KingbaseES
@ -122,11 +123,11 @@ namespace FreeSql.Odbc.KingbaseES
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<long> ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<List<T1>> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<List<T1>> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
async protected override Task<long> RawExecuteIdentityAsync() async protected override Task<long> RawExecuteIdentityAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
@ -142,7 +143,7 @@ namespace FreeSql.Odbc.KingbaseES
_orm.Aop.CurdBeforeHandler?.Invoke(this, before); _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
try try
{ {
ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -161,7 +162,7 @@ namespace FreeSql.Odbc.KingbaseES
_orm.Aop.CurdBeforeHandler?.Invoke(this, before); _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
try try
{ {
long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params)), out ret); long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken)), out ret);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -175,7 +176,7 @@ namespace FreeSql.Odbc.KingbaseES
} }
return ret; return ret;
} }
async protected override Task<List<T1>> RawExecuteInsertedAsync() async protected override Task<List<T1>> RawExecuteInsertedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
@ -197,7 +198,7 @@ namespace FreeSql.Odbc.KingbaseES
Exception exception = null; Exception exception = null;
try try
{ {
ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {

9
Providers/FreeSql.Provider.Odbc/KingbaseES/Curd/OdbcKingbaseESUpdate.cs
View File

@ -5,6 +5,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Odbc.KingbaseES namespace FreeSql.Odbc.KingbaseES
@ -123,10 +124,10 @@ namespace FreeSql.Odbc.KingbaseES
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<List<T1>> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<List<T1>> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
async protected override Task<List<T1>> RawExecuteUpdatedAsync() async protected override Task<List<T1>> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
@ -149,7 +150,7 @@ namespace FreeSql.Odbc.KingbaseES
Exception exception = null; Exception exception = null;
try try
{ {
ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken);
ValidateVersionAndThrow(ret.Count, sql, dbParms); ValidateVersionAndThrow(ret.Count, sql, dbParms);
} }
catch (Exception ex) catch (Exception ex)

17
Providers/FreeSql.Provider.Odbc/MySql/Curd/OdbcMySqlInsert.cs
View File

@ -6,6 +6,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Data.Common; using System.Data.Common;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Odbc.MySql namespace FreeSql.Odbc.MySql
@ -118,11 +119,11 @@ namespace FreeSql.Odbc.MySql
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<long> ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<List<T1>> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<List<T1>> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
async protected override Task<long> RawExecuteIdentityAsync() async protected override Task<long> RawExecuteIdentityAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
@ -141,8 +142,8 @@ namespace FreeSql.Odbc.MySql
poolConn = _orm.Ado.MasterPool.Get(); poolConn = _orm.Ado.MasterPool.Get();
conn = poolConn.Value; conn = poolConn.Value;
} }
await _orm.Ado.ExecuteNonQueryAsync(conn, _transaction, CommandType.Text, sql, _commandTimeout, _params); await _orm.Ado.ExecuteNonQueryAsync(conn, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
ret = long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(conn, _transaction, CommandType.Text, " SELECT LAST_INSERT_ID()", _commandTimeout)), out var trylng) ? trylng : 0; ret = long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(conn, _transaction, CommandType.Text, " SELECT LAST_INSERT_ID()", _commandTimeout, null, cancellationToken)), out var trylng) ? trylng : 0;
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -159,7 +160,7 @@ namespace FreeSql.Odbc.MySql
} }
return ret; return ret;
} }
async protected override Task<List<T1>> RawExecuteInsertedAsync() async protected override Task<List<T1>> RawExecuteInsertedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
@ -181,7 +182,7 @@ namespace FreeSql.Odbc.MySql
Exception exception = null; Exception exception = null;
try try
{ {
ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {

9
Providers/FreeSql.Provider.Odbc/MySql/Curd/OdbcMySqlUpdate.cs
View File

@ -5,6 +5,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Odbc.MySql namespace FreeSql.Odbc.MySql
@ -106,10 +107,10 @@ namespace FreeSql.Odbc.MySql
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<List<T1>> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<List<T1>> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
async protected override Task<List<T1>> RawExecuteUpdatedAsync() async protected override Task<List<T1>> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
@ -132,7 +133,7 @@ namespace FreeSql.Odbc.MySql
Exception exception = null; Exception exception = null;
try try
{ {
ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken);
ValidateVersionAndThrow(ret.Count, sql, dbParms); ValidateVersionAndThrow(ret.Count, sql, dbParms);
} }
catch (Exception ex) catch (Exception ex)

17
Providers/FreeSql.Provider.Odbc/Oracle/Curd/OdbcOracleInsert.cs
View File

@ -6,6 +6,7 @@ using System.Data;
using System.Data.Common; using System.Data.Common;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Odbc.Oracle namespace FreeSql.Odbc.Oracle
@ -153,11 +154,11 @@ namespace FreeSql.Odbc.Oracle
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
public override Task<long> ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
public override Task<List<T1>> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<List<T1>> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
async protected override Task<long> RawExecuteIdentityAsync() async protected override Task<long> RawExecuteIdentityAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
@ -172,7 +173,7 @@ namespace FreeSql.Odbc.Oracle
_orm.Aop.CurdBeforeHandler?.Invoke(this, before); _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
try try
{ {
ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -195,7 +196,7 @@ namespace FreeSql.Odbc.Oracle
_orm.Aop.CurdBeforeHandler?.Invoke(this, before); _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
try try
{ {
await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken);
long.TryParse(string.Concat(identParam.Value), out ret); long.TryParse(string.Concat(identParam.Value), out ret);
} }
catch (Exception ex) catch (Exception ex)
@ -210,13 +211,13 @@ namespace FreeSql.Odbc.Oracle
} }
return ret; return ret;
} }
async protected override Task<List<T1>> RawExecuteInsertedAsync() async protected override Task<List<T1>> RawExecuteInsertedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
var ret = _source.ToList(); var ret = _source.ToList();
await this.RawExecuteAffrowsAsync(); await this.RawExecuteAffrowsAsync(cancellationToken);
return ret; return ret;
} }
#endif #endif

7
Providers/FreeSql.Provider.Odbc/Oracle/Curd/OdbcOracleUpdate.cs
View File

@ -5,6 +5,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Odbc.Oracle namespace FreeSql.Odbc.Oracle
@ -68,10 +69,10 @@ namespace FreeSql.Odbc.Oracle
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
public override Task<List<T1>> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<List<T1>> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
protected override Task<List<T1>> RawExecuteUpdatedAsync() protected override Task<List<T1>> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default)
{ {
throw new NotImplementedException(); throw new NotImplementedException();
} }

17
Providers/FreeSql.Provider.Odbc/PostgreSQL/Curd/OdbcPostgreSQLInsert.cs
View File

@ -6,6 +6,7 @@ using System.Data;
using System.Data.Common; using System.Data.Common;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Odbc.PostgreSQL namespace FreeSql.Odbc.PostgreSQL
@ -122,11 +123,11 @@ namespace FreeSql.Odbc.PostgreSQL
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<long> ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<List<T1>> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<List<T1>> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
async protected override Task<long> RawExecuteIdentityAsync() async protected override Task<long> RawExecuteIdentityAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
@ -142,7 +143,7 @@ namespace FreeSql.Odbc.PostgreSQL
_orm.Aop.CurdBeforeHandler?.Invoke(this, before); _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
try try
{ {
ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -161,7 +162,7 @@ namespace FreeSql.Odbc.PostgreSQL
_orm.Aop.CurdBeforeHandler?.Invoke(this, before); _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
try try
{ {
long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params)), out ret); long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken)), out ret);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -175,7 +176,7 @@ namespace FreeSql.Odbc.PostgreSQL
} }
return ret; return ret;
} }
async protected override Task<List<T1>> RawExecuteInsertedAsync() async protected override Task<List<T1>> RawExecuteInsertedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
@ -197,7 +198,7 @@ namespace FreeSql.Odbc.PostgreSQL
Exception exception = null; Exception exception = null;
try try
{ {
ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {

9
Providers/FreeSql.Provider.Odbc/PostgreSQL/Curd/OdbcPostgreSQLUpdate.cs
View File

@ -5,6 +5,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Odbc.PostgreSQL namespace FreeSql.Odbc.PostgreSQL
@ -123,10 +124,10 @@ namespace FreeSql.Odbc.PostgreSQL
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<List<T1>> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<List<T1>> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
async protected override Task<List<T1>> RawExecuteUpdatedAsync() async protected override Task<List<T1>> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
@ -149,7 +150,7 @@ namespace FreeSql.Odbc.PostgreSQL
Exception exception = null; Exception exception = null;
try try
{ {
ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken);
ValidateVersionAndThrow(ret.Count, sql, dbParms); ValidateVersionAndThrow(ret.Count, sql, dbParms);
} }
catch (Exception ex) catch (Exception ex)

15
Providers/FreeSql.Provider.Odbc/SqlServer/Curd/OdbcSqlServerInsert.cs
View File

@ -3,6 +3,7 @@ using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Data; using System.Data;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Odbc.SqlServer namespace FreeSql.Odbc.SqlServer
@ -104,11 +105,11 @@ namespace FreeSql.Odbc.SqlServer
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100, cancellationToken);
public override Task<long> ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100); public override Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100, cancellationToken);
public override Task<List<T1>> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100); public override Task<List<T1>> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100, cancellationToken);
async protected override Task<long> RawExecuteIdentityAsync() async protected override Task<long> RawExecuteIdentityAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
@ -120,7 +121,7 @@ namespace FreeSql.Odbc.SqlServer
Exception exception = null; Exception exception = null;
try try
{ {
long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params)), out ret); long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken)), out ret);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -134,7 +135,7 @@ namespace FreeSql.Odbc.SqlServer
} }
return ret; return ret;
} }
async protected override Task<List<T1>> RawExecuteInsertedAsync() async protected override Task<List<T1>> RawExecuteInsertedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
@ -171,7 +172,7 @@ namespace FreeSql.Odbc.SqlServer
Exception exception = null; Exception exception = null;
try try
{ {
ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {

9
Providers/FreeSql.Provider.Odbc/SqlServer/Curd/OdbcSqlServerUpdate.cs
View File

@ -5,6 +5,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Odbc.SqlServer namespace FreeSql.Odbc.SqlServer
@ -102,10 +103,10 @@ namespace FreeSql.Odbc.SqlServer
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 2100); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 2100, cancellationToken);
public override Task<List<T1>> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 2100); public override Task<List<T1>> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 2100, cancellationToken);
async protected override Task<List<T1>> RawExecuteUpdatedAsync() async protected override Task<List<T1>> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
@ -133,7 +134,7 @@ namespace FreeSql.Odbc.SqlServer
Exception exception = null; Exception exception = null;
try try
{ {
ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken);
ValidateVersionAndThrow(ret.Count, sql, dbParms); ValidateVersionAndThrow(ret.Count, sql, dbParms);
} }
catch (Exception ex) catch (Exception ex)

17
Providers/FreeSql.Provider.Oracle/Curd/OracleInsert.cs
View File

@ -7,6 +7,7 @@ using System.Data;
using System.Data.Common; using System.Data.Common;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Oracle.Curd namespace FreeSql.Oracle.Curd
@ -226,11 +227,11 @@ namespace FreeSql.Oracle.Curd
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
public override Task<long> ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
public override Task<List<T1>> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<List<T1>> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
async protected override Task<long> RawExecuteIdentityAsync() async protected override Task<long> RawExecuteIdentityAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
@ -245,7 +246,7 @@ namespace FreeSql.Oracle.Curd
_orm.Aop.CurdBeforeHandler?.Invoke(this, before); _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
try try
{ {
ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -268,7 +269,7 @@ namespace FreeSql.Oracle.Curd
_orm.Aop.CurdBeforeHandler?.Invoke(this, before); _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
try try
{ {
await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken);
long.TryParse(string.Concat(identParam.Value), out ret); long.TryParse(string.Concat(identParam.Value), out ret);
} }
catch (Exception ex) catch (Exception ex)
@ -283,13 +284,13 @@ namespace FreeSql.Oracle.Curd
} }
return ret; return ret;
} }
async protected override Task<List<T1>> RawExecuteInsertedAsync() async protected override Task<List<T1>> RawExecuteInsertedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
var ret = _source.ToList(); var ret = _source.ToList();
await this.RawExecuteAffrowsAsync(); await this.RawExecuteAffrowsAsync(cancellationToken);
return ret; return ret;
} }
#endif #endif

7
Providers/FreeSql.Provider.Oracle/Curd/OracleUpdate.cs
View File

@ -5,6 +5,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Oracle.Curd namespace FreeSql.Oracle.Curd
@ -68,10 +69,10 @@ namespace FreeSql.Oracle.Curd
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
public override Task<List<T1>> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<List<T1>> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
protected override Task<List<T1>> RawExecuteUpdatedAsync() protected override Task<List<T1>> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default)
{ {
throw new NotImplementedException(); throw new NotImplementedException();
} }

17
Providers/FreeSql.Provider.PostgreSQL/Curd/PostgreSQLInsert.cs
View File

@ -6,6 +6,7 @@ using System.Data;
using System.Data.Common; using System.Data.Common;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.PostgreSQL.Curd namespace FreeSql.PostgreSQL.Curd
@ -122,11 +123,11 @@ namespace FreeSql.PostgreSQL.Curd
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<long> ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<List<T1>> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<List<T1>> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
async protected override Task<long> RawExecuteIdentityAsync() async protected override Task<long> RawExecuteIdentityAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
@ -142,7 +143,7 @@ namespace FreeSql.PostgreSQL.Curd
_orm.Aop.CurdBeforeHandler?.Invoke(this, before); _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
try try
{ {
ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -161,7 +162,7 @@ namespace FreeSql.PostgreSQL.Curd
_orm.Aop.CurdBeforeHandler?.Invoke(this, before); _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
try try
{ {
long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params)), out ret); long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken)), out ret);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -175,7 +176,7 @@ namespace FreeSql.PostgreSQL.Curd
} }
return ret; return ret;
} }
async protected override Task<List<T1>> RawExecuteInsertedAsync() async protected override Task<List<T1>> RawExecuteInsertedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
@ -197,7 +198,7 @@ namespace FreeSql.PostgreSQL.Curd
Exception exception = null; Exception exception = null;
try try
{ {
ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {

9
Providers/FreeSql.Provider.PostgreSQL/Curd/PostgreSQLUpdate.cs
View File

@ -5,6 +5,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.PostgreSQL.Curd namespace FreeSql.PostgreSQL.Curd
@ -123,10 +124,10 @@ namespace FreeSql.PostgreSQL.Curd
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<List<T1>> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<List<T1>> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
async protected override Task<List<T1>> RawExecuteUpdatedAsync() async protected override Task<List<T1>> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
@ -149,7 +150,7 @@ namespace FreeSql.PostgreSQL.Curd
Exception exception = null; Exception exception = null;
try try
{ {
ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken);
ValidateVersionAndThrow(ret.Count, sql, dbParms); ValidateVersionAndThrow(ret.Count, sql, dbParms);
} }
catch (Exception ex) catch (Exception ex)

17
Providers/FreeSql.Provider.ShenTong/Curd/ShenTongInsert.cs
View File

@ -6,6 +6,7 @@ using System.Data;
using System.Data.Common; using System.Data.Common;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.ShenTong.Curd namespace FreeSql.ShenTong.Curd
@ -122,11 +123,11 @@ namespace FreeSql.ShenTong.Curd
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<long> ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<List<T1>> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<List<T1>> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
async protected override Task<long> RawExecuteIdentityAsync() async protected override Task<long> RawExecuteIdentityAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
@ -142,7 +143,7 @@ namespace FreeSql.ShenTong.Curd
_orm.Aop.CurdBeforeHandler?.Invoke(this, before); _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
try try
{ {
ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -161,7 +162,7 @@ namespace FreeSql.ShenTong.Curd
_orm.Aop.CurdBeforeHandler?.Invoke(this, before); _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
try try
{ {
long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params)), out ret); long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken)), out ret);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -175,7 +176,7 @@ namespace FreeSql.ShenTong.Curd
} }
return ret; return ret;
} }
async protected override Task<List<T1>> RawExecuteInsertedAsync() async protected override Task<List<T1>> RawExecuteInsertedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
@ -197,7 +198,7 @@ namespace FreeSql.ShenTong.Curd
Exception exception = null; Exception exception = null;
try try
{ {
ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {

9
Providers/FreeSql.Provider.ShenTong/Curd/ShenTongUpdate.cs
View File

@ -6,6 +6,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.ShenTong.Curd namespace FreeSql.ShenTong.Curd
@ -124,10 +125,10 @@ namespace FreeSql.ShenTong.Curd
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
public override Task<List<T1>> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); public override Task<List<T1>> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken);
async protected override Task<List<T1>> RawExecuteUpdatedAsync() async protected override Task<List<T1>> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
@ -150,7 +151,7 @@ namespace FreeSql.ShenTong.Curd
Exception exception = null; Exception exception = null;
try try
{ {
ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken);
ValidateVersionAndThrow(ret.Count, sql, dbParms); ValidateVersionAndThrow(ret.Count, sql, dbParms);
} }
catch (Exception ex) catch (Exception ex)

15
Providers/FreeSql.Provider.SqlServer/Curd/SqlServerInsert.cs
View File

@ -4,6 +4,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Data.Common; using System.Data.Common;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.SqlServer.Curd namespace FreeSql.SqlServer.Curd
@ -109,11 +110,11 @@ namespace FreeSql.SqlServer.Curd
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100, cancellationToken);
public override Task<long> ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100); public override Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100, cancellationToken);
public override Task<List<T1>> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100); public override Task<List<T1>> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100, cancellationToken);
async protected override Task<long> RawExecuteIdentityAsync() async protected override Task<long> RawExecuteIdentityAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
@ -125,7 +126,7 @@ namespace FreeSql.SqlServer.Curd
Exception exception = null; Exception exception = null;
try try
{ {
long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params)), out ret); long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken)), out ret);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -139,7 +140,7 @@ namespace FreeSql.SqlServer.Curd
} }
return ret; return ret;
} }
async protected override Task<List<T1>> RawExecuteInsertedAsync() async protected override Task<List<T1>> RawExecuteInsertedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
@ -176,7 +177,7 @@ namespace FreeSql.SqlServer.Curd
Exception exception = null; Exception exception = null;
try try
{ {
ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
} }
catch (Exception ex) catch (Exception ex)
{ {

9
Providers/FreeSql.Provider.SqlServer/Curd/SqlServerUpdate.cs
View File

@ -5,6 +5,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.SqlServer.Curd namespace FreeSql.SqlServer.Curd
@ -103,10 +104,10 @@ namespace FreeSql.SqlServer.Curd
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 2100); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 2100, cancellationToken);
public override Task<List<T1>> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 2100); public override Task<List<T1>> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 2100, cancellationToken);
async protected override Task<List<T1>> RawExecuteUpdatedAsync() async protected override Task<List<T1>> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
@ -134,7 +135,7 @@ namespace FreeSql.SqlServer.Curd
Exception exception = null; Exception exception = null;
try try
{ {
ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken);
ValidateVersionAndThrow(ret.Count, sql, dbParms); ValidateVersionAndThrow(ret.Count, sql, dbParms);
} }
catch (Exception ex) catch (Exception ex)

15
Providers/FreeSql.Provider.Sqlite/Curd/SqliteInsert.cs
View File

@ -4,6 +4,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Sqlite.Curd namespace FreeSql.Sqlite.Curd
@ -59,11 +60,11 @@ namespace FreeSql.Sqlite.Curd
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
public override Task<long> ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
public override Task<List<T1>> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<List<T1>> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
async protected override Task<long> RawExecuteIdentityAsync() async protected override Task<long> RawExecuteIdentityAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0; if (string.IsNullOrEmpty(sql)) return 0;
@ -75,7 +76,7 @@ namespace FreeSql.Sqlite.Curd
Exception exception = null; Exception exception = null;
try try
{ {
long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params)), out ret); long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken)), out ret);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -89,13 +90,13 @@ namespace FreeSql.Sqlite.Curd
} }
return ret; return ret;
} }
async protected override Task<List<T1>> RawExecuteInsertedAsync() async protected override Task<List<T1>> RawExecuteInsertedAsync(CancellationToken cancellationToken = default)
{ {
var sql = this.ToSql(); var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return new List<T1>(); if (string.IsNullOrEmpty(sql)) return new List<T1>();
var ret = _source.ToList(); var ret = _source.ToList();
await this.RawExecuteAffrowsAsync(); await this.RawExecuteAffrowsAsync(cancellationToken);
return ret; return ret;
} }
#endif #endif

7
Providers/FreeSql.Provider.Sqlite/Curd/SqliteUpdate.cs
View File

@ -5,6 +5,7 @@ using System.Collections.Generic;
using System.Data; using System.Data;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace FreeSql.Sqlite.Curd namespace FreeSql.Sqlite.Curd
@ -66,10 +67,10 @@ namespace FreeSql.Sqlite.Curd
#if net40 #if net40
#else #else
public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
public override Task<List<T1>> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); public override Task<List<T1>> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken);
protected override Task<List<T1>> RawExecuteUpdatedAsync() protected override Task<List<T1>> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default)
{ {
throw new NotImplementedException(); throw new NotImplementedException();
} }