/// <summary>
/// 异步执行查询文本并返回一个 <see cref="IDataReader"/>。
/// </summary>
/// <param name="queryCommand">查询命令。</param>
/// <param name="segment">数据分段对象。</param>
/// <param name="parameters">查询参数集合。</param>
/// <returns>一个 <see cref="IDataReader"/> 对象。</returns>
public async virtual Task <IDataReader> ExecuteReaderAsync(IQueryCommand queryCommand, IDataSegment segment = null, ParameterCollection parameters = null)
{
Guard.ArgumentNull(queryCommand, "queryCommand");
return(await UsingConnection(() =>
{
using (var command = CreateDbCommand(queryCommand, parameters))
{
try
{
Task <DbDataReader> reader = null;
var context = new CommandContext(this, command, segment, parameters);
OnCommandExecuted(command, segment, parameters, TimeWatcher.Watch(() => ProcessSegmentCommand(context, () => reader = command.ExecuteReaderAsync())));
command.SyncParameters(parameters);
command.ClearParameters();
return reader;
}
catch (DbException exp)
{
TrackFailedLog(command, exp);
throw new CommandException(command, exp);
}
}
}));
}
/// <summary>
/// 异步的，执行查询文本并将结果并返回动态序列。
/// </summary>
/// <param name="queryCommand">查询命令。</param>
/// <param name="segment">数据分段对象。</param>
/// <param name="parameters">查询参数集合。</param>
/// <param name="cancellationToken">取消操作的通知。</param>
/// <returns>一个动态对象的枚举器。</returns>
public virtual async IAsyncEnumerable <dynamic> ExecuteEnumerableAsync(IQueryCommand queryCommand, IDataSegment segment = null, ParameterCollection parameters = null, CancellationToken cancellationToken = default)
{
Guard.ArgumentNull(queryCommand, nameof(queryCommand));
using (var reader = (DbDataReader)(await ExecuteReaderAsync(queryCommand, segment, parameters, cancellationToken)))
{
var wrapper = Provider.GetService <IRecordWrapper>();
TypeDescriptorUtility.AddDefaultDynamicProvider();
while (await reader.ReadAsync(cancellationToken))
{
var expando = new ExpandoObject();
var dictionary = (IDictionary <string, object>)expando;
for (var i = 0; i < reader.FieldCount; i++)
{
var name = wrapper.GetFieldName(reader, i);
if (name.Equals("ROW_NUM"))
{
continue;
}
dictionary.Add(wrapper.GetFieldName(reader, i), RecordWrapHelper.GetValue(wrapper, reader, i));
}
yield return(expando);
}
}
}
/// <summary>
/// 根据自定义的SQL语句查询返回一组动态对象。
/// </summary>
/// <param name="queryCommand">查询命令。</param>
/// <param name="segment">数据分段对象。</param>
/// <param name="parameters">查询参数集合。</param>
/// <returns>一个动态对象的枚举器。</returns>
public virtual IEnumerable <object> ExecuteEnumerable(IQueryCommand queryCommand, IDataSegment segment = null, ParameterCollection parameters = null)
{
Guard.ArgumentNull(queryCommand, "queryCommand");
using (var reader = ExecuteReader(queryCommand, segment, parameters))
{
var wrapper = Provider.GetService <IRecordWrapper>();
#if !N35 && DYNAMIC
TypeDescriptorUtility.AddDefaultDynamicProvider();
while (reader.Read())
{
var expando = new ExpandoObject();
var dictionary = (IDictionary <string, object>)expando;
for (var i = 0; i < reader.FieldCount; i++)
{
dictionary.Add(wrapper.GetFieldName(reader, i), RecordWrapHelper.GetValue(wrapper, reader, i));
}
yield return(expando);
}
#else
var builder = new DataReaderTypeBuilder(reader);
var elementType = builder.CreateType();
while (reader.Read())
{
yield return(elementType.New(reader, wrapper));
}
#endif
}
}
/// <summary>
/// 异步执行查询文本，并返回第一行的第一列。
/// </summary>
/// <param name="queryCommand">查询命令。</param>
/// <param name="parameters">查询参数集合。</param>
/// <returns>第一行的第一列数据。</returns>
public async virtual Task <object> ExecuteScalarAsync(IQueryCommand queryCommand, ParameterCollection parameters = null)
{
Guard.ArgumentNull(queryCommand, "queryCommand");
return(await UsingConnection(() =>
{
using (var command = CreateDbCommand(queryCommand, parameters))
{
try
{
Task <object> result = null;
OnCommandExecuted(command, null, parameters, TimeWatcher.Watch(() => result = command.ExecuteScalarAsync()));
command.SyncParameters(parameters);
command.ClearParameters();
return result;
}
catch (DbException exp)
{
if (ConnectionString.IsTracking && Track != null)
{
Track.Fail(command, exp);
}
throw new CommandException(command, exp);
}
}
}));
}
/// <summary>
/// 根据自定义的SQL语句查询返回一组动态对象。
/// </summary>
/// <param name="queryCommand">查询命令。</param>
/// <param name="segment">数据分段对象。</param>
/// <param name="parameters">查询参数集合。</param>
/// <returns>一个动态对象的枚举器。</returns>
public virtual IEnumerable <dynamic> ExecuteEnumerable(IQueryCommand queryCommand, IDataSegment segment = null, ParameterCollection parameters = null)
{
Guard.ArgumentNull(queryCommand, nameof(queryCommand));
using var reader = ExecuteReader(queryCommand, segment, parameters, CommandBehavior.Default);
var wrapper = Provider.GetService <IRecordWrapper>();
TypeDescriptorUtility.AddDefaultDynamicProvider();
while (reader.Read())
{
var expando = new ExpandoObject();
var dictionary = (IDictionary <string, object>)expando;
for (int i = 0, n = reader.FieldCount; i < n; i++)
{
var name = wrapper.GetFieldName(reader, i);
if (name.Equals("ROW_NUM"))
{
continue;
}
dictionary.Add(wrapper.GetFieldName(reader, i), RecordWrapHelper.GetValue(wrapper, reader, i));
}
yield return(expando);
}
}
/// <summary>
/// 执行查询文本，返回受影响的记录数。
/// </summary>
/// <param name="queryCommand">查询命令。</param>
/// <param name="parameters">查询参数集合。</param>
/// <returns>所影响的记录数。</returns>
public virtual int ExecuteNonQuery(IQueryCommand queryCommand, ParameterCollection parameters = null)
{
Guard.ArgumentNull(queryCommand, nameof(queryCommand));
return(UsingConnection(connection =>
{
using (var command = CreateDbCommand(connection, queryCommand, parameters))
{
try
{
var result = HandleCommandExecute(command, () => command.ExecuteNonQuery());
command.SyncParameters(parameters);
command.ClearParameters();
return result;
}
catch (DbException exp)
{
HandleFailedLog(command, exp);
throw new CommandException(command, exp);
}
}
}, mode: DistributedMode.Master));
}
/// <summary>
/// 异步的，执行查询文本并将结果并返回动态序列。
/// </summary>
/// <param name="queryCommand">查询命令。</param>
/// <param name="segment">数据分段对象。</param>
/// <param name="parameters">查询参数集合。</param>
/// <param name="cancellationToken">取消操作的通知。</param>
/// <returns>一个动态对象的枚举器。</returns>
public virtual async Task <IEnumerable <dynamic> > ExecuteEnumerableAsync(IQueryCommand queryCommand, IDataSegment segment = null, ParameterCollection parameters = null, CancellationToken cancellationToken = default)
{
Guard.ArgumentNull(queryCommand, nameof(queryCommand));
cancellationToken.ThrowIfCancellationRequested();
var result = new List <dynamic>();
using var reader = (InternalDataReader) await ExecuteReaderAsync(queryCommand, segment, parameters, CommandBehavior.Default, cancellationToken);
var wrapper = Provider.GetService <IRecordWrapper>();
TypeDescriptorUtility.AddDefaultDynamicProvider();
while (await reader.ReadAsync(cancellationToken))
{
var expando = new ExpandoObject();
var dictionary = (IDictionary <string, object>)expando;
for (int i = 0, n = reader.FieldCount; i < n; i++)
{
var name = wrapper.GetFieldName(reader, i);
if (name.Equals("ROW_NUM"))
{
continue;
}
dictionary.Add(wrapper.GetFieldName(reader, i), RecordWrapHelper.GetValue(wrapper, reader, i));
}
result.Add(expando);
}
return(result);
}
/// <summary>
/// Resets this enumerator preparing it for a fresh new execution.
/// </summary>
public void Reset()
{
try { if (_Enumerator != null)
{
_Enumerator.Dispose();
}
}
catch { }
try { if (_CoreCommand != null)
{
_CoreCommand.Dispose();
}
}
catch { }
if (_Indented)
{
DebugEx.Unindent();
}
_Indented = false;
_Enumerator = null;
_CoreCommand = null;
_Current = null;
}
/// <summary>
/// 执行查询文本并返回一个 <see cref="IDataReader"/>。
/// </summary>
/// <param name="queryCommand">查询命令。</param>
/// <param name="segment">数据分段对象。</param>
/// <param name="parameters">查询参数集合。</param>
/// <returns>一个 <see cref="IDataReader"/> 对象。</returns>
public virtual IDataReader ExecuteReader(IQueryCommand queryCommand, IDataSegment segment = null, ParameterCollection parameters = null)
{
Guard.ArgumentNull(queryCommand, nameof(queryCommand));
return(UsingConnection(connection =>
{
var command = CreateDbCommand(connection, queryCommand, parameters);
try
{
var cmdBehavior = CommandBehavior.Default;
var context = new CommandContext(this, command, segment, parameters);
HandleSegmentCommand(context);
IDataReader result = HandleCommandExecute(command, () => command.ExecuteReader(cmdBehavior));
command.SyncParameters(parameters);
command.ClearParameters();
return result;
}
catch (DbException exp)
{
HandleFailedLog(command, exp);
throw new CommandException(command, exp);
}
}, mode: DistributedMode.Slave));
}
/// <summary>
/// 执行查询文本并返回一个 <see cref="IDataReader"/>。
/// </summary>
/// <param name="queryCommand">查询命令。</param>
/// <param name="segment">数据分段对象。</param>
/// <param name="parameters">查询参数集合。</param>
/// <returns>一个 <see cref="IDataReader"/> 对象。</returns>
public virtual IDataReader ExecuteReader(IQueryCommand queryCommand, IDataSegment segment = null, ParameterCollection parameters = null)
{
Guard.ArgumentNull(queryCommand, "queryCommand");
return(UsingConnection(() =>
{
var command = CreateDbCommand(queryCommand, parameters);
try
{
var cmdBehavior = CommandBehavior.Default;
IDataReader reader = null;
var context = new CommandContext(this, command, segment, parameters);
OnCommandExecuted(command, segment, parameters, TimeWatcher.Watch(() => ProcessSegmentCommand(context, () => reader = command.ExecuteReader(cmdBehavior))));
command.SyncParameters(parameters);
command.ClearParameters();
return reader;
}
catch (DbException exp)
{
TrackFailedLog(command, exp);
throw new CommandException(command, exp);
}
}));
}
/// <summary>
/// 执行查询文本，返回受影响的记录数。
/// </summary>
/// <param name="queryCommand">查询命令。</param>
/// <param name="parameters">查询参数集合。</param>
/// <returns>所影响的记录数。</returns>
public virtual int ExecuteNonQuery(IQueryCommand queryCommand, ParameterCollection parameters = null)
{
Guard.ArgumentNull(queryCommand, "queryCommand");
return(UsingConnection(() =>
{
using (var command = CreateDbCommand(queryCommand, parameters))
{
try
{
var result = 0;
OnCommandExecuted(command, null, parameters, TimeWatcher.Watch(() => result = command.ExecuteNonQuery()));
command.SyncParameters(parameters);
command.ClearParameters();
return result;
}
catch (DbException exp)
{
TrackFailedLog(command, exp);
throw new CommandException(command, exp);
}
}
}));
}
/// <summary>
/// 执行查询文本并将结果填充到指定的 <see cref="DataTable"/> 对象中。
/// </summary>
/// <param name="queryCommand">查询命令。</param>
/// <param name="tableName"><see cref="DataTable"/> 的名称。</param>
/// <param name="segment">数据分段对象。</param>
/// <param name="parameters">查询参数集合。</param>
/// <returns>一个 <see cref="DataTable"/> 对象。</returns>
public virtual DataTable ExecuteDataTable(IQueryCommand queryCommand, string tableName = null, IDataSegment segment = null, ParameterCollection parameters = null)
{
Guard.ArgumentNull(queryCommand, nameof(queryCommand));
var ds = new DataSet();
FillDataSet(ds, queryCommand, tableName, segment, parameters);
return(ds.Tables.Count == 0 ? null : ds.Tables[0]);
}
public IEnumerable <TR> FindBy <TR>(IQueryCommand <TDomain> queryObject, Expression <Func <TDomain, TR> > projection)
{
var predicateTData = _replaceTypeVisitor.Convert <TDomain, TData, bool>(queryObject.Predicate);
var projectionTData = _replaceTypeVisitor.Convert <TDomain, TData, TR>(projection);
return(Set.Where(predicateTData).Select(projectionTData).ToList());
}
public void Xpto()
{
IDbConnection dbConnection = default(IDbConnection);
List <Temp> temps = dbConnection.Query <Temp>("", null).ToList();
IQueryCommand comparisonOperators = dbConnection.Select().From("SeiLa").Where("x").EqualTo(1);
//List<Temp> enumerable = comparisonOperators.Query<Temp>().ToList();
}
public static Task <T> QuerySingleOrDefaultAsync <T>(this IQueryCommand queryCommand, IDbTransaction transaction = null, int?commandTimeout = null, CommandType?commandType = null)
{
if (queryCommand is FlepperDapperQuery flepperDapperQuery)
{
return(flepperDapperQuery.QuerySingleOrDefaultAsync <T>(transaction, commandTimeout, commandType));
}
throw new NotSupportedException("Only instances of FlepperDapperQuery can execute this method.");
}
public static GridReader QueryMultiple(this IQueryCommand queryCommand, IDbTransaction transaction = null, int?commandTimeout = null, CommandType?commandType = null)
{
if (queryCommand is FlepperDapperQuery flepperDapperQuery)
{
return(flepperDapperQuery.QueryMultiple(transaction, commandTimeout, commandType));
}
throw new NotSupportedException("Only instances of FlepperDapperQuery can execute this method.");
}
//the API
//...
public IDataReader Execute(IQueryCommand cmd)
{
//build the command and execute it
var dbCommand = cmd.BuildCommand();
//...
return(null);
}
public static object QueryFirstOrDefault(this IQueryCommand queryCommand, Type type, IDbTransaction transaction = null, int?commandTimeout = null, CommandType?commandType = null)
{
if (queryCommand is FlepperDapperQuery flepperDapperQuery)
{
return(flepperDapperQuery.QueryFirstOrDefault(type, transaction, commandTimeout, commandType));
}
throw new NotSupportedException("Only instances of FlepperDapperQuery can execute this method.");
}
public IMessageFormater CreateFormaterForCommand(IQueryCommand command)
{
if (command is WallCommand)
{
return new WallMessageFormater(new MessageFormater(new ElapsedTimeMessageFormater()));
}
return new MessageFormater(new ElapsedTimeMessageFormater());
}
public IMessageFormater CreateFormaterForCommand(IQueryCommand command)
{
if (command is WallCommand)
{
return(new WallMessageFormater(new MessageFormater(new ElapsedTimeMessageFormater())));
}
return(new MessageFormater(new ElapsedTimeMessageFormater()));
}
public static IEnumerable <T> Query <T>(this IQueryCommand queryCommand, IDbTransaction transaction = null, bool buffered = true,
int?commandTimeout = null, CommandType?commandType = null)
{
if (queryCommand is FlepperDapperQuery flepperDapperQuery)
{
return(flepperDapperQuery.Query <T>(transaction, buffered, commandTimeout, commandType));
}
throw new NotSupportedException("Only instances of FlepperDapperQuery can execute this method.");
}
public static IEnumerable <TReturn> Query <TReturn>(this IQueryCommand queryCommand, Type[] types, Func <object[], TReturn> map, IDbTransaction transaction = null,
bool buffered = true, string splitOn = "Id", int?commandTimeout = null, CommandType?commandType = null)
{
if (queryCommand is FlepperDapperQuery flepperDapperQuery)
{
return(flepperDapperQuery.Query(types, map, transaction, buffered, splitOn, commandTimeout, commandType));
}
throw new NotSupportedException("Only instances of FlepperDapperQuery can execute this method.");
}
/// <summary>
/// 执行查询文本，并返回第一行的第一列。
/// </summary>
/// <param name="queryCommand">查询命令。</param>
/// <param name="parameters">查询参数集合。</param>
/// <returns>第一行的第一列数据。</returns>
public virtual T ExecuteScalar <T>(IQueryCommand queryCommand, ParameterCollection parameters = null)
{
var result = ExecuteScalar(queryCommand, parameters);
if (result != DBNull.Value)
{
return(result.To <T>());
}
return(default);
public TResult ExecuteQuery <TResult>(IQueryCommand <TResult> command)
{
var handler = dispatcher.GetHandler(command);
if (handler == null)
{
throw new ArgumentNullException("handler");
}
return((TResult)handler.Query(command));
}
/// <summary>
/// Sets the queryParameters into the mainQuery
/// </summary>
/// <param name="mainQuery">the mainQuery</param>
/// <param name="subQueries">all the subQueries</param>
public static void SetQueryParameters(IQueryCommand mainQuery, List <IQueryPart> subQueries)
{
foreach (IQueryPart subQuery in subQueries)
{
foreach (KeyValuePair <string, object> parameter in subQuery.Parameters)
{
mainQuery.AddParameter(parameter.Key, parameter.Value);
}
}
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="map">The map this command will be associated with.</param>
public DataQuery(DataMap <T> map)
: base(map)
{
_Template = map.Link.Query();
if (_Template == null)
{
throw new CannotCreateException(
"Cannot create a template query for this '{0}'.".FormatWith(this));
}
}
/// <summary>
/// 异步执行查询文本并将结果以一个 <see cref="IEnumerable{T}"/> 的序列返回。
/// </summary>
/// <typeparam name="T">查询对象类型。</typeparam>
/// <param name="queryCommand">查询命令。</param>
/// <param name="segment">数据分段对象。</param>
/// <param name="parameters">查询参数集合。</param>
/// <param name="rowMapper">数据行映射器。</param>
/// <param name="cancellationToken">取消操作的通知。</param>
/// <returns>一个 <typeparamref name="T"/> 类型的对象的枚举器。</returns>
public async virtual Task <IEnumerable <T> > ExecuteEnumerableAsync <T>(IQueryCommand queryCommand, IDataSegment segment = null, ParameterCollection parameters = null, IDataRowMapper <T> rowMapper = null, CancellationToken cancellationToken = default)
{
Guard.ArgumentNull(queryCommand, nameof(queryCommand));
rowMapper = rowMapper ?? RowMapperFactory.CreateRowMapper <T>();
rowMapper.RecordWrapper = Provider.GetService <IRecordWrapper>();
var reader = await ExecuteReaderAsync(queryCommand, segment, parameters, cancellationToken);
return(new AsyncEnumerable <T>(this, reader, rowMapper));
}
/// <summary>
/// 执行查询文本并将结果以一个 <see cref="IEnumerable{T}"/> 的序列返回。
/// </summary>
/// <typeparam name="T">查询对象类型。</typeparam>
/// <param name="queryCommand">查询命令。</param>
/// <param name="segment">数据分段对象。</param>
/// <param name="parameters">查询参数集合。</param>
/// <param name="rowMapper">数据行映射器。</param>
/// <returns>一个 <typeparamref name="T"/> 类型的对象的枚举器。</returns>
public virtual IEnumerable <T> ExecuteEnumerable <T>(IQueryCommand queryCommand, IDataSegment segment = null, ParameterCollection parameters = null, IDataRowMapper <T> rowMapper = null)
{
Guard.ArgumentNull(queryCommand, nameof(queryCommand));
rowMapper ??= RowMapperFactory.CreateRowMapper <T>();
rowMapper.RecordWrapper = Provider.GetService <IRecordWrapper>();
using var reader = ExecuteReader(queryCommand, segment, parameters, CommandBehavior.Default);
while (reader.Read())
{
yield return(rowMapper.Map(this, reader));
}
}
/// <summary>
/// 异步执行查询文本并将结果以一个 <see cref="IEnumerable<T>"/> 的序列返回。
/// </summary>
/// <typeparam name="T">查询对象类型。</typeparam>
/// <param name="queryCommand">查询命令。</param>
/// <param name="segment">数据分段对象。</param>
/// <param name="parameters">查询参数集合。</param>
/// <param name="rowMapper">数据行映射器。</param>
/// <returns>一个 <typeparamref name="T"/> 类型的对象的枚举器。</returns>
public async virtual Task <IEnumerable <T> > ExecuteEnumerableAsync <T>(IQueryCommand queryCommand, IDataSegment segment = null, ParameterCollection parameters = null, IDataRowMapper <T> rowMapper = null)
{
Guard.ArgumentNull(queryCommand, "queryCommand");
var reader = ExecuteReaderAsync(queryCommand, segment, parameters);
return(await new Task <IEnumerable <T> >(() =>
{
var list = new List <T>();
rowMapper = rowMapper ?? RowMapperFactory.CreateRowMapper <T>();
rowMapper.RecordWrapper = Provider.GetService <IRecordWrapper>();
return new List <T>(new AsyncEnumerable <T>(reader.Result, rowMapper));
}));
}
public IQueryHandler GetHandler(IQueryCommand query)
{
var interfaces = query.GetType().GetInterfaces();
foreach (var type in interfaces)
{
if (type.IsGenericType && typeof (IQueryCommand).IsAssignableFrom(type))
{
var handlerType = typeof (IQueryHandler<,>).MakeGenericType(query.GetType(),
type.GetGenericArguments()[0]);
return (IQueryHandler) locator.GetInstance(handlerType);
}
}
throw new InvalidOperationException("don't implement IQueryCommand directory, use IQueryCommand<T>");
}
/// <summary>
/// 异步的，执行查询文本并将结果以一个 <see cref="IEnumerable{T}"/> 的序列返回。
/// </summary>
/// <typeparam name="T">查询对象类型。</typeparam>
/// <param name="queryCommand">查询命令。</param>
/// <param name="segment">数据分段对象。</param>
/// <param name="parameters">查询参数集合。</param>
/// <param name="rowMapper">数据行映射器。</param>
/// <param name="cancellationToken">取消操作的通知。</param>
/// <returns>一个 <typeparamref name="T"/> 类型的对象的枚举器。</returns>
public async virtual IAsyncEnumerable <T> ExecuteEnumerableAsync <T>(IQueryCommand queryCommand, IDataSegment segment = null, ParameterCollection parameters = null, IDataRowMapper <T> rowMapper = null, CancellationToken cancellationToken = default)
{
Guard.ArgumentNull(queryCommand, nameof(queryCommand));
rowMapper = rowMapper ?? RowMapperFactory.CreateRowMapper <T>();
rowMapper.RecordWrapper = Provider.GetService <IRecordWrapper>();
using (var reader = (DbDataReader)(await ExecuteReaderAsync(queryCommand, segment, parameters, cancellationToken)))
{
while (await reader.ReadAsync(cancellationToken))
{
yield return(rowMapper.Map(this, reader));
}
}
}
/// <summary>
/// 执行查询文本并将结果以一个 <see cref="IEnumerable<T>"/> 的序列返回。
/// </summary>
/// <typeparam name="T">查询对象类型。</typeparam>
/// <param name="queryCommand">查询命令。</param>
/// <param name="segment">数据分段对象。</param>
/// <param name="parameters">查询参数集合。</param>
/// <param name="rowMapper">数据行映射器。</param>
/// <returns>一个 <typeparamref name="T"/> 类型的对象的枚举器。</returns>
public virtual IEnumerable <T> ExecuteEnumerable <T>(IQueryCommand queryCommand, IDataSegment segment = null, ParameterCollection parameters = null, IDataRowMapper <T> rowMapper = null)
{
Guard.ArgumentNull(queryCommand, "queryCommand");
rowMapper = rowMapper ?? RowMapperFactory.CreateRowMapper <T>();
rowMapper.RecordWrapper = Provider.GetService <IRecordWrapper>();
using (var reader = ExecuteReader(queryCommand, segment, parameters))
{
while (reader.Read())
{
yield return(rowMapper.Map(reader));
}
}
}
public FakeCommandProvider(IDataLink link) { TheCommand = link.Query(); }
public void AddQuery(IQueryCommand command)
{
}
