/// <summary>
/// Execute the SQL query asynchronously and return the result. Use the provided result
/// materializer to read the IDataReader and map to result objects. Maps internally to
/// a call to IDbCommand.ExecuteReader()
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="runner"></param>
/// <param name="query"></param>
/// <param name="reader"></param>
/// <returns></returns>
public static Task <T> QueryAsync <T>(this ISqlRunner runner, ISqlQuerySimple query, IResultMaterializer <T> reader, CancellationToken cancellationToken = new CancellationToken())
{
Argument.NotNull(runner, nameof(runner));
Argument.NotNull(query, nameof(query));
Argument.NotNull(reader, nameof(reader));
return(runner.ExecuteAsync(c => new SqlQuerySimpleStrategy().ExecuteAsync(query, reader, c, 0, cancellationToken)));
}
/// <summary>
/// Execute the SQL query asynchronously and return the result. Use the provided result
/// materializer to read the IDataReader and map to result objects. Maps internally to a
/// call to IDbCommand.ExecuteReader()
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="runner"></param>
/// <param name="query"></param>
/// <param name="reader"></param>
/// <returns></returns>
public static T Query <T>(this ISqlRunner runner, ISqlQuerySimple query, IResultMaterializer <T> reader)
{
Argument.NotNull(runner, nameof(runner));
Argument.NotNull(query, nameof(query));
Argument.NotNull(reader, nameof(reader));
return(runner.Execute(c => new SqlQuerySimpleStrategy().Execute(query, reader, c, 0)));
}
public string Stringify <T>(ISqlQuerySimple <T> query)
{
var dummy = new DummyCommandAsync(new DummyDbCommand());
new SqlQuerySimpleStrategy().SetupCommand(query, dummy);
return(_stringifier.Stringify(dummy));
}
public SqlQuerySimpleCombined(ISqlQuerySimple query, IResultMaterializer <T> materializer, bool cacheMappings)
{
Argument.NotNull(query, nameof(query));
Argument.NotNull(materializer, nameof(materializer));
_query = query;
_materializer = materializer;
_cacheMappings = cacheMappings;
}
public T Execute <T>(ISqlQuerySimple query, IResultMaterializer <T> queryReader, IExecutionContext context, int index)
{
context.StartSetupCommand(index);
using var dbCommand = context.CreateCommand();
if (!SetupCommand(query, dbCommand))
{
context.MarkAborted();
return(default);
/// <summary>
/// Execute the SQL query and return a stream of results. Maps internally to a call to
/// IDbCommand.ExecuteReader(). The returned stream object must be disposed when it is
/// finished being used.
/// </summary>
/// <param name="runner"></param>
/// <param name="query"></param>
/// <returns></returns>
public static IDataResultsStream QueryStream(this ISqlRunner runner, ISqlQuerySimple query)
{
Argument.NotNull(runner, nameof(runner));
Argument.NotNull(query, nameof(query));
var context = runner.CreateExecutionContext();
context.OpenConnection();
return(new SqlQuerySimpleStrategy().ExecuteStream(query, context));
}
public ISqlResultPromise <T> Add <T>(ISqlQuerySimple query, IResultMaterializer <T> reader)
{
Argument.NotNull(query, nameof(query));
Argument.NotNull(reader, nameof(reader));
var promise = new SqlResultPromise <T>();
AddExecutor((c, i) =>
{
var result = new SqlQuerySimpleStrategy().Execute(query, reader, c, i);
promise.SetValue(result);
});
return(promise);
}
public SqlQueryFromSimple(ISqlQuerySimple simple)
{
Argument.NotNull(simple, nameof(simple));
_simple = simple;
}
/// <summary>
/// Execute the query object and return the result. Maps internally to a call to
/// IDbCommand.ExecuteReader()
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="runner"></param>
/// <param name="query"></param>
/// <returns></returns>
public static T Query <T>(this ISqlRunner runner, ISqlQuerySimple <T> query)
{
Argument.NotNull(runner, nameof(runner));
return(runner.Query(query, query));
}
public static ISqlQuerySimple <T> Combine <T>(ISqlQuerySimple query, Func <IDataResults, T> materialize, bool cacheMappings = false) => new SqlQuerySimpleCombined <T>(query, new DelegateResultMaterializer <T>(materialize), cacheMappings);
public static ISqlQuerySimple <T> Combine <T>(ISqlQuerySimple query, IResultMaterializer <T> materializer, bool cacheMappings = false) => new SqlQuerySimpleCombined <T>(query, materializer, cacheMappings);
public static ISqlQuery <T> FromSimple <T>(ISqlQuerySimple <T> simple) => new SqlQueryFromSimple <T>(simple);
public static ISqlQuery FromSimple(ISqlQuerySimple simple) => new SqlQueryFromSimple(simple);
/// <summary>
/// Execute the SQL query asynchronously and return a stream of results. Maps internally
/// to a call to IDbCommand.ExecuteReader(). The returned stream object must be disposed
/// when it is finished being used.
/// </summary>
/// <param name="runner"></param>
/// <param name="query"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public static async Task <IDataResultsStream> QueryStreamAsync(this ISqlRunner runner, ISqlQuerySimple query, CancellationToken cancellationToken = new CancellationToken())
{
Argument.NotNull(runner, nameof(runner));
Argument.NotNull(query, nameof(query));
var context = runner.CreateExecutionContext();
await context.OpenConnectionAsync(cancellationToken).ConfigureAwait(false);
return(await new SqlQuerySimpleStrategy().ExecuteStreamAsync(query, context, cancellationToken).ConfigureAwait(false));
}
public ISqlResultPromise <T> Add <T>(ISqlQuerySimple <T> query) => Add(query, query);
