From 8bbb7329f979ea8b976c58667140f084cb822c25 Mon Sep 17 00:00:00 2001 From: 2881099 <2881099@qq.com> Date: Thu, 12 Nov 2020 06:35:29 +0800 Subject: [PATCH] =?UTF-8?q?-=20=E5=A2=9E=E5=8A=A0=20Async=20CancellationTo?= =?UTF-8?q?ken=20IInsert/IUdate/IInsertOrUpdate=EF=BC=9B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- FreeSql.DbContext/FreeSql.DbContext.xml | 16 ++ FreeSql/FreeSql.xml | 34 ++-- FreeSql/Interface/Curd/IInsert.cs | 7 +- FreeSql/Interface/Curd/IInsertOrUpdate.cs | 3 +- FreeSql/Interface/Curd/IUpdate.cs | 5 +- FreeSql/Interface/IAdo.cs | 137 ++++++------- .../AdoProvider/AdoProviderAsync.cs | 187 +++++++++--------- .../CommonProvider/InsertOrUpdateProvider.cs | 15 +- .../CommonProvider/InsertProviderAsync.cs | 43 ++-- .../CommonProvider/UpdateProviderAsync.cs | 27 +-- FreeSql/Internal/Model/AdoCommandFluent.cs | 21 +- .../Curd/DamengInsert.cs | 17 +- .../Curd/DamengUpdate.cs | 7 +- .../Curd/FirebirdInsert.cs | 21 +- .../Curd/FirebirdUpdate.cs | 9 +- .../Curd/KingbaseESInsert.cs | 17 +- .../Curd/KingbaseESUpdate.cs | 9 +- .../Curd/MsAccessInsert.cs | 25 +-- .../Curd/MsAccessUpdate.cs | 7 +- .../Curd/MySqlInsert.cs | 15 +- .../Curd/MySqlUpdate.cs | 9 +- .../Dameng/Curd/OdbcDamengInsert.cs | 17 +- .../Dameng/Curd/OdbcDamengUpdate.cs | 7 +- .../Default/Curd/OdbcInsert.cs | 15 +- .../Default/Curd/OdbcUpdate.cs | 7 +- .../KingbaseES/Curd/OdbcKingbaseESInsert.cs | 17 +- .../KingbaseES/Curd/OdbcKingbaseESUpdate.cs | 9 +- .../MySql/Curd/OdbcMySqlInsert.cs | 17 +- .../MySql/Curd/OdbcMySqlUpdate.cs | 9 +- .../Oracle/Curd/OdbcOracleInsert.cs | 17 +- .../Oracle/Curd/OdbcOracleUpdate.cs | 7 +- .../PostgreSQL/Curd/OdbcPostgreSQLInsert.cs | 17 +- .../PostgreSQL/Curd/OdbcPostgreSQLUpdate.cs | 9 +- .../SqlServer/Curd/OdbcSqlServerInsert.cs | 15 +- .../SqlServer/Curd/OdbcSqlServerUpdate.cs | 9 +- .../Curd/OracleInsert.cs | 17 +- .../Curd/OracleUpdate.cs | 7 +- .../Curd/PostgreSQLInsert.cs | 17 +- .../Curd/PostgreSQLUpdate.cs | 9 +- .../Curd/ShenTongInsert.cs | 17 +- .../Curd/ShenTongUpdate.cs | 9 +- .../Curd/SqlServerInsert.cs | 15 +- .../Curd/SqlServerUpdate.cs | 9 +- .../Curd/SqliteInsert.cs | 15 +- .../Curd/SqliteUpdate.cs | 7 +- 45 files changed, 492 insertions(+), 433 deletions(-) diff --git a/FreeSql.DbContext/FreeSql.DbContext.xml b/FreeSql.DbContext/FreeSql.DbContext.xml index b3c14870..2d6d3409 100644 --- a/FreeSql.DbContext/FreeSql.DbContext.xml +++ b/FreeSql.DbContext/FreeSql.DbContext.xml @@ -130,6 +130,13 @@ 清空状态数据 + + + 根据 lambda 条件删除数据 + + + + 添加 @@ -502,5 +509,14 @@ + + + 批量注入 Repository，可以参考代码自行调整 + + + + + + diff --git a/FreeSql/FreeSql.xml b/FreeSql/FreeSql.xml index 3d1bfc1b..751d06c0 100644 --- a/FreeSql/FreeSql.xml +++ b/FreeSql/FreeSql.xml @@ -3013,7 +3013,7 @@ - + 测试数据库是否连接正确，本方法执行如下命令： MySql/SqlServer/PostgreSQL/达梦/人大金仓/神通: SELECT 1 @@ -3022,7 +3022,7 @@ 命令超时设置(秒) true: 成功, false: 失败 - + 查询，若使用读写分离，查询【从库】条件cmdText.StartsWith("SELECT ")，否则查询【主库】 @@ -3031,7 +3031,7 @@ - + 查询，ExecuteReaderAsync(dr => {}, "select * from user where age > ?age", new { age = 25 }) 提示：parms 参数还可以传 Dictionary<string, object> @@ -3039,14 +3039,14 @@ - + 查询 - + 查询，ExecuteArrayAsync("select * from user where age > ?age", new { age = 25 }) 提示：parms 参数还可以传 Dictionary<string, object> @@ -3055,14 +3055,14 @@ - + 查询 - + 查询，ExecuteDataSetAsync("select * from user where age > ?age; select 2", new { age = 25 }) 提示：parms 参数还可以传 Dictionary<string, object> @@ -3071,14 +3071,14 @@ - + 查询 - + 查询，ExecuteDataTableAsync("select * from user where age > ?age", new { age = 25 }) 提示：parms 参数还可以传 Dictionary<string, object> @@ -3087,7 +3087,7 @@ - + 在【主库】执行 @@ -3095,7 +3095,7 @@ - + 在【主库】执行，ExecuteNonQueryAsync("delete from user where age > ?age", new { age = 25 }) 提示：parms 参数还可以传 Dictionary<string, object> @@ -3104,7 +3104,7 @@ - + 在【主库】执行 @@ -3112,7 +3112,7 @@ - + 在【主库】执行，ExecuteScalarAsync("select 1 from user where age > ?age", new { age = 25 }) 提示：parms 参数还可以传 Dictionary<string, object> @@ -3121,7 +3121,7 @@ - + 执行SQL返回对象集合，QueryAsync<User>("select * from user where age > ?age", new SqlParameter { ParameterName = "age", Value = 25 }) @@ -3131,7 +3131,7 @@ - + 执行SQL返回对象集合，QueryAsync<User>("select * from user where age > ?age", new { age = 25 }) 提示：parms 参数还可以传 Dictionary<string, object> @@ -3141,7 +3141,7 @@ - + 执行SQL返回对象集合，Query<User>("select * from user where age > ?age; select * from address", new SqlParameter { ParameterName = "age", Value = 25 }) @@ -3151,7 +3151,7 @@ - + 执行SQL返回对象集合，Query<User, Address>("select * from user where age > ?age; select * from address", new { age = 25 }) 提示：parms 参数还可以传 Dictionary<string, object> diff --git a/FreeSql/Interface/Curd/IInsert.cs b/FreeSql/Interface/Curd/IInsert.cs index 234495ae..4cbcfd8c 100644 --- a/FreeSql/Interface/Curd/IInsert.cs +++ b/FreeSql/Interface/Curd/IInsert.cs @@ -4,6 +4,7 @@ using System.Collections.Generic; using System.Data; using System.Data.Common; using System.Linq.Expressions; +using System.Threading; using System.Threading.Tasks; namespace FreeSql @@ -157,9 +158,9 @@ namespace FreeSql #if net40 #else - Task ExecuteAffrowsAsync(); - Task ExecuteIdentityAsync(); - Task> ExecuteInsertedAsync(); + Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default); + Task ExecuteIdentityAsync(CancellationToken cancellationToken = default); + Task> ExecuteInsertedAsync(CancellationToken cancellationToken = default); #endif } } \ No newline at end of file diff --git a/FreeSql/Interface/Curd/IInsertOrUpdate.cs b/FreeSql/Interface/Curd/IInsertOrUpdate.cs index 0299d065..f2926980 100644 --- a/FreeSql/Interface/Curd/IInsertOrUpdate.cs +++ b/FreeSql/Interface/Curd/IInsertOrUpdate.cs @@ -2,6 +2,7 @@ using System.Collections.Generic; using System.Data.Common; using System.Linq.Expressions; +using System.Threading; using System.Threading.Tasks; namespace FreeSql @@ -86,7 +87,7 @@ namespace FreeSql #if net40 #else - Task ExecuteAffrowsAsync(); + Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default); #endif } } \ No newline at end of file diff --git a/FreeSql/Interface/Curd/IUpdate.cs b/FreeSql/Interface/Curd/IUpdate.cs index 004939c3..87a372f7 100644 --- a/FreeSql/Interface/Curd/IUpdate.cs +++ b/FreeSql/Interface/Curd/IUpdate.cs @@ -3,6 +3,7 @@ using System; using System.Collections.Generic; using System.Data.Common; using System.Linq.Expressions; +using System.Threading; using System.Threading.Tasks; namespace FreeSql @@ -249,8 +250,8 @@ namespace FreeSql #if net40 #else - Task ExecuteAffrowsAsync(); - Task> ExecuteUpdatedAsync(); + Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default); + Task> ExecuteUpdatedAsync(CancellationToken cancellationToken = default); #endif } } \ No newline at end of file diff --git a/FreeSql/Interface/IAdo.cs b/FreeSql/Interface/IAdo.cs index 69ce18f9..7e8f53f1 100644 --- a/FreeSql/Interface/IAdo.cs +++ b/FreeSql/Interface/IAdo.cs @@ -6,6 +6,7 @@ using System.Collections.Generic; using System.Data; using System.Data.Common; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql @@ -274,7 +275,7 @@ namespace FreeSql /// /// 命令超时设置(秒) /// true: 成功, false: 失败 - Task ExecuteConnectTestAsync(int commandTimeout = 0); + Task ExecuteConnectTestAsync(int commandTimeout = 0, CancellationToken cancellationToken = default); /// /// 查询，若使用读写分离，查询【从库】条件cmdText.StartsWith("SELECT ")，否则查询【主库】 @@ -283,26 +284,26 @@ namespace FreeSql /// /// /// - Task ExecuteReaderAsync(Func, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task ExecuteReaderAsync(DbTransaction transaction, Func, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func, Task> readerHander, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); + Task ExecuteReaderAsync(Func, Task> readerHander, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task ExecuteReaderAsync(DbTransaction transaction, Func, Task> readerHander, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func, Task> readerHander, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default); /// /// 查询，ExecuteReaderAsync(dr => {}, "select * from user where age > ?age", new { age = 25 }) /// 提示：parms 参数还可以传 Dictionary<string, object> /// /// /// - Task ExecuteReaderAsync(Func, Task> readerHander, string cmdText, object parms = null); - Task ExecuteReaderAsync(DbTransaction transaction, Func, Task> readerHander, string cmdText, object parms = null); - Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func, Task> readerHander, string cmdText, object parms = null); + Task ExecuteReaderAsync(Func, Task> readerHander, string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task ExecuteReaderAsync(DbTransaction transaction, Func, Task> readerHander, string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func, Task> readerHander, string cmdText, object parms = null, CancellationToken cancellationToken = default); /// /// 查询 /// /// /// - Task ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); + Task ExecuteArrayAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default); /// /// 查询，ExecuteArrayAsync("select * from user where age > ?age", new { age = 25 }) /// 提示：parms 参数还可以传 Dictionary<string, object> @@ -310,17 +311,17 @@ namespace FreeSql /// /// /// - Task ExecuteArrayAsync(string cmdText, object parms = null); - Task ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null); - Task ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); + Task ExecuteArrayAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default); /// /// 查询 /// /// /// - Task ExecuteDataSetAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task ExecuteDataSetAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task ExecuteDataSetAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); + Task ExecuteDataSetAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task ExecuteDataSetAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task ExecuteDataSetAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default); /// /// 查询，ExecuteDataSetAsync("select * from user where age > ?age; select 2", new { age = 25 }) /// 提示：parms 参数还可以传 Dictionary<string, object> @@ -328,17 +329,17 @@ namespace FreeSql /// /// /// - Task ExecuteDataSetAsync(string cmdText, object parms = null); - Task ExecuteDataSetAsync(DbTransaction transaction, string cmdText, object parms = null); - Task ExecuteDataSetAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); + Task ExecuteDataSetAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task ExecuteDataSetAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task ExecuteDataSetAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default); /// /// 查询 /// /// /// - Task ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); + Task ExecuteDataTableAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default); /// /// 查询，ExecuteDataTableAsync("select * from user where age > ?age", new { age = 25 }) /// 提示：parms 参数还可以传 Dictionary<string, object> @@ -346,18 +347,18 @@ namespace FreeSql /// /// /// - Task ExecuteDataTableAsync(string cmdText, object parms = null); - Task ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null); - Task ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); + Task ExecuteDataTableAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default); /// /// 在【主库】执行 /// /// /// /// - Task ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); + Task ExecuteNonQueryAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default); /// /// 在【主库】执行，ExecuteNonQueryAsync("delete from user where age > ?age", new { age = 25 }) /// 提示：parms 参数还可以传 Dictionary<string, object> @@ -365,18 +366,18 @@ namespace FreeSql /// /// /// - Task ExecuteNonQueryAsync(string cmdText, object parms = null); - Task ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null); - Task ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); + Task ExecuteNonQueryAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default); /// /// 在【主库】执行 /// /// /// /// - Task ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); + Task ExecuteScalarAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default); /// /// 在【主库】执行，ExecuteScalarAsync("select 1 from user where age > ?age", new { age = 25 }) /// 提示：parms 参数还可以传 Dictionary<string, object> @@ -384,9 +385,9 @@ namespace FreeSql /// /// /// - Task ExecuteScalarAsync(string cmdText, object parms = null); - Task ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null); - Task ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); + Task ExecuteScalarAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default); /// /// 执行SQL返回对象集合，QueryAsync<User>("select * from user where age > ?age", new SqlParameter { ParameterName = "age", Value = 25 }) @@ -396,10 +397,10 @@ namespace FreeSql /// /// /// - Task> QueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); - Task> QueryAsync(Type resultType, DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); + Task> QueryAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task> QueryAsync(Type resultType, DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default); /// /// 执行SQL返回对象集合，QueryAsync<User>("select * from user where age > ?age", new { age = 25 }) /// 提示：parms 参数还可以传 Dictionary<string, object> @@ -408,9 +409,9 @@ namespace FreeSql /// /// /// - Task> QueryAsync(string cmdText, object parms = null); - Task> QueryAsync(DbTransaction transaction, string cmdText, object parms = null); - Task> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); + Task> QueryAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task> QueryAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default); /// /// 执行SQL返回对象集合，Query<User>("select * from user where age > ?age; select * from address", new SqlParameter { ParameterName = "age", Value = 25 }) @@ -420,9 +421,9 @@ namespace FreeSql /// /// /// - Task, List>> QueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task, List>> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task, List>> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); + Task, List>> QueryAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task, List>> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task, List>> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default); /// /// 执行SQL返回对象集合，Query<User, Address>("select * from user where age > ?age; select * from address", new { age = 25 }) /// 提示：parms 参数还可以传 Dictionary<string, object> @@ -431,28 +432,28 @@ namespace FreeSql /// /// /// - Task, List>> QueryAsync(string cmdText, object parms = null); - Task, List>> QueryAsync(DbTransaction transaction, string cmdText, object parms = null); - Task, List>> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); + Task, List>> QueryAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task, List>> QueryAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task, List>> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default); - Task, List, List>> QueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task, List, List>> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); - Task, List, List>> QueryAsync(string cmdText, object parms = null); - Task, List, List>> QueryAsync(DbTransaction transaction, string cmdText, object parms = null); - Task, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); - Task, List, List, List>> QueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task, List, List, List>> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task, List, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); - Task, List, List, List>> QueryAsync(string cmdText, object parms = null); - Task, List, List, List>> QueryAsync(DbTransaction transaction, string cmdText, object parms = null); - Task, List, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); - Task, List, List, List, List>> QueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task, List, List, List, List>> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms); - Task, List, List, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms); - Task, List, List, List, List>> QueryAsync(string cmdText, object parms = null); - Task, List, List, List, List>> QueryAsync(DbTransaction transaction, string cmdText, object parms = null); - Task, List, List, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null); + Task, List, List>> QueryAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task, List, List>> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task, List, List>> QueryAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task, List, List>> QueryAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task, List, List, List>> QueryAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task, List, List, List>> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task, List, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task, List, List, List>> QueryAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task, List, List, List>> QueryAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task, List, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task, List, List, List, List>> QueryAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task, List, List, List, List>> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task, List, List, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default); + Task, List, List, List, List>> QueryAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task, List, List, List, List>> QueryAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default); + Task, List, List, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default); #endregion #endif } diff --git a/FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderAsync.cs b/FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderAsync.cs index 1ff333fb..f6d6bab5 100644 --- a/FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderAsync.cs +++ b/FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderAsync.cs @@ -6,6 +6,7 @@ using System.Data; using System.Data.Common; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; #if net40 @@ -14,7 +15,7 @@ namespace FreeSql.Internal.CommonProvider { partial class AdoProvider { - async public Task ExecuteConnectTestAsync(int commandTimeout = 0) + async public Task ExecuteConnectTestAsync(int commandTimeout = 0, CancellationToken cancellationToken = default) { try { @@ -22,13 +23,13 @@ namespace FreeSql.Internal.CommonProvider { case DataType.Oracle: 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; 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; } - await ExecuteNonQueryAsync(null, null, CommandType.Text, " SELECT 1", commandTimeout); + await ExecuteNonQueryAsync(null, null, CommandType.Text, " SELECT 1", commandTimeout, null, cancellationToken); return true; } catch @@ -37,13 +38,13 @@ namespace FreeSql.Internal.CommonProvider } } - public Task> QueryAsync(string cmdText, object parms = null) => QueryAsync(null, null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task> QueryAsync(DbTransaction transaction, string cmdText, object parms = null) => QueryAsync(null, null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => QueryAsync(null, connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task> QueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync(null, null, null, cmdType, cmdText, 0, cmdParms); - public Task> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync(null, null, transaction, cmdType, cmdText, 0, cmdParms); - public Task> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) => QueryAsync(null, connection, transaction, cmdType, cmdText, cmdTimeout, cmdParms); - async public Task> QueryAsync(Type resultType, DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) + public Task> QueryAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync(null, null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task> QueryAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync(null, null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync(null, connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task> QueryAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync(null, null, null, cmdType, cmdText, 0, cmdParms, cancellationToken); + public Task> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync(null, null, transaction, cmdType, cmdText, 0, cmdParms, cancellationToken); + public Task> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync(null, connection, transaction, cmdType, cmdText, cmdTimeout, cmdParms, cancellationToken); + async public Task> QueryAsync(Type resultType, DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default) { var ret = new List(); 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); return Task.FromResult(false); - }, cmdType, cmdText, cmdTimeout, cmdParms); + }, cmdType, cmdText, cmdTimeout, cmdParms, cancellationToken); return ret; } #region QueryAsync multi - public Task, List>> QueryAsync(string cmdText, object parms = null) => QueryAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task, List>> QueryAsync(DbTransaction transaction, string cmdText, object parms = null) => QueryAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task, List>> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => QueryAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task, List>> QueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync(null, null, cmdType, cmdText, 0, cmdParms); - public Task, List>> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync(null, transaction, cmdType, cmdText, 0, cmdParms); - async public Task, List>> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) + public Task, List>> QueryAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task, List>> QueryAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task, List>> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task, List>> QueryAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync(null, null, cmdType, cmdText, 0, cmdParms, cancellationToken); + public Task, List>> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync(null, transaction, cmdType, cmdText, 0, cmdParms, cancellationToken); + async public Task, List>> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default) { if (string.IsNullOrEmpty(cmdText)) return NativeTuple.Create(new List(), new List()); var ret1 = new List(); @@ -133,16 +134,16 @@ namespace FreeSql.Internal.CommonProvider break; } return Task.FromResult(false); - }, null, cmdType, cmdText, cmdTimeout, cmdParms); + }, null, cmdType, cmdText, cmdTimeout, cmdParms, cancellationToken); return NativeTuple.Create(ret1, ret2); } - public Task, List, List>> QueryAsync(string cmdText, object parms = null) => QueryAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task, List, List>> QueryAsync(DbTransaction transaction, string cmdText, object parms = null) => QueryAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => QueryAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task, List, List>> QueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync(null, null, cmdType, cmdText, 0, cmdParms); - public Task, List, List>> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync(null, transaction, cmdType, cmdText, 0, cmdParms); - async public Task, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) + public Task, List, List>> QueryAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task, List, List>> QueryAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task, List, List>> QueryAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync(null, null, cmdType, cmdText, 0, cmdParms, cancellationToken); + public Task, List, List>> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync(null, transaction, cmdType, cmdText, 0, cmdParms, cancellationToken); + async public Task, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default) { if (string.IsNullOrEmpty(cmdText)) return NativeTuple.Create(new List(), new List(), new List()); var ret1 = new List(); @@ -219,16 +220,16 @@ namespace FreeSql.Internal.CommonProvider break; } return Task.FromResult(false); - }, null, cmdType, cmdText, cmdTimeout, cmdParms); + }, null, cmdType, cmdText, cmdTimeout, cmdParms, cancellationToken); return NativeTuple.Create(ret1, ret2, ret3); } - public Task, List, List, List>> QueryAsync(string cmdText, object parms = null) => QueryAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task, List, List, List>> QueryAsync(DbTransaction transaction, string cmdText, object parms = null) => QueryAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task, List, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => QueryAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task, List, List, List>> QueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync(null, null, cmdType, cmdText, 0, cmdParms); - public Task, List, List, List>> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync(null, transaction, cmdType, cmdText, 0, cmdParms); - async public Task, List, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) + public Task, List, List, List>> QueryAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task, List, List, List>> QueryAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task, List, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task, List, List, List>> QueryAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync(null, null, cmdType, cmdText, 0, cmdParms, cancellationToken); + public Task, List, List, List>> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync(null, transaction, cmdType, cmdText, 0, cmdParms, cancellationToken); + async public Task, List, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default) { if (string.IsNullOrEmpty(cmdText)) return NativeTuple.Create(new List(), new List(), new List(), new List()); var ret1 = new List(); @@ -328,16 +329,16 @@ namespace FreeSql.Internal.CommonProvider break; } return Task.FromResult(false); - }, null, cmdType, cmdText, cmdTimeout, cmdParms); + }, null, cmdType, cmdText, cmdTimeout, cmdParms, cancellationToken); return NativeTuple.Create(ret1, ret2, ret3, ret4); } - public Task, List, List, List, List>> QueryAsync(string cmdText, object parms = null) => QueryAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task, List, List, List, List>> QueryAsync(DbTransaction transaction, string cmdText, object parms = null) => QueryAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task, List, List, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => QueryAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task, List, List, List, List>> QueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync(null, null, cmdType, cmdText, 0, cmdParms); - public Task, List, List, List, List>> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync(null, transaction, cmdType, cmdText, 0, cmdParms); - async public Task, List, List, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) + public Task, List, List, List, List>> QueryAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task, List, List, List, List>> QueryAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task, List, List, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => QueryAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task, List, List, List, List>> QueryAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync(null, null, cmdType, cmdText, 0, cmdParms, cancellationToken); + public Task, List, List, List, List>> QueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => QueryAsync(null, transaction, cmdType, cmdText, 0, cmdParms, cancellationToken); + async public Task, List, List, List, List>> QueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default) { if (string.IsNullOrEmpty(cmdText)) return NativeTuple.Create(new List(), new List(), new List(), new List(), new List()); var ret1 = new List(); @@ -460,18 +461,18 @@ namespace FreeSql.Internal.CommonProvider break; } return Task.FromResult(false); - }, null, cmdType, cmdText, cmdTimeout, cmdParms); + }, null, cmdType, cmdText, cmdTimeout, cmdParms, cancellationToken); return NativeTuple.Create(ret1, ret2, ret3, ret4, ret5); } #endregion - public Task ExecuteReaderAsync(Func, Task> fetchHandler, string cmdText, object parms = null) => ExecuteReaderAsync(null, null, fetchHandler, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteReaderAsync(DbTransaction transaction, Func, Task> fetchHandler, string cmdText, object parms = null) => ExecuteReaderAsync(null, transaction, fetchHandler, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func, Task> fetchHandler, string cmdText, object parms = null) => ExecuteReaderAsync(connection, transaction, fetchHandler, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteReaderAsync(Func, Task> fetchHandler, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(null, null, fetchHandler, cmdType, cmdText, 0, cmdParms); - public Task ExecuteReaderAsync(DbTransaction transaction, Func, Task> fetchHandler, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(null, transaction, fetchHandler, cmdType, cmdText, 0, cmdParms); - public Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func, Task> fetchHandler, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) => ExecuteReaderMultipleAsync(1, connection, transaction, (fetch, result) => fetchHandler(fetch), null, cmdType, cmdText, cmdTimeout, cmdParms); - async Task ExecuteReaderMultipleAsync(int multipleResult, DbConnection connection, DbTransaction transaction, Func, int, Task> fetchHandler, Action schemaHandler, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) + public Task ExecuteReaderAsync(Func, 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, 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, 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, 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, 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, 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, int, Task> fetchHandler, Action schemaHandler, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default) { if (string.IsNullOrEmpty(cmdText)) return; var dt = DateTime.Now; @@ -501,7 +502,7 @@ namespace FreeSql.Internal.CommonProvider } Object 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) { 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); pc.cmd.Parameters.Clear(); 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; } } @@ -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_dt = DateTime.Now; } - using (var dr = await pc.cmd.ExecuteReaderAsync()) + using (var dr = await pc.cmd.ExecuteReaderAsync(cancellationToken)) { int resultIndex = 0; var fetch = new FetchCallbackArgs { Object = dr }; @@ -557,7 +558,7 @@ namespace FreeSql.Internal.CommonProvider bool isfirst = true; while (true) { - bool isread = await dr.ReadAsync(); + bool isread = await dr.ReadAsync(cancellationToken); if (schemaHandler != null && isfirst) { isfirst = false; @@ -600,36 +601,36 @@ namespace FreeSql.Internal.CommonProvider pc.cmd.Parameters.Clear(); if (DataType == DataType.Sqlite) pc.cmd.Dispose(); } - public Task ExecuteArrayAsync(string cmdText, object parms = null) => ExecuteArrayAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteArrayAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteArrayAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArrayAsync(null, null, cmdType, cmdText, 0, cmdParms); - public Task ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArrayAsync(null, transaction, cmdType, cmdText, 0, cmdParms); - async public Task ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) + public Task ExecuteArrayAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteArrayAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteArrayAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task 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 ExecuteArrayAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteArrayAsync(null, null, cmdType, cmdText, 0, cmdParms, cancellationToken); + public Task ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteArrayAsync(null, transaction, cmdType, cmdText, 0, cmdParms, cancellationToken); + async public Task ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default) { List ret = new List(); await ExecuteReaderAsync(connection, transaction, async fetch => { 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(a); + for (int a = 0; a < values.Length; a++) if (!await fetch.Object.IsDBNullAsync(a, cancellationToken)) values[a] = await fetch.Object.GetFieldValueAsync(a, cancellationToken); ret.Add(values); - }, cmdType, cmdText, cmdTimeout, cmdParms); + }, cmdType, cmdText, cmdTimeout, cmdParms, cancellationToken); return ret.ToArray(); } - public Task ExecuteDataSetAsync(string cmdText, object parms = null) => ExecuteDataSetAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteDataSetAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataSetAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteDataSetAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataSetAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteDataSetAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataSetAsync(null, null, cmdType, cmdText, 0, cmdParms); - public Task ExecuteDataSetAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataSetAsync(null, transaction, cmdType, cmdText, 0, cmdParms); - async public Task ExecuteDataSetAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) + public Task ExecuteDataSetAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteDataSetAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task ExecuteDataSetAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteDataSetAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task 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 ExecuteDataSetAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteDataSetAsync(null, null, cmdType, cmdText, 0, cmdParms, cancellationToken); + public Task ExecuteDataSetAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteDataSetAsync(null, transaction, cmdType, cmdText, 0, cmdParms, cancellationToken); + async public Task ExecuteDataSetAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default) { var ret = new DataSet(); DataTable dt = null; await ExecuteReaderMultipleAsync(16, connection, transaction, async (fetch, result) => { 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(a); + for (int a = 0; a < values.Length; a++) if (!await fetch.Object.IsDBNullAsync(a, cancellationToken)) values[a] = await fetch.Object.GetFieldValueAsync(a, cancellationToken); dt.Rows.Add(values); }, (dr, result) => { @@ -640,21 +641,21 @@ namespace FreeSql.Internal.CommonProvider if (dt.Columns.Contains(name)) name = $"{name}_{Guid.NewGuid().ToString("N").Substring(0, 4)}"; dt.Columns.Add(name, dr.GetFieldType(a)); } - }, cmdType, cmdText, cmdTimeout, cmdParms); + }, cmdType, cmdText, cmdTimeout, cmdParms, cancellationToken); return ret; } - public Task ExecuteDataTableAsync(string cmdText, object parms = null) => ExecuteDataTableAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTableAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTableAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTableAsync(null, null, cmdType, cmdText, 0, cmdParms); - public Task ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTableAsync(null, transaction, cmdType, cmdText, 0, cmdParms); - async public Task ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) + public Task ExecuteDataTableAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteDataTableAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteDataTableAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task 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 ExecuteDataTableAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteDataTableAsync(null, null, cmdType, cmdText, 0, cmdParms, cancellationToken); + public Task ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteDataTableAsync(null, transaction, cmdType, cmdText, 0, cmdParms, cancellationToken); + async public Task ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default) { var ret = new DataTable(); await ExecuteReaderMultipleAsync(1, connection, transaction, async (fetch, result) => { 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(a); + for (int a = 0; a < values.Length; a++) if (!await fetch.Object.IsDBNullAsync(a, cancellationToken)) values[a] = await fetch.Object.GetFieldValueAsync(a, cancellationToken); ret.Rows.Add(values); }, (dr, result) => { @@ -664,28 +665,28 @@ namespace FreeSql.Internal.CommonProvider if (ret.Columns.Contains(name)) name = $"{name}_{Guid.NewGuid().ToString("N").Substring(0, 4)}"; ret.Columns.Add(name, dr.GetFieldType(a)); } - }, cmdType, cmdText, cmdTimeout, cmdParms); + }, cmdType, cmdText, cmdTimeout, cmdParms, cancellationToken); return ret; } - public Task ExecuteNonQueryAsync(string cmdText, object parms = null) => ExecuteNonQueryAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQueryAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQueryAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(null, null, cmdType, cmdText, 0, cmdParms); - public Task ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(null, transaction, cmdType, cmdText, 0, cmdParms); - async public Task ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) + public Task ExecuteNonQueryAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteNonQueryAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteNonQueryAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task 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 ExecuteNonQueryAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteNonQueryAsync(null, null, cmdType, cmdText, 0, cmdParms, cancellationToken); + public Task ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteNonQueryAsync(null, transaction, cmdType, cmdText, 0, cmdParms, cancellationToken); + async public Task ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default) { if (string.IsNullOrEmpty(cmdText)) return 0; var dt = DateTime.Now; var logtxt = new StringBuilder(); var logtxt_dt = DateTime.Now; Object 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; Exception ex = null; try { 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) { @@ -703,25 +704,25 @@ namespace FreeSql.Internal.CommonProvider if (DataType == DataType.Sqlite) pc.cmd.Dispose(); return val; } - public Task ExecuteScalarAsync(string cmdText, object parms = null) => ExecuteScalarAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalarAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalarAsync(connection, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms)); - public Task ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(null, null, cmdType, cmdText, 0, cmdParms); - public Task ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(null, transaction, cmdType, cmdText, 0, cmdParms); - async public Task ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, params DbParameter[] cmdParms) + public Task ExecuteScalarAsync(string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteScalarAsync(null, null, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null, CancellationToken cancellationToken = default) => ExecuteScalarAsync(null, transaction, CommandType.Text, cmdText, 0, GetDbParamtersByObject(cmdText, parms), cancellationToken); + public Task 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 ExecuteScalarAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteScalarAsync(null, null, cmdType, cmdText, 0, cmdParms, cancellationToken); + public Task ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, CancellationToken cancellationToken = default) => ExecuteScalarAsync(null, transaction, cmdType, cmdText, 0, cmdParms, cancellationToken); + async public Task ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, CancellationToken cancellationToken = default) { if (string.IsNullOrEmpty(cmdText)) return null; var dt = DateTime.Now; var logtxt = new StringBuilder(); var logtxt_dt = DateTime.Now; Object 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; Exception ex = null; try { 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) { @@ -740,7 +741,7 @@ namespace FreeSql.Internal.CommonProvider return val; } - async Task PrepareCommandAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, StringBuilder logtxt) + async Task PrepareCommandAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, int cmdTimeout, DbParameter[] cmdParms, StringBuilder logtxt, CancellationToken cancellationToken = default) { DateTime dt = DateTime.Now; DbCommand cmd = CreateCommand(); @@ -774,7 +775,7 @@ namespace FreeSql.Internal.CommonProvider if (connection.State != ConnectionState.Open) { 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"); isclose = true; } diff --git a/FreeSql/Internal/CommonProvider/InsertOrUpdateProvider.cs b/FreeSql/Internal/CommonProvider/InsertOrUpdateProvider.cs index d2ed7a35..270dc44e 100644 --- a/FreeSql/Internal/CommonProvider/InsertOrUpdateProvider.cs +++ b/FreeSql/Internal/CommonProvider/InsertOrUpdateProvider.cs @@ -8,6 +8,7 @@ using System.Linq; using System.Linq.Expressions; using System.Reflection; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Internal.CommonProvider @@ -292,7 +293,7 @@ namespace FreeSql.Internal.CommonProvider } #if net40 #else - async public Task RawExecuteAffrowsAsync() + async public Task RawExecuteAffrowsAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; @@ -302,7 +303,7 @@ namespace FreeSql.Internal.CommonProvider Exception exception = null; 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) { @@ -316,7 +317,7 @@ namespace FreeSql.Internal.CommonProvider } return affrows; } - async public Task ExecuteAffrowsAsync() + async public Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) { var affrows = 0; var ss = SplitSourceByIdentityValueIsNull(_source); @@ -332,10 +333,10 @@ namespace FreeSql.Internal.CommonProvider { _source = ss.Item1; _SplitSourceByIdentityValueIsNullFlag = 1; - affrows += await this.RawExecuteAffrowsAsync(); + affrows += await this.RawExecuteAffrowsAsync(cancellationToken); _source = ss.Item2; _SplitSourceByIdentityValueIsNullFlag = 2; - affrows += await this.RawExecuteAffrowsAsync(); + affrows += await this.RawExecuteAffrowsAsync(cancellationToken); } else { @@ -348,10 +349,10 @@ namespace FreeSql.Internal.CommonProvider { _source = ss.Item1; _SplitSourceByIdentityValueIsNullFlag = 1; - affrows += await this.RawExecuteAffrowsAsync(); + affrows += await this.RawExecuteAffrowsAsync(cancellationToken); _source = ss.Item2; _SplitSourceByIdentityValueIsNullFlag = 2; - affrows += await this.RawExecuteAffrowsAsync(); + affrows += await this.RawExecuteAffrowsAsync(cancellationToken); _transaction.Commit(); _orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, "提交", null)); } diff --git a/FreeSql/Internal/CommonProvider/InsertProviderAsync.cs b/FreeSql/Internal/CommonProvider/InsertProviderAsync.cs index 0cc8ac76..b1123aa7 100644 --- a/FreeSql/Internal/CommonProvider/InsertProviderAsync.cs +++ b/FreeSql/Internal/CommonProvider/InsertProviderAsync.cs @@ -7,6 +7,7 @@ using System.Data.Common; using System.Linq; using System.Linq.Expressions; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Internal.CommonProvider @@ -16,7 +17,7 @@ namespace FreeSql.Internal.CommonProvider { #if net40 #else - async protected Task SplitExecuteAffrowsAsync(int valuesLimit, int parameterLimit) + async protected Task SplitExecuteAffrowsAsync(int valuesLimit, int parameterLimit, CancellationToken cancellationToken = default) { var ss = SplitSource(valuesLimit, parameterLimit); var ret = 0; @@ -28,7 +29,7 @@ namespace FreeSql.Internal.CommonProvider if (ss.Length == 1) { _batchProgress?.Invoke(new BatchProgressStatus(_source, 1, 1)); - ret = await this.RawExecuteAffrowsAsync(); + ret = await this.RawExecuteAffrowsAsync(cancellationToken); ClearData(); return ret; } @@ -49,7 +50,7 @@ namespace FreeSql.Internal.CommonProvider { _source = ss[a]; _batchProgress?.Invoke(new BatchProgressStatus(_source, a + 1, ss.Length)); - ret += await this.RawExecuteAffrowsAsync(); + ret += await this.RawExecuteAffrowsAsync(cancellationToken); } } else @@ -66,7 +67,7 @@ namespace FreeSql.Internal.CommonProvider { _source = ss[a]; _batchProgress?.Invoke(new BatchProgressStatus(_source, a + 1, ss.Length)); - ret += await this.RawExecuteAffrowsAsync(); + ret += await this.RawExecuteAffrowsAsync(cancellationToken); } _transaction.Commit(); _orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, "提交", null)); @@ -95,7 +96,7 @@ namespace FreeSql.Internal.CommonProvider return ret; } - async protected Task SplitExecuteIdentityAsync(int valuesLimit, int parameterLimit) + async protected Task SplitExecuteIdentityAsync(int valuesLimit, int parameterLimit, CancellationToken cancellationToken = default) { var ss = SplitSource(valuesLimit, parameterLimit); long ret = 0; @@ -107,7 +108,7 @@ namespace FreeSql.Internal.CommonProvider if (ss.Length == 1) { _batchProgress?.Invoke(new BatchProgressStatus(_source, 1, 1)); - ret = await this.RawExecuteIdentityAsync(); + ret = await this.RawExecuteIdentityAsync(cancellationToken); ClearData(); return ret; } @@ -128,8 +129,8 @@ namespace FreeSql.Internal.CommonProvider { _source = ss[a]; _batchProgress?.Invoke(new BatchProgressStatus(_source, a + 1, ss.Length)); - if (a < ss.Length - 1) await this.RawExecuteAffrowsAsync(); - else ret = await this.RawExecuteIdentityAsync(); + if (a < ss.Length - 1) await this.RawExecuteAffrowsAsync(cancellationToken); + else ret = await this.RawExecuteIdentityAsync(cancellationToken); } } else @@ -146,8 +147,8 @@ namespace FreeSql.Internal.CommonProvider { _source = ss[a]; _batchProgress?.Invoke(new BatchProgressStatus(_source, a + 1, ss.Length)); - if (a < ss.Length - 1) await this.RawExecuteAffrowsAsync(); - else ret = await this.RawExecuteIdentityAsync(); + if (a < ss.Length - 1) await this.RawExecuteAffrowsAsync(cancellationToken); + else ret = await this.RawExecuteIdentityAsync(cancellationToken); } _transaction.Commit(); _orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, "提交", null)); @@ -176,7 +177,7 @@ namespace FreeSql.Internal.CommonProvider return ret; } - async protected Task> SplitExecuteInsertedAsync(int valuesLimit, int parameterLimit) + async protected Task> SplitExecuteInsertedAsync(int valuesLimit, int parameterLimit, CancellationToken cancellationToken = default) { var ss = SplitSource(valuesLimit, parameterLimit); var ret = new List(); @@ -188,7 +189,7 @@ namespace FreeSql.Internal.CommonProvider if (ss.Length == 1) { _batchProgress?.Invoke(new BatchProgressStatus(_source, 1, 1)); - ret = await this.RawExecuteInsertedAsync(); + ret = await this.RawExecuteInsertedAsync(cancellationToken); ClearData(); return ret; } @@ -209,7 +210,7 @@ namespace FreeSql.Internal.CommonProvider { _source = ss[a]; _batchProgress?.Invoke(new BatchProgressStatus(_source, a + 1, ss.Length)); - ret.AddRange(await this.RawExecuteInsertedAsync()); + ret.AddRange(await this.RawExecuteInsertedAsync(cancellationToken)); } } else @@ -226,7 +227,7 @@ namespace FreeSql.Internal.CommonProvider { _source = ss[a]; _batchProgress?.Invoke(new BatchProgressStatus(_source, a + 1, ss.Length)); - ret.AddRange(await this.RawExecuteInsertedAsync()); + ret.AddRange(await this.RawExecuteInsertedAsync(cancellationToken)); } _transaction.Commit(); _orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, "提交", null)); @@ -255,7 +256,7 @@ namespace FreeSql.Internal.CommonProvider return ret; } - async protected virtual Task RawExecuteAffrowsAsync() + async protected virtual Task RawExecuteAffrowsAsync(CancellationToken cancellationToken = default) { var sql = ToSql(); var before = new Aop.CurdBeforeEventArgs(_table.Type, _table, Aop.CurdType.Insert, sql, _params); @@ -264,7 +265,7 @@ namespace FreeSql.Internal.CommonProvider Exception exception = null; 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) { @@ -279,12 +280,12 @@ namespace FreeSql.Internal.CommonProvider return affrows; } - protected abstract Task RawExecuteIdentityAsync(); - protected abstract Task> RawExecuteInsertedAsync(); + protected abstract Task RawExecuteIdentityAsync(CancellationToken cancellationToken = default); + protected abstract Task> RawExecuteInsertedAsync(CancellationToken cancellationToken = default); - public abstract Task ExecuteAffrowsAsync(); - public abstract Task ExecuteIdentityAsync(); - public abstract Task> ExecuteInsertedAsync(); + public abstract Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default); + public abstract Task ExecuteIdentityAsync(CancellationToken cancellationToken = default); + public abstract Task> ExecuteInsertedAsync(CancellationToken cancellationToken = default); #endif } } diff --git a/FreeSql/Internal/CommonProvider/UpdateProviderAsync.cs b/FreeSql/Internal/CommonProvider/UpdateProviderAsync.cs index 1b3d7756..55599457 100644 --- a/FreeSql/Internal/CommonProvider/UpdateProviderAsync.cs +++ b/FreeSql/Internal/CommonProvider/UpdateProviderAsync.cs @@ -8,6 +8,7 @@ using System.Linq; using System.Linq.Expressions; using System.Reflection; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Internal.CommonProvider @@ -17,14 +18,14 @@ namespace FreeSql.Internal.CommonProvider { #if net40 #else - async protected Task SplitExecuteAffrowsAsync(int valuesLimit, int parameterLimit) + async protected Task SplitExecuteAffrowsAsync(int valuesLimit, int parameterLimit, CancellationToken cancellationToken = default) { var ss = SplitSource(valuesLimit, parameterLimit); var ret = 0; if (ss.Length <= 1) { if (_source?.Any() == true) _batchProgress?.Invoke(new BatchProgressStatus(_source, 1, 1)); - ret = await this.RawExecuteAffrowsAsync(); + ret = await this.RawExecuteAffrowsAsync(cancellationToken); ClearData(); return ret; } @@ -45,7 +46,7 @@ namespace FreeSql.Internal.CommonProvider { _source = ss[a]; _batchProgress?.Invoke(new BatchProgressStatus(_source, a + 1, ss.Length)); - ret += await this.RawExecuteAffrowsAsync(); + ret += await this.RawExecuteAffrowsAsync(cancellationToken); } } else @@ -62,7 +63,7 @@ namespace FreeSql.Internal.CommonProvider { _source = ss[a]; _batchProgress?.Invoke(new BatchProgressStatus(_source, a + 1, ss.Length)); - ret += await this.RawExecuteAffrowsAsync(); + ret += await this.RawExecuteAffrowsAsync(cancellationToken); } _transaction.Commit(); _orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, "提交", null)); @@ -90,14 +91,14 @@ namespace FreeSql.Internal.CommonProvider ClearData(); return ret; } - async protected Task> SplitExecuteUpdatedAsync(int valuesLimit, int parameterLimit) + async protected Task> SplitExecuteUpdatedAsync(int valuesLimit, int parameterLimit, CancellationToken cancellationToken = default) { var ss = SplitSource(valuesLimit, parameterLimit); var ret = new List(); if (ss.Length <= 1) { if (_source?.Any() == true) _batchProgress?.Invoke(new BatchProgressStatus(_source, 1, 1)); - ret = await this.RawExecuteUpdatedAsync(); + ret = await this.RawExecuteUpdatedAsync(cancellationToken); ClearData(); return ret; } @@ -118,7 +119,7 @@ namespace FreeSql.Internal.CommonProvider { _source = ss[a]; _batchProgress?.Invoke(new BatchProgressStatus(_source, a + 1, ss.Length)); - ret.AddRange(await this.RawExecuteUpdatedAsync()); + ret.AddRange(await this.RawExecuteUpdatedAsync(cancellationToken)); } } else @@ -135,7 +136,7 @@ namespace FreeSql.Internal.CommonProvider { _source = ss[a]; _batchProgress?.Invoke(new BatchProgressStatus(_source, a + 1, ss.Length)); - ret.AddRange(await this.RawExecuteUpdatedAsync()); + ret.AddRange(await this.RawExecuteUpdatedAsync(cancellationToken)); } _transaction.Commit(); _orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, "提交", null)); @@ -164,7 +165,7 @@ namespace FreeSql.Internal.CommonProvider return ret; } - async protected Task RawExecuteAffrowsAsync() + async protected Task RawExecuteAffrowsAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; @@ -175,7 +176,7 @@ namespace FreeSql.Internal.CommonProvider Exception exception = null; 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); } catch (Exception ex) @@ -190,10 +191,10 @@ namespace FreeSql.Internal.CommonProvider } return affrows; } - protected abstract Task> RawExecuteUpdatedAsync(); + protected abstract Task> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default); - public abstract Task ExecuteAffrowsAsync(); - public abstract Task> ExecuteUpdatedAsync(); + public abstract Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default); + public abstract Task> ExecuteUpdatedAsync(CancellationToken cancellationToken = default); #endif } } diff --git a/FreeSql/Internal/Model/AdoCommandFluent.cs b/FreeSql/Internal/Model/AdoCommandFluent.cs index 8accc9aa..322f4e47 100644 --- a/FreeSql/Internal/Model/AdoCommandFluent.cs +++ b/FreeSql/Internal/Model/AdoCommandFluent.cs @@ -5,6 +5,7 @@ using System.Data; using System.Data.Common; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Internal.Model @@ -98,16 +99,16 @@ namespace FreeSql.Internal.Model #if net40 #else - public Task ExecuteNonQueryAsync() => this.Ado.ExecuteNonQueryAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray()); - public Task ExecuteScalarAsync() => this.Ado.ExecuteScalarAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray()); - public Task ExecuteDataTableAsync() => this.Ado.ExecuteDataTableAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray()); - public Task ExecuteDataSetAsync() => this.Ado.ExecuteDataSetAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray()); - public Task ExecuteArrayAsync() => this.Ado.ExecuteArrayAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray()); - public Task> QueryAsync() => this.Ado.QueryAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray()); - public Task, List>> QueryAsync() => this.Ado.QueryAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray()); - public Task, List, List>> QueryAsync() => this.Ado.QueryAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray()); - public Task, List, List, List>> QueryAsync() => this.Ado.QueryAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray()); - public Task, List, List, List, List>> QueryAsync() => this.Ado.QueryAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray()); + public Task ExecuteNonQueryAsync(CancellationToken cancellationToken = default) => this.Ado.ExecuteNonQueryAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray(), cancellationToken); + public Task ExecuteScalarAsync(CancellationToken cancellationToken = default) => this.Ado.ExecuteScalarAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray(), cancellationToken); + public Task ExecuteDataTableAsync(CancellationToken cancellationToken = default) => this.Ado.ExecuteDataTableAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray(), cancellationToken); + public Task ExecuteDataSetAsync(CancellationToken cancellationToken = default) => this.Ado.ExecuteDataSetAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray(), cancellationToken); + public Task ExecuteArrayAsync(CancellationToken cancellationToken = default) => this.Ado.ExecuteArrayAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray(), cancellationToken); + public Task> QueryAsync(CancellationToken cancellationToken = default) => this.Ado.QueryAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray(), cancellationToken); + public Task, List>> QueryAsync(CancellationToken cancellationToken = default) => this.Ado.QueryAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray(), cancellationToken); + public Task, List, List>> QueryAsync(CancellationToken cancellationToken = default) => this.Ado.QueryAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray(), cancellationToken); + public Task, List, List, List>> QueryAsync(CancellationToken cancellationToken = default) => this.Ado.QueryAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray(), cancellationToken); + public Task, List, List, List, List>> QueryAsync(CancellationToken cancellationToken = default) => this.Ado.QueryAsync(this.Connection, this.Transaction, this.CmdType, this.CmdText, this.CmdTimeout, this.CmdParameters.ToArray(), cancellationToken); #endif } } diff --git a/Providers/FreeSql.Provider.Dameng/Curd/DamengInsert.cs b/Providers/FreeSql.Provider.Dameng/Curd/DamengInsert.cs index e0e0173c..d07499a3 100644 --- a/Providers/FreeSql.Provider.Dameng/Curd/DamengInsert.cs +++ b/Providers/FreeSql.Provider.Dameng/Curd/DamengInsert.cs @@ -6,6 +6,7 @@ using System.Data; using System.Data.Common; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Dameng.Curd @@ -153,11 +154,11 @@ namespace FreeSql.Dameng.Curd #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); - public override Task ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); - public override Task> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); + public override Task ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); + public override Task> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); - async protected override Task RawExecuteIdentityAsync() + async protected override Task RawExecuteIdentityAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; @@ -172,7 +173,7 @@ namespace FreeSql.Dameng.Curd _orm.Aop.CurdBeforeHandler?.Invoke(this, before); 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) { @@ -195,7 +196,7 @@ namespace FreeSql.Dameng.Curd _orm.Aop.CurdBeforeHandler?.Invoke(this, before); 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); } catch (Exception ex) @@ -210,13 +211,13 @@ namespace FreeSql.Dameng.Curd } return ret; } - async protected override Task> RawExecuteInsertedAsync() + async protected override Task> RawExecuteInsertedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); var ret = _source.ToList(); - await this.RawExecuteAffrowsAsync(); + await this.RawExecuteAffrowsAsync(cancellationToken); return ret; } #endif diff --git a/Providers/FreeSql.Provider.Dameng/Curd/DamengUpdate.cs b/Providers/FreeSql.Provider.Dameng/Curd/DamengUpdate.cs index c4b88741..3ab0bc8f 100644 --- a/Providers/FreeSql.Provider.Dameng/Curd/DamengUpdate.cs +++ b/Providers/FreeSql.Provider.Dameng/Curd/DamengUpdate.cs @@ -4,6 +4,7 @@ using System; using System.Collections.Generic; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Dameng.Curd @@ -65,10 +66,10 @@ namespace FreeSql.Dameng.Curd #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); - public override Task> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); + public override Task> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); - protected override Task> RawExecuteUpdatedAsync() + protected override Task> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default) { throw new NotImplementedException(); } diff --git a/Providers/FreeSql.Provider.Firebird/Curd/FirebirdInsert.cs b/Providers/FreeSql.Provider.Firebird/Curd/FirebirdInsert.cs index 89d7cac4..e7140830 100644 --- a/Providers/FreeSql.Provider.Firebird/Curd/FirebirdInsert.cs +++ b/Providers/FreeSql.Provider.Firebird/Curd/FirebirdInsert.cs @@ -6,6 +6,7 @@ using System.Data; using System.Data.Common; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Firebird.Curd @@ -123,19 +124,19 @@ namespace FreeSql.Firebird.Curd #if net40 #else - public override Task ExecuteAffrowsAsync() + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) { 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 ExecuteIdentityAsync() + public override Task ExecuteIdentityAsync(CancellationToken cancellationToken = default) { 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> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(1, 1000); + public override Task> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(1, 1000, cancellationToken); - async protected override Task RawExecuteIdentityAsync() + async protected override Task RawExecuteIdentityAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; @@ -151,7 +152,7 @@ namespace FreeSql.Firebird.Curd _orm.Aop.CurdBeforeHandler?.Invoke(this, before); 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) { @@ -170,7 +171,7 @@ namespace FreeSql.Firebird.Curd _orm.Aop.CurdBeforeHandler?.Invoke(this, before); 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) { @@ -184,7 +185,7 @@ namespace FreeSql.Firebird.Curd } return ret; } - async protected override Task> RawExecuteInsertedAsync() + async protected override Task> RawExecuteInsertedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); @@ -206,7 +207,7 @@ namespace FreeSql.Firebird.Curd Exception exception = null; try { - ret = await _orm.Ado.QueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); + ret = await _orm.Ado.QueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken); } catch (Exception ex) { diff --git a/Providers/FreeSql.Provider.Firebird/Curd/FirebirdUpdate.cs b/Providers/FreeSql.Provider.Firebird/Curd/FirebirdUpdate.cs index 793554ff..ad701a6e 100644 --- a/Providers/FreeSql.Provider.Firebird/Curd/FirebirdUpdate.cs +++ b/Providers/FreeSql.Provider.Firebird/Curd/FirebirdUpdate.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Data; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Firebird.Curd @@ -99,10 +100,10 @@ namespace FreeSql.Firebird.Curd #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); - public override Task> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); + public override Task> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); - async protected override Task> RawExecuteUpdatedAsync() + async protected override Task> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); @@ -125,7 +126,7 @@ namespace FreeSql.Firebird.Curd Exception exception = null; try { - ret = await _orm.Ado.QueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); + ret = await _orm.Ado.QueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken); ValidateVersionAndThrow(ret.Count, sql, dbParms); } catch (Exception ex) diff --git a/Providers/FreeSql.Provider.KingbaseES/Curd/KingbaseESInsert.cs b/Providers/FreeSql.Provider.KingbaseES/Curd/KingbaseESInsert.cs index 545c7c63..b012359d 100644 --- a/Providers/FreeSql.Provider.KingbaseES/Curd/KingbaseESInsert.cs +++ b/Providers/FreeSql.Provider.KingbaseES/Curd/KingbaseESInsert.cs @@ -6,6 +6,7 @@ using System.Data; using System.Data.Common; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.KingbaseES @@ -122,11 +123,11 @@ namespace FreeSql.KingbaseES #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); - async protected override Task RawExecuteIdentityAsync() + async protected override Task RawExecuteIdentityAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; @@ -142,7 +143,7 @@ namespace FreeSql.KingbaseES _orm.Aop.CurdBeforeHandler?.Invoke(this, before); 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) { @@ -161,7 +162,7 @@ namespace FreeSql.KingbaseES _orm.Aop.CurdBeforeHandler?.Invoke(this, before); 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) { @@ -175,7 +176,7 @@ namespace FreeSql.KingbaseES } return ret; } - async protected override Task> RawExecuteInsertedAsync() + async protected override Task> RawExecuteInsertedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); @@ -197,7 +198,7 @@ namespace FreeSql.KingbaseES Exception exception = null; try { - ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); + ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken); } catch (Exception ex) { diff --git a/Providers/FreeSql.Provider.KingbaseES/Curd/KingbaseESUpdate.cs b/Providers/FreeSql.Provider.KingbaseES/Curd/KingbaseESUpdate.cs index cb086288..e31c0ba6 100644 --- a/Providers/FreeSql.Provider.KingbaseES/Curd/KingbaseESUpdate.cs +++ b/Providers/FreeSql.Provider.KingbaseES/Curd/KingbaseESUpdate.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Data; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.KingbaseES @@ -123,10 +124,10 @@ namespace FreeSql.KingbaseES #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); - async protected override Task> RawExecuteUpdatedAsync() + async protected override Task> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); @@ -149,7 +150,7 @@ namespace FreeSql.KingbaseES Exception exception = null; try { - ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); + ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken); ValidateVersionAndThrow(ret.Count, sql, dbParms); } catch (Exception ex) diff --git a/Providers/FreeSql.Provider.MsAccess/Curd/MsAccessInsert.cs b/Providers/FreeSql.Provider.MsAccess/Curd/MsAccessInsert.cs index 9a31e8cc..464a3ff9 100644 --- a/Providers/FreeSql.Provider.MsAccess/Curd/MsAccessInsert.cs +++ b/Providers/FreeSql.Provider.MsAccess/Curd/MsAccessInsert.cs @@ -6,6 +6,7 @@ using System.Data; using System.Data.Common; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.MsAccess.Curd @@ -102,11 +103,11 @@ namespace FreeSql.MsAccess.Curd #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(1, 1000); - public override Task ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(1, 1000); - public override Task> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(1, 1000); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(1, 1000, cancellationToken); + public override Task ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(1, 1000, cancellationToken); + public override Task> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(1, 1000, cancellationToken); - async protected override Task RawExecuteAffrowsAsync() + async protected override Task RawExecuteAffrowsAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); var before = new Aop.CurdBeforeEventArgs(_table.Type, _table, Aop.CurdType.Insert, sql, _params); @@ -115,7 +116,7 @@ namespace FreeSql.MsAccess.Curd Exception exception = null; 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) { @@ -129,7 +130,7 @@ namespace FreeSql.MsAccess.Curd } return affrows; } - async protected override Task RawExecuteIdentityAsync() + async protected override Task RawExecuteIdentityAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; @@ -146,14 +147,14 @@ namespace FreeSql.MsAccess.Curd using (var conn = await _orm.Ado.MasterPool.GetAsync()) { _connection = conn.Value; - await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); - long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, "SELECT @@identity", _commandTimeout, _params)), out ret); + 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, cancellationToken)), out ret); } } else { - await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); - long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_connection, _transaction, CommandType.Text, "SELECT @@identity", _commandTimeout, _params)), out ret); + 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, cancellationToken)), out ret); } } catch (Exception ex) @@ -169,13 +170,13 @@ namespace FreeSql.MsAccess.Curd } return ret; } - async protected override Task> RawExecuteInsertedAsync() + async protected override Task> RawExecuteInsertedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); var ret = _source.ToList(); - await this.RawExecuteAffrowsAsync(); + await this.RawExecuteAffrowsAsync(cancellationToken); return ret; } #endif diff --git a/Providers/FreeSql.Provider.MsAccess/Curd/MsAccessUpdate.cs b/Providers/FreeSql.Provider.MsAccess/Curd/MsAccessUpdate.cs index 47dcd294..04411b04 100644 --- a/Providers/FreeSql.Provider.MsAccess/Curd/MsAccessUpdate.cs +++ b/Providers/FreeSql.Provider.MsAccess/Curd/MsAccessUpdate.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Data; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.MsAccess.Curd @@ -68,10 +69,10 @@ namespace FreeSql.MsAccess.Curd #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(1, 1000); - public override Task> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(1, 1000); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(1, 1000, cancellationToken); + public override Task> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(1, 1000, cancellationToken); - protected override Task> RawExecuteUpdatedAsync() + protected override Task> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default) { throw new NotImplementedException(); } diff --git a/Providers/FreeSql.Provider.MySql/Curd/MySqlInsert.cs b/Providers/FreeSql.Provider.MySql/Curd/MySqlInsert.cs index 74aacd75..23f8e59e 100644 --- a/Providers/FreeSql.Provider.MySql/Curd/MySqlInsert.cs +++ b/Providers/FreeSql.Provider.MySql/Curd/MySqlInsert.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Data; using System.Data.Common; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.MySql.Curd @@ -106,11 +107,11 @@ namespace FreeSql.MySql.Curd #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); - async protected override Task RawExecuteIdentityAsync() + async protected override Task RawExecuteIdentityAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; @@ -122,7 +123,7 @@ namespace FreeSql.MySql.Curd Exception exception = null; 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) { @@ -136,7 +137,7 @@ namespace FreeSql.MySql.Curd } return ret; } - async protected override Task> RawExecuteInsertedAsync() + async protected override Task> RawExecuteInsertedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); @@ -158,7 +159,7 @@ namespace FreeSql.MySql.Curd Exception exception = null; try { - ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); + ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken); } catch (Exception ex) { diff --git a/Providers/FreeSql.Provider.MySql/Curd/MySqlUpdate.cs b/Providers/FreeSql.Provider.MySql/Curd/MySqlUpdate.cs index 659fa00d..e1196549 100644 --- a/Providers/FreeSql.Provider.MySql/Curd/MySqlUpdate.cs +++ b/Providers/FreeSql.Provider.MySql/Curd/MySqlUpdate.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Data; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.MySql.Curd @@ -106,10 +107,10 @@ namespace FreeSql.MySql.Curd #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); - async protected override Task> RawExecuteUpdatedAsync() + async protected override Task> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); @@ -132,7 +133,7 @@ namespace FreeSql.MySql.Curd Exception exception = null; try { - ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); + ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken); ValidateVersionAndThrow(ret.Count, sql, dbParms); } catch (Exception ex) diff --git a/Providers/FreeSql.Provider.Odbc/Dameng/Curd/OdbcDamengInsert.cs b/Providers/FreeSql.Provider.Odbc/Dameng/Curd/OdbcDamengInsert.cs index ac099657..96dce1fc 100644 --- a/Providers/FreeSql.Provider.Odbc/Dameng/Curd/OdbcDamengInsert.cs +++ b/Providers/FreeSql.Provider.Odbc/Dameng/Curd/OdbcDamengInsert.cs @@ -6,6 +6,7 @@ using System.Data; using System.Data.Common; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Odbc.Dameng @@ -153,11 +154,11 @@ namespace FreeSql.Odbc.Dameng #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); - public override Task ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); - public override Task> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); + public override Task ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); + public override Task> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); - async protected override Task RawExecuteIdentityAsync() + async protected override Task RawExecuteIdentityAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; @@ -172,7 +173,7 @@ namespace FreeSql.Odbc.Dameng _orm.Aop.CurdBeforeHandler?.Invoke(this, before); 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) { @@ -195,7 +196,7 @@ namespace FreeSql.Odbc.Dameng _orm.Aop.CurdBeforeHandler?.Invoke(this, before); 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); } catch (Exception ex) @@ -210,13 +211,13 @@ namespace FreeSql.Odbc.Dameng } return ret; } - async protected override Task> RawExecuteInsertedAsync() + async protected override Task> RawExecuteInsertedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); var ret = _source.ToList(); - await this.RawExecuteAffrowsAsync(); + await this.RawExecuteAffrowsAsync(cancellationToken); return ret; } #endif diff --git a/Providers/FreeSql.Provider.Odbc/Dameng/Curd/OdbcDamengUpdate.cs b/Providers/FreeSql.Provider.Odbc/Dameng/Curd/OdbcDamengUpdate.cs index 9f039209..451c40ef 100644 --- a/Providers/FreeSql.Provider.Odbc/Dameng/Curd/OdbcDamengUpdate.cs +++ b/Providers/FreeSql.Provider.Odbc/Dameng/Curd/OdbcDamengUpdate.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Data; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Odbc.Dameng @@ -66,10 +67,10 @@ namespace FreeSql.Odbc.Dameng #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); - public override Task> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); + public override Task> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); - protected override Task> RawExecuteUpdatedAsync() + protected override Task> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default) { throw new NotImplementedException(); } diff --git a/Providers/FreeSql.Provider.Odbc/Default/Curd/OdbcInsert.cs b/Providers/FreeSql.Provider.Odbc/Default/Curd/OdbcInsert.cs index 54c04672..4ff987f7 100644 --- a/Providers/FreeSql.Provider.Odbc/Default/Curd/OdbcInsert.cs +++ b/Providers/FreeSql.Provider.Odbc/Default/Curd/OdbcInsert.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Data; using System.Data.Common; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Odbc.Default @@ -65,11 +66,11 @@ namespace FreeSql.Odbc.Default #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : _utils.Adapter.InsertBatchSplitLimit, _batchParameterLimit > 0 ? _batchParameterLimit : 255); - public override Task ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : _utils.Adapter.InsertBatchSplitLimit, _batchParameterLimit > 0 ? _batchParameterLimit : 255); - public override Task> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : _utils.Adapter.InsertBatchSplitLimit, _batchParameterLimit > 0 ? _batchParameterLimit : 255); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : _utils.Adapter.InsertBatchSplitLimit, _batchParameterLimit > 0 ? _batchParameterLimit : 255, cancellationToken); + public override Task ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : _utils.Adapter.InsertBatchSplitLimit, _batchParameterLimit > 0 ? _batchParameterLimit : 255, cancellationToken); + public override Task> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : _utils.Adapter.InsertBatchSplitLimit, _batchParameterLimit > 0 ? _batchParameterLimit : 255, cancellationToken); - async protected override Task RawExecuteIdentityAsync() + async protected override Task RawExecuteIdentityAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; @@ -88,8 +89,8 @@ namespace FreeSql.Odbc.Default poolConn = _orm.Ado.MasterPool.Get(); conn = poolConn.Value; } - await _orm.Ado.ExecuteNonQueryAsync(conn, _transaction, CommandType.Text, sql, _commandTimeout, _params); - ret = long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(conn, _transaction, CommandType.Text, $" {_utils.Adapter.InsertAfterGetIdentitySql}", _commandTimeout)), out var trylng) ? trylng : 0; + 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, null, cancellationToken)), out var trylng) ? trylng : 0; } catch (Exception ex) { @@ -106,7 +107,7 @@ namespace FreeSql.Odbc.Default } return ret; } - protected override Task> RawExecuteInsertedAsync() => throw new NotImplementedException("FreeSql.Odbc.Default 未实现该功能"); + protected override Task> RawExecuteInsertedAsync(CancellationToken cancellationToken = default) => throw new NotImplementedException("FreeSql.Odbc.Default 未实现该功能"); #endif } } \ No newline at end of file diff --git a/Providers/FreeSql.Provider.Odbc/Default/Curd/OdbcUpdate.cs b/Providers/FreeSql.Provider.Odbc/Default/Curd/OdbcUpdate.cs index 9e588197..2f9605ff 100644 --- a/Providers/FreeSql.Provider.Odbc/Default/Curd/OdbcUpdate.cs +++ b/Providers/FreeSql.Provider.Odbc/Default/Curd/OdbcUpdate.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Data; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Odbc.Default @@ -61,10 +62,10 @@ namespace FreeSql.Odbc.Default #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : _utils.Adapter.UpdateBatchSplitLimit, _batchParameterLimit > 0 ? _batchParameterLimit : 255); - public override Task> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : _utils.Adapter.UpdateBatchSplitLimit, _batchParameterLimit > 0 ? _batchParameterLimit : 255); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : _utils.Adapter.UpdateBatchSplitLimit, _batchParameterLimit > 0 ? _batchParameterLimit : 255, cancellationToken); + public override Task> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : _utils.Adapter.UpdateBatchSplitLimit, _batchParameterLimit > 0 ? _batchParameterLimit : 255, cancellationToken); - protected override Task> RawExecuteUpdatedAsync() => throw new NotImplementedException("FreeSql.Odbc.Default 未实现该功能"); + protected override Task> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default) => throw new NotImplementedException("FreeSql.Odbc.Default 未实现该功能"); #endif } } diff --git a/Providers/FreeSql.Provider.Odbc/KingbaseES/Curd/OdbcKingbaseESInsert.cs b/Providers/FreeSql.Provider.Odbc/KingbaseES/Curd/OdbcKingbaseESInsert.cs index 2c2ca22b..8c1f56cd 100644 --- a/Providers/FreeSql.Provider.Odbc/KingbaseES/Curd/OdbcKingbaseESInsert.cs +++ b/Providers/FreeSql.Provider.Odbc/KingbaseES/Curd/OdbcKingbaseESInsert.cs @@ -6,6 +6,7 @@ using System.Data; using System.Data.Common; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Odbc.KingbaseES @@ -122,11 +123,11 @@ namespace FreeSql.Odbc.KingbaseES #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); - async protected override Task RawExecuteIdentityAsync() + async protected override Task RawExecuteIdentityAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; @@ -142,7 +143,7 @@ namespace FreeSql.Odbc.KingbaseES _orm.Aop.CurdBeforeHandler?.Invoke(this, before); 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) { @@ -161,7 +162,7 @@ namespace FreeSql.Odbc.KingbaseES _orm.Aop.CurdBeforeHandler?.Invoke(this, before); 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) { @@ -175,7 +176,7 @@ namespace FreeSql.Odbc.KingbaseES } return ret; } - async protected override Task> RawExecuteInsertedAsync() + async protected override Task> RawExecuteInsertedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); @@ -197,7 +198,7 @@ namespace FreeSql.Odbc.KingbaseES Exception exception = null; try { - ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); + ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken); } catch (Exception ex) { diff --git a/Providers/FreeSql.Provider.Odbc/KingbaseES/Curd/OdbcKingbaseESUpdate.cs b/Providers/FreeSql.Provider.Odbc/KingbaseES/Curd/OdbcKingbaseESUpdate.cs index 4cdfaf27..bc744a65 100644 --- a/Providers/FreeSql.Provider.Odbc/KingbaseES/Curd/OdbcKingbaseESUpdate.cs +++ b/Providers/FreeSql.Provider.Odbc/KingbaseES/Curd/OdbcKingbaseESUpdate.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Data; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Odbc.KingbaseES @@ -123,10 +124,10 @@ namespace FreeSql.Odbc.KingbaseES #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); - async protected override Task> RawExecuteUpdatedAsync() + async protected override Task> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); @@ -149,7 +150,7 @@ namespace FreeSql.Odbc.KingbaseES Exception exception = null; try { - ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); + ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken); ValidateVersionAndThrow(ret.Count, sql, dbParms); } catch (Exception ex) diff --git a/Providers/FreeSql.Provider.Odbc/MySql/Curd/OdbcMySqlInsert.cs b/Providers/FreeSql.Provider.Odbc/MySql/Curd/OdbcMySqlInsert.cs index e877bcdc..1ab8e494 100644 --- a/Providers/FreeSql.Provider.Odbc/MySql/Curd/OdbcMySqlInsert.cs +++ b/Providers/FreeSql.Provider.Odbc/MySql/Curd/OdbcMySqlInsert.cs @@ -6,6 +6,7 @@ using System.Collections.Generic; using System.Data; using System.Data.Common; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Odbc.MySql @@ -118,11 +119,11 @@ namespace FreeSql.Odbc.MySql #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); - async protected override Task RawExecuteIdentityAsync() + async protected override Task RawExecuteIdentityAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; @@ -141,8 +142,8 @@ namespace FreeSql.Odbc.MySql poolConn = _orm.Ado.MasterPool.Get(); conn = poolConn.Value; } - await _orm.Ado.ExecuteNonQueryAsync(conn, _transaction, CommandType.Text, sql, _commandTimeout, _params); - ret = long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(conn, _transaction, CommandType.Text, " SELECT LAST_INSERT_ID()", _commandTimeout)), out var trylng) ? trylng : 0; + 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, null, cancellationToken)), out var trylng) ? trylng : 0; } catch (Exception ex) { @@ -159,7 +160,7 @@ namespace FreeSql.Odbc.MySql } return ret; } - async protected override Task> RawExecuteInsertedAsync() + async protected override Task> RawExecuteInsertedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); @@ -181,7 +182,7 @@ namespace FreeSql.Odbc.MySql Exception exception = null; try { - ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); + ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken); } catch (Exception ex) { diff --git a/Providers/FreeSql.Provider.Odbc/MySql/Curd/OdbcMySqlUpdate.cs b/Providers/FreeSql.Provider.Odbc/MySql/Curd/OdbcMySqlUpdate.cs index 6a07f83b..596472cb 100644 --- a/Providers/FreeSql.Provider.Odbc/MySql/Curd/OdbcMySqlUpdate.cs +++ b/Providers/FreeSql.Provider.Odbc/MySql/Curd/OdbcMySqlUpdate.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Data; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Odbc.MySql @@ -106,10 +107,10 @@ namespace FreeSql.Odbc.MySql #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); - async protected override Task> RawExecuteUpdatedAsync() + async protected override Task> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); @@ -132,7 +133,7 @@ namespace FreeSql.Odbc.MySql Exception exception = null; try { - ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); + ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken); ValidateVersionAndThrow(ret.Count, sql, dbParms); } catch (Exception ex) diff --git a/Providers/FreeSql.Provider.Odbc/Oracle/Curd/OdbcOracleInsert.cs b/Providers/FreeSql.Provider.Odbc/Oracle/Curd/OdbcOracleInsert.cs index f687a17d..87d33c14 100644 --- a/Providers/FreeSql.Provider.Odbc/Oracle/Curd/OdbcOracleInsert.cs +++ b/Providers/FreeSql.Provider.Odbc/Oracle/Curd/OdbcOracleInsert.cs @@ -6,6 +6,7 @@ using System.Data; using System.Data.Common; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Odbc.Oracle @@ -153,11 +154,11 @@ namespace FreeSql.Odbc.Oracle #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); - public override Task ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); - public override Task> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); + public override Task ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); + public override Task> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); - async protected override Task RawExecuteIdentityAsync() + async protected override Task RawExecuteIdentityAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; @@ -172,7 +173,7 @@ namespace FreeSql.Odbc.Oracle _orm.Aop.CurdBeforeHandler?.Invoke(this, before); 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) { @@ -195,7 +196,7 @@ namespace FreeSql.Odbc.Oracle _orm.Aop.CurdBeforeHandler?.Invoke(this, before); 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); } catch (Exception ex) @@ -210,13 +211,13 @@ namespace FreeSql.Odbc.Oracle } return ret; } - async protected override Task> RawExecuteInsertedAsync() + async protected override Task> RawExecuteInsertedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); var ret = _source.ToList(); - await this.RawExecuteAffrowsAsync(); + await this.RawExecuteAffrowsAsync(cancellationToken); return ret; } #endif diff --git a/Providers/FreeSql.Provider.Odbc/Oracle/Curd/OdbcOracleUpdate.cs b/Providers/FreeSql.Provider.Odbc/Oracle/Curd/OdbcOracleUpdate.cs index 2ef008c9..4d7172ba 100644 --- a/Providers/FreeSql.Provider.Odbc/Oracle/Curd/OdbcOracleUpdate.cs +++ b/Providers/FreeSql.Provider.Odbc/Oracle/Curd/OdbcOracleUpdate.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Data; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Odbc.Oracle @@ -68,10 +69,10 @@ namespace FreeSql.Odbc.Oracle #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); - public override Task> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); + public override Task> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); - protected override Task> RawExecuteUpdatedAsync() + protected override Task> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default) { throw new NotImplementedException(); } diff --git a/Providers/FreeSql.Provider.Odbc/PostgreSQL/Curd/OdbcPostgreSQLInsert.cs b/Providers/FreeSql.Provider.Odbc/PostgreSQL/Curd/OdbcPostgreSQLInsert.cs index d1fe614d..dc1e0673 100644 --- a/Providers/FreeSql.Provider.Odbc/PostgreSQL/Curd/OdbcPostgreSQLInsert.cs +++ b/Providers/FreeSql.Provider.Odbc/PostgreSQL/Curd/OdbcPostgreSQLInsert.cs @@ -6,6 +6,7 @@ using System.Data; using System.Data.Common; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Odbc.PostgreSQL @@ -122,11 +123,11 @@ namespace FreeSql.Odbc.PostgreSQL #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); - async protected override Task RawExecuteIdentityAsync() + async protected override Task RawExecuteIdentityAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; @@ -142,7 +143,7 @@ namespace FreeSql.Odbc.PostgreSQL _orm.Aop.CurdBeforeHandler?.Invoke(this, before); 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) { @@ -161,7 +162,7 @@ namespace FreeSql.Odbc.PostgreSQL _orm.Aop.CurdBeforeHandler?.Invoke(this, before); 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) { @@ -175,7 +176,7 @@ namespace FreeSql.Odbc.PostgreSQL } return ret; } - async protected override Task> RawExecuteInsertedAsync() + async protected override Task> RawExecuteInsertedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); @@ -197,7 +198,7 @@ namespace FreeSql.Odbc.PostgreSQL Exception exception = null; try { - ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); + ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken); } catch (Exception ex) { diff --git a/Providers/FreeSql.Provider.Odbc/PostgreSQL/Curd/OdbcPostgreSQLUpdate.cs b/Providers/FreeSql.Provider.Odbc/PostgreSQL/Curd/OdbcPostgreSQLUpdate.cs index dd21bcef..77c63351 100644 --- a/Providers/FreeSql.Provider.Odbc/PostgreSQL/Curd/OdbcPostgreSQLUpdate.cs +++ b/Providers/FreeSql.Provider.Odbc/PostgreSQL/Curd/OdbcPostgreSQLUpdate.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Data; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Odbc.PostgreSQL @@ -123,10 +124,10 @@ namespace FreeSql.Odbc.PostgreSQL #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); - async protected override Task> RawExecuteUpdatedAsync() + async protected override Task> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); @@ -149,7 +150,7 @@ namespace FreeSql.Odbc.PostgreSQL Exception exception = null; try { - ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); + ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken); ValidateVersionAndThrow(ret.Count, sql, dbParms); } catch (Exception ex) diff --git a/Providers/FreeSql.Provider.Odbc/SqlServer/Curd/OdbcSqlServerInsert.cs b/Providers/FreeSql.Provider.Odbc/SqlServer/Curd/OdbcSqlServerInsert.cs index 1551bd21..b1626bc5 100644 --- a/Providers/FreeSql.Provider.Odbc/SqlServer/Curd/OdbcSqlServerInsert.cs +++ b/Providers/FreeSql.Provider.Odbc/SqlServer/Curd/OdbcSqlServerInsert.cs @@ -3,6 +3,7 @@ using System; using System.Collections.Generic; using System.Data; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Odbc.SqlServer @@ -104,11 +105,11 @@ namespace FreeSql.Odbc.SqlServer #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100); - public override Task ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100); - public override Task> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100, cancellationToken); + public override Task ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100, cancellationToken); + public override Task> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100, cancellationToken); - async protected override Task RawExecuteIdentityAsync() + async protected override Task RawExecuteIdentityAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; @@ -120,7 +121,7 @@ namespace FreeSql.Odbc.SqlServer Exception exception = null; 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) { @@ -134,7 +135,7 @@ namespace FreeSql.Odbc.SqlServer } return ret; } - async protected override Task> RawExecuteInsertedAsync() + async protected override Task> RawExecuteInsertedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); @@ -171,7 +172,7 @@ namespace FreeSql.Odbc.SqlServer Exception exception = null; try { - ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); + ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken); } catch (Exception ex) { diff --git a/Providers/FreeSql.Provider.Odbc/SqlServer/Curd/OdbcSqlServerUpdate.cs b/Providers/FreeSql.Provider.Odbc/SqlServer/Curd/OdbcSqlServerUpdate.cs index b1009017..0b08e1b2 100644 --- a/Providers/FreeSql.Provider.Odbc/SqlServer/Curd/OdbcSqlServerUpdate.cs +++ b/Providers/FreeSql.Provider.Odbc/SqlServer/Curd/OdbcSqlServerUpdate.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Data; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Odbc.SqlServer @@ -102,10 +103,10 @@ namespace FreeSql.Odbc.SqlServer #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 2100); - public override Task> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 2100); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 2100, cancellationToken); + public override Task> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 2100, cancellationToken); - async protected override Task> RawExecuteUpdatedAsync() + async protected override Task> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); @@ -133,7 +134,7 @@ namespace FreeSql.Odbc.SqlServer Exception exception = null; try { - ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); + ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken); ValidateVersionAndThrow(ret.Count, sql, dbParms); } catch (Exception ex) diff --git a/Providers/FreeSql.Provider.Oracle/Curd/OracleInsert.cs b/Providers/FreeSql.Provider.Oracle/Curd/OracleInsert.cs index ce124df9..b4a33b6d 100644 --- a/Providers/FreeSql.Provider.Oracle/Curd/OracleInsert.cs +++ b/Providers/FreeSql.Provider.Oracle/Curd/OracleInsert.cs @@ -7,6 +7,7 @@ using System.Data; using System.Data.Common; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Oracle.Curd @@ -226,11 +227,11 @@ namespace FreeSql.Oracle.Curd #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); - public override Task ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); - public override Task> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); + public override Task ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); + public override Task> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); - async protected override Task RawExecuteIdentityAsync() + async protected override Task RawExecuteIdentityAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; @@ -245,7 +246,7 @@ namespace FreeSql.Oracle.Curd _orm.Aop.CurdBeforeHandler?.Invoke(this, before); 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) { @@ -268,7 +269,7 @@ namespace FreeSql.Oracle.Curd _orm.Aop.CurdBeforeHandler?.Invoke(this, before); 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); } catch (Exception ex) @@ -283,13 +284,13 @@ namespace FreeSql.Oracle.Curd } return ret; } - async protected override Task> RawExecuteInsertedAsync() + async protected override Task> RawExecuteInsertedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); var ret = _source.ToList(); - await this.RawExecuteAffrowsAsync(); + await this.RawExecuteAffrowsAsync(cancellationToken); return ret; } #endif diff --git a/Providers/FreeSql.Provider.Oracle/Curd/OracleUpdate.cs b/Providers/FreeSql.Provider.Oracle/Curd/OracleUpdate.cs index f0652f8d..b0beee38 100644 --- a/Providers/FreeSql.Provider.Oracle/Curd/OracleUpdate.cs +++ b/Providers/FreeSql.Provider.Oracle/Curd/OracleUpdate.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Data; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Oracle.Curd @@ -68,10 +69,10 @@ namespace FreeSql.Oracle.Curd #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); - public override Task> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); + public override Task> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); - protected override Task> RawExecuteUpdatedAsync() + protected override Task> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default) { throw new NotImplementedException(); } diff --git a/Providers/FreeSql.Provider.PostgreSQL/Curd/PostgreSQLInsert.cs b/Providers/FreeSql.Provider.PostgreSQL/Curd/PostgreSQLInsert.cs index 367a967a..13b0d2ea 100644 --- a/Providers/FreeSql.Provider.PostgreSQL/Curd/PostgreSQLInsert.cs +++ b/Providers/FreeSql.Provider.PostgreSQL/Curd/PostgreSQLInsert.cs @@ -6,6 +6,7 @@ using System.Data; using System.Data.Common; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.PostgreSQL.Curd @@ -122,11 +123,11 @@ namespace FreeSql.PostgreSQL.Curd #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); - async protected override Task RawExecuteIdentityAsync() + async protected override Task RawExecuteIdentityAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; @@ -142,7 +143,7 @@ namespace FreeSql.PostgreSQL.Curd _orm.Aop.CurdBeforeHandler?.Invoke(this, before); 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) { @@ -161,7 +162,7 @@ namespace FreeSql.PostgreSQL.Curd _orm.Aop.CurdBeforeHandler?.Invoke(this, before); 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) { @@ -175,7 +176,7 @@ namespace FreeSql.PostgreSQL.Curd } return ret; } - async protected override Task> RawExecuteInsertedAsync() + async protected override Task> RawExecuteInsertedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); @@ -197,7 +198,7 @@ namespace FreeSql.PostgreSQL.Curd Exception exception = null; try { - ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); + ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken); } catch (Exception ex) { diff --git a/Providers/FreeSql.Provider.PostgreSQL/Curd/PostgreSQLUpdate.cs b/Providers/FreeSql.Provider.PostgreSQL/Curd/PostgreSQLUpdate.cs index 085ac4bd..a8cd23b3 100644 --- a/Providers/FreeSql.Provider.PostgreSQL/Curd/PostgreSQLUpdate.cs +++ b/Providers/FreeSql.Provider.PostgreSQL/Curd/PostgreSQLUpdate.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Data; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.PostgreSQL.Curd @@ -123,10 +124,10 @@ namespace FreeSql.PostgreSQL.Curd #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); - async protected override Task> RawExecuteUpdatedAsync() + async protected override Task> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); @@ -149,7 +150,7 @@ namespace FreeSql.PostgreSQL.Curd Exception exception = null; try { - ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); + ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken); ValidateVersionAndThrow(ret.Count, sql, dbParms); } catch (Exception ex) diff --git a/Providers/FreeSql.Provider.ShenTong/Curd/ShenTongInsert.cs b/Providers/FreeSql.Provider.ShenTong/Curd/ShenTongInsert.cs index 9dadb1a5..60a2951e 100644 --- a/Providers/FreeSql.Provider.ShenTong/Curd/ShenTongInsert.cs +++ b/Providers/FreeSql.Provider.ShenTong/Curd/ShenTongInsert.cs @@ -6,6 +6,7 @@ using System.Data; using System.Data.Common; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.ShenTong.Curd @@ -122,11 +123,11 @@ namespace FreeSql.ShenTong.Curd #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); - async protected override Task RawExecuteIdentityAsync() + async protected override Task RawExecuteIdentityAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; @@ -142,7 +143,7 @@ namespace FreeSql.ShenTong.Curd _orm.Aop.CurdBeforeHandler?.Invoke(this, before); 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) { @@ -161,7 +162,7 @@ namespace FreeSql.ShenTong.Curd _orm.Aop.CurdBeforeHandler?.Invoke(this, before); 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) { @@ -175,7 +176,7 @@ namespace FreeSql.ShenTong.Curd } return ret; } - async protected override Task> RawExecuteInsertedAsync() + async protected override Task> RawExecuteInsertedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); @@ -197,7 +198,7 @@ namespace FreeSql.ShenTong.Curd Exception exception = null; try { - ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); + ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken); } catch (Exception ex) { diff --git a/Providers/FreeSql.Provider.ShenTong/Curd/ShenTongUpdate.cs b/Providers/FreeSql.Provider.ShenTong/Curd/ShenTongUpdate.cs index 50c293e7..44102c15 100644 --- a/Providers/FreeSql.Provider.ShenTong/Curd/ShenTongUpdate.cs +++ b/Providers/FreeSql.Provider.ShenTong/Curd/ShenTongUpdate.cs @@ -6,6 +6,7 @@ using System.Collections.Generic; using System.Data; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.ShenTong.Curd @@ -124,10 +125,10 @@ namespace FreeSql.ShenTong.Curd #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); - public override Task> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); + public override Task> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 3000, cancellationToken); - async protected override Task> RawExecuteUpdatedAsync() + async protected override Task> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); @@ -150,7 +151,7 @@ namespace FreeSql.ShenTong.Curd Exception exception = null; try { - ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); + ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken); ValidateVersionAndThrow(ret.Count, sql, dbParms); } catch (Exception ex) diff --git a/Providers/FreeSql.Provider.SqlServer/Curd/SqlServerInsert.cs b/Providers/FreeSql.Provider.SqlServer/Curd/SqlServerInsert.cs index f1ee76ae..fca5e0b8 100644 --- a/Providers/FreeSql.Provider.SqlServer/Curd/SqlServerInsert.cs +++ b/Providers/FreeSql.Provider.SqlServer/Curd/SqlServerInsert.cs @@ -4,6 +4,7 @@ using System.Collections.Generic; using System.Data; using System.Data.Common; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.SqlServer.Curd @@ -109,11 +110,11 @@ namespace FreeSql.SqlServer.Curd #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100); - public override Task ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100); - public override Task> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100, cancellationToken); + public override Task ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100, cancellationToken); + public override Task> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 1000, _batchParameterLimit > 0 ? _batchParameterLimit : 2100, cancellationToken); - async protected override Task RawExecuteIdentityAsync() + async protected override Task RawExecuteIdentityAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; @@ -125,7 +126,7 @@ namespace FreeSql.SqlServer.Curd Exception exception = null; 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) { @@ -139,7 +140,7 @@ namespace FreeSql.SqlServer.Curd } return ret; } - async protected override Task> RawExecuteInsertedAsync() + async protected override Task> RawExecuteInsertedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); @@ -176,7 +177,7 @@ namespace FreeSql.SqlServer.Curd Exception exception = null; try { - ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params); + ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken); } catch (Exception ex) { diff --git a/Providers/FreeSql.Provider.SqlServer/Curd/SqlServerUpdate.cs b/Providers/FreeSql.Provider.SqlServer/Curd/SqlServerUpdate.cs index f70a8143..b70438d6 100644 --- a/Providers/FreeSql.Provider.SqlServer/Curd/SqlServerUpdate.cs +++ b/Providers/FreeSql.Provider.SqlServer/Curd/SqlServerUpdate.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Data; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.SqlServer.Curd @@ -103,10 +104,10 @@ namespace FreeSql.SqlServer.Curd #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 2100); - public override Task> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 2100); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 2100, cancellationToken); + public override Task> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 500, _batchParameterLimit > 0 ? _batchParameterLimit : 2100, cancellationToken); - async protected override Task> RawExecuteUpdatedAsync() + async protected override Task> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); @@ -134,7 +135,7 @@ namespace FreeSql.SqlServer.Curd Exception exception = null; try { - ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms); + ret = await _orm.Ado.QueryAsync(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken); ValidateVersionAndThrow(ret.Count, sql, dbParms); } catch (Exception ex) diff --git a/Providers/FreeSql.Provider.Sqlite/Curd/SqliteInsert.cs b/Providers/FreeSql.Provider.Sqlite/Curd/SqliteInsert.cs index a9165dc3..ba1b143a 100644 --- a/Providers/FreeSql.Provider.Sqlite/Curd/SqliteInsert.cs +++ b/Providers/FreeSql.Provider.Sqlite/Curd/SqliteInsert.cs @@ -4,6 +4,7 @@ using System.Collections.Generic; using System.Data; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Sqlite.Curd @@ -59,11 +60,11 @@ namespace FreeSql.Sqlite.Curd #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 999); - public override Task ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 999); - public override Task> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 999); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); + public override Task ExecuteIdentityAsync(CancellationToken cancellationToken = default) => base.SplitExecuteIdentityAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); + public override Task> ExecuteInsertedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteInsertedAsync(_batchValuesLimit > 0 ? _batchValuesLimit : 5000, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); - async protected override Task RawExecuteIdentityAsync() + async protected override Task RawExecuteIdentityAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return 0; @@ -75,7 +76,7 @@ namespace FreeSql.Sqlite.Curd Exception exception = null; 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) { @@ -89,13 +90,13 @@ namespace FreeSql.Sqlite.Curd } return ret; } - async protected override Task> RawExecuteInsertedAsync() + async protected override Task> RawExecuteInsertedAsync(CancellationToken cancellationToken = default) { var sql = this.ToSql(); if (string.IsNullOrEmpty(sql)) return new List(); var ret = _source.ToList(); - await this.RawExecuteAffrowsAsync(); + await this.RawExecuteAffrowsAsync(cancellationToken); return ret; } #endif diff --git a/Providers/FreeSql.Provider.Sqlite/Curd/SqliteUpdate.cs b/Providers/FreeSql.Provider.Sqlite/Curd/SqliteUpdate.cs index 1fefc121..6db2c026 100644 --- a/Providers/FreeSql.Provider.Sqlite/Curd/SqliteUpdate.cs +++ b/Providers/FreeSql.Provider.Sqlite/Curd/SqliteUpdate.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Data; using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; namespace FreeSql.Sqlite.Curd @@ -66,10 +67,10 @@ namespace FreeSql.Sqlite.Curd #if net40 #else - public override Task ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); - public override Task> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999); + public override Task ExecuteAffrowsAsync(CancellationToken cancellationToken = default) => base.SplitExecuteAffrowsAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); + public override Task> ExecuteUpdatedAsync(CancellationToken cancellationToken = default) => base.SplitExecuteUpdatedAsync(_batchRowsLimit > 0 ? _batchRowsLimit : 200, _batchParameterLimit > 0 ? _batchParameterLimit : 999, cancellationToken); - protected override Task> RawExecuteUpdatedAsync() + protected override Task> RawExecuteUpdatedAsync(CancellationToken cancellationToken = default) { throw new NotImplementedException(); }