/// <summary>
/// Great of huge result sets, process one row at the time
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cmd"></param>
/// <param name="processor">Result processor</param>
/// <param name="mapper"></param>
/// <param name="firstRowOnly"></param>
public static void QueryAndProcess <T>(this DbCommand cmd, Func <T, bool> processor, Func <DbDataReader, T> mapper = null,
bool firstRowOnly = false)
{
try
{
CommandBehavior behavior = firstRowOnly ? CommandBehavior.SingleRow : CommandBehavior.Default;
using (var reader = cmd.ExecuteReader(behavior))
{
SqlFuManager.Config.OnCommand(cmd);
while (reader.Read())
{
if (!processor(SqlFuManager.GetMapper(mapper, cmd.CommandText)(reader)))
{
break;
}
}
}
}
catch (DbException ex)
{
SqlFuManager.Config.OnException(cmd, ex);
throw;
}
}
/// <summary>
/// Executes an async query then processes each result
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cmd"></param>
/// <param name="cancellation"></param>
/// <param name="processor">Delegate to process a result item. Return false from delegate to end the query</param>
/// <param name="mapper"></param>
/// <param name="firstRowOnly"></param>
/// <returns></returns>
public static async Task QueryAndProcessAsync <T>(this DbCommand cmd, CancellationToken cancellation, Func <T, bool> processor, Func <DbDataReader, T> mapper = null,
bool firstRowOnly = false)
{
try
{
CommandBehavior behavior = firstRowOnly ? CommandBehavior.SingleRow : CommandBehavior.Default;
using (var reader = await cmd.ExecuteReaderAsync(behavior, cancellation).ConfigureAwait(false))
{
SqlFuManager.Config.OnCommand(cmd);
while (await reader.ReadAsync(cancellation).ConfigureAwait(false))
{
if (!processor(SqlFuManager.GetMapper(mapper, cmd.CommandText)(reader)))
{
break;
}
}
}
}
catch (DbException ex)
{
SqlFuManager.Config.OnException(cmd, ex);
throw;
}
}
public Task <DbConnection> CreateAsync(CancellationToken cancel, DbConnection db = null)
{
if (db != null)
{
return(Task.FromResult((DbConnection) new SqlFuConnection(_provider, db, SqlFuManager.Config.TransientErrorsStrategyFactory)));
}
return(SqlFuManager.OpenConnectionAsync(_provider, _connectionString, cancel));
}
public DbConnection Create(DbConnection db = null)
{
if (db != null)
{
return(new SqlFuConnection(_provider, db, SqlFuManager.Config.TransientErrorsStrategyFactory));
}
return(SqlFuManager.OpenConnection(_provider, _connectionString));
}
public Task <DbConnection> CreateAsync(CancellationToken cancel, DbConnection db = null)
{
if (db != null)
{
return(Task.FromResult((DbConnection) new SqlFuConnection(db, _provider)));
}
return(SqlFuManager.OpenConnectionAsync(_provider, _connectionString, cancel));
}
public DbConnection Create(DbConnection db = null)
{
if (db != null)
{
return(new SqlFuConnection(db, _provider));
}
return(SqlFuManager.OpenConnection(_provider, _connectionString));
}
public DbConnection Create(DbConnection db = null)
{
if (db == null)
{
return(SqlFuManager.OpenConnection(_provider, _connectionString));
}
if (db is SqlFuConnection)
{
return(db);
}
return(new SqlFuConnection(_provider, db, Configuration));
}
/// <summary>
/// Gets one result value
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cmd"></param>
/// <param name="converter"></param>
/// <returns></returns>
public static T GetValue <T>(this DbCommand cmd, Func <object, T> converter = null)
{
try
{
object rez = cmd.ExecuteScalar();
SqlFuManager.Config.OnCommand(cmd);
return(SqlFuManager.GetConverter(converter)(rez));
}
catch (DbException ex)
{
SqlFuManager.Config.OnException(cmd, ex);
throw;
}
}
public static async Task <T> GetValueAsync <T>(this DbCommand cmd, CancellationToken token, Func <object, T> converter = null)
{
try
{
object rez = await cmd.ExecuteScalarAsync(token).ConfigureAwait(false);
SqlFuManager.Config.OnCommand(cmd);
return(SqlFuManager.GetConverter(converter)(rez));
}
catch (DbException ex)
{
SqlFuManager.Config.OnException(cmd, ex);
throw;
}
}
/// <summary>
/// Great of huge result sets, process one row at the time
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cmd"></param>
/// <param name="processor">Result processor</param>
/// <param name="mapper"></param>
/// <param name="firstRowOnly"></param>
public static void QueryAndProcess <T>(this DbCommand cmd, Func <T, bool> processor, Func <DbDataReader, T> mapper = null,
bool firstRowOnly = false)
{
var fuCommand = cmd.CastAs <SqlFuCommand>();
var strat = fuCommand.GetErrorsStrategy();
CommandBehavior behavior = firstRowOnly ? CommandBehavior.SingleRow : CommandBehavior.Default;
SqlFuCommand.HandleTransients(cmd, () =>
{
using (var reader = cmd.ExecuteReader(behavior))
{
while (reader.Read())
{
if (!processor(SqlFuManager.GetMapper(mapper, cmd.CommandText)(reader)))
{
break;
}
}
}
}, strat, fuCommand.Provider);
}
/// <summary>
/// Executes an async query then processes each result
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cmd"></param>
/// <param name="cancellation"></param>
/// <param name="processor">Delegate to process a result item. Return false from delegate to end the query</param>
/// <param name="mapper"></param>
/// <param name="firstRowOnly"></param>
/// <returns></returns>
public static Task QueryAndProcessAsync <T>(this DbCommand cmd, CancellationToken cancellation, Func <T, bool> processor, Func <DbDataReader, T> mapper = null,
bool firstRowOnly = false)
{
var fuCommand = cmd.CastAs <SqlFuCommand>();
var strat = fuCommand.GetErrorsStrategy();
CommandBehavior behavior = firstRowOnly ? CommandBehavior.SingleRow : CommandBehavior.Default;
return(SqlFuCommand.HandleTransientsAsync(cmd, async(c) =>
{
using (var reader = await cmd.ExecuteReaderAsync(behavior, c).ConfigureFalse())
{
while (await reader.ReadAsync(c).ConfigureFalse())
{
if (!processor(SqlFuManager.GetMapper(mapper, cmd.CommandText)(reader)))
{
break;
}
}
}
}, strat, fuCommand.Provider, cancellation));
}
public Task <DbConnection> CreateAsync(CancellationToken cancel, string cnxString)
{
return(SqlFuManager.OpenConnectionAsync(_provider, cnxString ?? _connectionString, cancel));
}
public DbConnection Create(string cnxString)
{
return(SqlFuManager.OpenConnection(_provider, cnxString ?? _connectionString));
}
/// <summary>
/// Gets one result value
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cmd"></param>
/// <param name="converter"></param>
/// <returns></returns>
public static T GetValue <T>(this DbCommand cmd, Func <object, T> converter = null)
{
return(SqlFuManager.GetConverter(converter)(cmd.ExecuteScalar()));
}
public static async Task <T> GetValueAsync <T>(this DbCommand cmd, CancellationToken token, Func <object, T> converter = null)
{
return(SqlFuManager.GetConverter(converter)(await cmd.ExecuteScalarAsync(token).ConfigureAwait(false)));
}
