/// <summary> /// 异步执行没有结果的查询 /// </summary> /// <param name="query">要执行的查询对象</param> /// <param name="token">取消指示</param> /// <returns>查询所影响的行数</returns> public static async Task <int> ExecuteNonQueryAsync(this IDbExecutableQuery query, CancellationToken token = default(CancellationToken)) { using (var context = await query.ExecuteAsync(token)) { return(context.DataReader.RecordsAffected); } }
/// <summary> /// 执行查询并将第一个结果集包装成 DataTable 返回 /// </summary> /// <param name="query">要执行的查询对象</param> /// <returns>查询结果</returns> public static DataTable ExecuteDataTable(this IDbExecutableQuery query) { using (var context = query.Execute()) { return(context.LoadDataTable(0, 0)); } }
/// <summary> /// 执行没有结果的查询 /// </summary> /// <param name="query">要执行的查询对象</param> /// <returns>查询所影响的行数</returns> public static int ExecuteNonQuery(this IDbExecutableQuery query) { using (var context = query.Execute()) { return(context.DataReader.RecordsAffected); } }
/// <summary> /// 执行查询并将第一个结果集包装成 DataTable 返回 /// </summary> /// <param name="query">要执行的查询对象</param> /// <returns>查询结果</returns> public static DataTable ExecuteDataTable(this IDbExecutableQuery query) { using (var context = query.Execute()) { var data = new DataTable(); data.Load(context.DataReader); return(data); } }
/// <summary> /// 异步执行查询并将第一个结果集包装成 DataTable 返回 /// </summary> /// <param name="query">要执行的查询对象</param> /// <param name="token">取消指示</param> /// <returns>查询结果</returns> public static async Task <DataTable> ExecuteDataTableAsync(this IDbExecutableQuery query, CancellationToken token = default(CancellationToken)) { using (var context = await query.ExecuteAsync(token)) { var data = new DataTable(); data.Load(context.DataReader); return(data); } }
/// <summary> /// 执行查询并将所有结果集包装成 DataTable 返回 /// </summary> /// <param name="query">要执行的查询对象</param> /// <returns>查询结果</returns> public static DataTable[] ExecuteAllDataTables(this IDbExecutableQuery query) { List <DataTable> dataTables = new List <DataTable>(); using (var context = query.Execute()) { do { dataTables.Add(context.LoadDataTable(0, 0)); } while (context.NextResult()); } return(dataTables.ToArray()); }
/// <summary> /// 执行查询并返回首行首列 /// </summary> /// <param name="query">要执行的查询对象</param> /// <returns>查询结果</returns> public static object ExecuteScalar(this IDbExecutableQuery query) { using (var context = query.Execute()) { if (context.DataReader.Read() && context.DataReader.FieldCount > 0) { return(context.DataReader[0]); } else { return(null); } } }
/// <summary> /// 查询数据库并将第一个结果集填充实体类型 /// </summary> /// <typeparam name="T">实体类型</typeparam> /// <param name="query">要执行的查询</param> /// <param name="token">取消指示</param> /// <param name="converter">实体转换器</param> /// <returns>实体集</returns> public async static Task <T[]> ExecuteEntitiesAsync <T>(this IDbExecutableQuery query, CancellationToken token, Func <DataRow, CancellationToken, Task <T> > converter) { var data = await query.ExecuteDataTableAsync(token); List <T> result = new List <T>(); foreach (var dataItem in data.GetRows()) { var entity = await converter(dataItem, token); result.Add(entity); } return(result.ToArray()); }
/// <summary> /// 异步执行查询并返回首行首列 /// </summary> /// <param name="query">要执行的查询对象</param> /// <param name="token">取消指示</param> /// <returns>查询结果</returns> public static async Task <object> ExecuteScalarAsync(this IDbExecutableQuery query, CancellationToken token = default(CancellationToken)) { using (var context = await query.ExecuteAsync(token)) { if (context.DataReader.Read()) { return(context.DataReader[0]); } else { return(null); } } }
/// <summary> /// 执行查询并返回首行 /// </summary> /// <param name="query">要执行的查询对象</param> /// <returns>查询结果</returns> public static DataRow ExecuteFirstRow(this IDbExecutableQuery query) { //UNDONE var data = query.ExecuteDataTable(); if (data.Rows.Count > 0) { return(data.Rows[0]); } else { return(null); } }
/// <summary> /// 异步执行查询并返回首行 /// </summary> /// <param name="query">要执行的查询对象</param> /// <param name="token">取消指示</param> /// <returns>查询结果</returns> public static async Task <DataRow> ExecuteFirstRowAsync(this IDbExecutableQuery query, CancellationToken token = default(CancellationToken)) { //UNDONE var data = await query.ExecuteDataTableAsync(token); if (data.Rows.Count > 0) { return(data.Rows[0]); } else { return(null); } }
/// <summary> /// 执行查询并返回首行首列 /// </summary> /// <param name="query">要执行的查询对象</param> /// <returns>查询结果</returns> public static object ExecuteScalar(this IDbExecutableQuery query) { using (var context = query.Execute()) { var record = context.ReadRecord(); if (record != null && record.FieldCount > 0) { return(record[0]); } else { return(null); } } }
/// <summary> /// 执行查询并将所有结果集包装成 DataTable 返回 /// </summary> /// <param name="query">要执行的查询对象</param> /// <returns>查询结果</returns> public static DataTable[] ExecuteAllDataTables(this IDbExecutableQuery query) { List <DataTable> dataTables = new List <DataTable>(); using (var context = query.Execute()) { do { var data = new DataTable(); data.Load(context.DataReader); dataTables.Add(data); } while (context.DataReader.NextResult()); } return(dataTables.ToArray()); }
/// <summary> /// 异步执行查询并将所有结果集包装成 DataTable 返回 /// </summary> /// <param name="query">要执行的查询对象</param> /// <param name="token">取消指示</param> /// <returns>查询结果</returns> public static async Task <DataTable[]> ExecuteAllDataTablesAsync(this IDbExecutableQuery query, CancellationToken token = default(CancellationToken)) { List <DataTable> dataTables = new List <DataTable>(); using (var context = await query.ExecuteAsync(token)) { do { var data = new DataTable(); data.Load(context.DataReader); dataTables.Add(data); } while (context.DataReader.NextResult()); } return(dataTables.ToArray()); }
/// <summary> /// 执行查询并返回首行 /// </summary> /// <param name="query">要执行的查询对象</param> /// <returns>查询结果</returns> public static DataRow ExecuteFirstRow(this IDbExecutableQuery query) { //UNDONE using (var context = query.Execute()) { var data = context.LoadDataTable(0, 1); if (data.Rows.Count > 0) { return(data.Rows[0]); } else { return(null); } } }
/// <summary> /// 查询数据库并将第一个结果集填充实体类型 /// </summary> /// <typeparam name="T">实体类型</typeparam> /// <param name="query">要执行的查询</param> /// <param name="converter">实体转换器</param> /// <returns>实体集</returns> public static T[] ExecuteEntities <T>(this IDbExecutableQuery query, IEntityConverter <T> converter) where T : new() { var data = query.ExecuteDataTable(); return(data.GetRows().Select(dataItem => dataItem.ToEntity(converter)).ToArray()); }
/// <summary> /// 查询数据库并将第一个结果集填充实体类型 /// </summary> /// <typeparam name="T">实体类型</typeparam> /// <param name="query">要执行的查询</param> /// <param name="converter">实体转换器</param> /// <returns>实体集</returns> public static T[] ExecuteEntities <T>(this IDbExecutableQuery query, Func <DataRow, T> converter) { var data = query.ExecuteDataTable(); return(data.GetRows().Select(dataItem => converter(dataItem)).ToArray()); }
/// <summary> /// 查询数据库并将结果首行填充实体 /// </summary> /// <typeparam name="T">实体类型</typeparam> /// <param name="query">要执行的查询</param> /// <param name="converter">实体转换方法</param> /// <returns>实体</returns> public static T ExecuteEntity <T>(this IDbExecutableQuery query, IEntityConverter <T> converter) where T : new() { var dataItem = query.ExecuteFirstRow(); return(dataItem.ToEntity <T>(converter)); }
/// <summary> /// 查询数据库并将结果首行填充实体 /// </summary> /// <typeparam name="T">实体类型</typeparam> /// <param name="query">要执行的查询</param> /// <param name="converter">实体转换方法</param> /// <returns>实体</returns> public static T ExecuteEntity <T>(this IDbExecutableQuery query, Func <DataRow, T> converter) { var dataItem = query.ExecuteFirstRow(); return(converter(dataItem)); }
/// <summary> /// 执行查询并将第一个结果集的第一条记录填充动态对象 /// </summary> /// <param name="query">要执行的查询</param> /// <returns>查询结果</returns> public static dynamic ExecuteDynamicObject(this IDbExecutableQuery query) { var dataItem = query.ExecuteFirstRow(); return(ToDynamic(dataItem)); }
/// <summary> /// 查询数据库并将结果首行填充实体 /// </summary> /// <typeparam name="T">实体类型</typeparam> /// <param name="query">要执行的查询</param> /// <returns>实体</returns> public static T ExecuteEntity <T>(this IDbExecutableQuery query) where T : new() { var dataItem = query.ExecuteFirstRow(); return(dataItem.ToEntity <T>()); }
/// <summary> /// 查询数据库并将结果首行填充实体 /// </summary> /// <typeparam name="T">实体类型</typeparam> /// <param name="query">要执行的查询</param> /// <param name="token">取消指示</param> /// <returns>实体</returns> public async static Task <T> ExecuteEntityAsync <T>(this IDbExecutableQuery query, CancellationToken token = default(CancellationToken)) where T : new() { var dataItem = await query.ExecuteFirstRowAsync(token); return(dataItem.ToEntity <T>()); }
/// <summary> /// 查询数据库并将第一个结果集填充实体类型 /// </summary> /// <typeparam name="T">实体类型</typeparam> /// <param name="query">要执行的查询</param> /// <param name="token">取消指示</param> /// <param name="converter">实体转换器</param> /// <returns>实体集</returns> public async static Task <T[]> ExecuteEntitiesAsync <T>(this IDbExecutableQuery query, CancellationToken token, Func <DataRow, T> converter) { var data = await query.ExecuteDataTableAsync(token); return(data.GetRows().Select(dataItem => converter(dataItem)).ToArray()); }
/// <summary> /// 执行查询并返回首行首列 /// </summary> /// <typeparam name="T">返回值类型</typeparam> /// <param name="query">要执行的查询对象</param> /// <returns>查询结果</returns> public static T ExecuteScalar <T>(this IDbExecutableQuery query) { return(ExecuteScalar(query).ConvertTo <T>()); }
/// <summary> /// 异步执行查询并返回首行首列 /// </summary> /// <typeparam name="T">返回值类型</typeparam> /// <param name="query">要执行的查询对象</param> /// <param name="token">取消指示</param> /// <returns>查询结果</returns> public async static Task <T> ExecuteScalarAsync <T>(this IDbExecutableQuery query, CancellationToken token = default(CancellationToken)) { var scalar = await ExecuteScalarAsync(query, token); return(scalar.ConvertTo <T>()); }
/// <summary> /// 查询数据库并将结果首行填充实体 /// </summary> /// <typeparam name="T">实体类型</typeparam> /// <param name="query">要执行的查询</param> /// <param name="token">取消指示</param> /// <param name="converter">实体转换方法</param> /// <returns>实体</returns> public async static Task <T> ExecuteEntityAsync <T>(this IDbExecutableQuery query, CancellationToken token, IEntityConverter <T> converter) where T : new() { var dataItem = await query.ExecuteFirstRowAsync(token); return(dataItem.ToEntity <T>(converter)); }
/// <summary> /// 异步查询数据库并将结果首行填充实体 /// </summary> /// <typeparam name="T">实体类型</typeparam> /// <param name="query">要执行的查询</param> /// <param name="converter">实体转换方法</param> /// <returns>实体</returns> public static Task <T> ExecuteEntityAsync <T>(this IDbExecutableQuery query, Func <DataRow, T> converter) { return(ExecuteEntityAsync(query, CancellationToken.None, converter)); }
/// <summary> /// 异步查询数据库并将结果首行填充实体 /// </summary> /// <typeparam name="T">实体类型</typeparam> /// <param name="query">要执行的查询</param> /// <param name="token">取消指示</param> /// <param name="converter">异步实体转换方法</param> /// <returns>实体</returns> public async static Task <T> ExecuteEntityAsync <T>(this IDbExecutableQuery query, CancellationToken token, Func <DataRow, CancellationToken, Task <T> > converter) { var dataItem = await query.ExecuteFirstRowAsync(token); return(await converter(dataItem, token)); }
/// <summary> /// 查询数据库并将第一个结果集填充实体类型 /// </summary> /// <typeparam name="T">实体类型</typeparam> /// <param name="query">要执行的查询</param> /// <param name="converter">实体转换器</param> /// <returns>实体集</returns> public static Task <T[]> ExecuteEntitiesAsync <T>(this IDbExecutableQuery query, IEntityConverter <T> converter) where T : new() { return(ExecuteEntitiesAsync(query, CancellationToken.None, converter)); }
/// <summary> /// 查询数据库并将第一个结果集填充实体类型 /// </summary> /// <typeparam name="T">实体类型</typeparam> /// <param name="query">要执行的查询</param> /// <param name="token">取消指示</param> /// <param name="converter">实体转换器</param> /// <returns>实体集</returns> public async static Task <T[]> ExecuteEntitiesAsync <T>(this IDbExecutableQuery query, CancellationToken token, IEntityConverter <T> converter) where T : new() { var data = await query.ExecuteDataTableAsync(token); return(data.GetRows().Select(dataItem => dataItem.ToEntity <T>(converter)).ToArray()); }