/// <summary>
/// Executes the non query.
/// </summary>
/// <param name="databaseManager">The database manager.</param>
/// <param name="executableCommandInfo">The executable command information.</param>
/// <returns>System.Int32.</returns>
public override int ExecuteNonQuery(IDatabaseManager databaseManager, IExecutableCommandInfo executableCommandInfo)
{
var transformed = _transforms.Aggregate(executableCommandInfo, (current, commandTransform) =>
commandTransform.Transform(current));
return(Source.ExecuteNonQuery(databaseManager, transformed));
}
/// <summary>
/// Executes the scalar asynchronously.
/// </summary>
/// <typeparam name="TReturn">The type of the return.</typeparam>
/// <param name="databaseManager">The database manager.</param>
/// <param name="executableCommandInfo">The executable command information.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>System.Threading.Tasks.Task<TReturn>.</returns>
public override async Task <TReturn> ExecuteScalarAsync <TReturn>(IDatabaseManager databaseManager,
IExecutableCommandInfo executableCommandInfo, CancellationToken cancellationToken)
{
var transformed = _transforms.Aggregate(executableCommandInfo, (current, commandTransform) =>
commandTransform.Transform(current));
return(await Source.ExecuteScalarAsync <TReturn>(databaseManager, transformed, cancellationToken)
.ConfigureAwait(false));
}
/// <summary>
/// Executes the scalar.
/// </summary>
/// <typeparam name="TReturn">The type of the return.</typeparam>
/// <param name="databaseManager">The database manager.</param>
/// <param name="executableCommandInfo">The executable command information.</param>
/// <returns>TReturn.</returns>
public override TReturn ExecuteScalar <TReturn>(IDatabaseManager databaseManager,
IExecutableCommandInfo executableCommandInfo)
{
var transformed = _transforms.Aggregate(executableCommandInfo, (current, commandTransform) =>
commandTransform.Transform(current));
_queryInspector(transformed);
return(Source.ExecuteScalar <TReturn>(databaseManager, transformed));
}
/// <summary>
/// Executes the non query asynchronously.
/// </summary>
/// <param name="databaseManager">The database manager.</param>
/// <param name="executableCommandInfo">The executable command information.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>System.Threading.Tasks.Task<System.Int32>.</returns>
public override async Task <int> ExecuteNonQueryAsync(IDatabaseManager databaseManager,
IExecutableCommandInfo executableCommandInfo, CancellationToken cancellationToken)
{
var transformed = _transforms.Aggregate(executableCommandInfo, (current, commandTransform) =>
commandTransform.Transform(current));
_queryInspector(transformed);
return(await Source.ExecuteNonQueryAsync(databaseManager, transformed, cancellationToken)
.ConfigureAwait(false));
}
/// <summary>
/// Builds the where filter implementation.
/// </summary>
/// <param name="info">The information.</param>
/// <returns>ICommandSingleResultExpression<TFilter, TResult>.</returns>
public IExecutableCommandInfo BuildWhereFilterTransform(IExecutableCommandInfo info)
{
var mappings = info.Parameters
.Join(_processor.CommandResultInfo.RetrieveResultSetMappings(typeof(TResult)).Export(), parameter =>
parameter.SourceColumn, pair => pair.Key,
(parameter, pair) =>
new Tuple <string, Type, string, string>(
pair.Key, //Property Name
pair.Value.PropertyMetadata.PropertyType, //Property Type
parameter.ParameterName, //Parameter Name
pair.Value.ActiveAlias //Result Column Name
))
.GroupJoin(WhereFilterOptions, tuple => tuple.Item1, pair => pair.Key,
(tuple, pairs) => new { tuple, comparer = pairs.Select(kvp => kvp.Value).FirstOrDefault() })
.Select(o => new Tuple <string, Type, string, string, object>(
o.tuple.Item1, //Property Name
o.tuple.Item2, //Property Type
o.tuple.Item3, //Parameter Name
o.tuple.Item4, //Result Column Name
o.comparer ?? GetDefaultCompareMethod(o.tuple.Item2) //Comparer
));
return(new ExecutableCommandInfo
{
CommandText = info.CommandText + string.Concat(mappings.Select(o =>
{
var parameter = info.Parameters.SingleOrDefault(param => param.ParameterName == o.Item3);
var compareFormat = string.Empty;
//If no matching parameter or value is null or DBNull, don't add a comaparison.
if (parameter?.Value != null && parameter.Value != DBNull.Value)
{
if (o.Item5 is CompareMethod)
{
compareFormat = Comparison.GetComparisonFormat((CompareMethod)o.Item5);
}
}
var value = o.Item5 as ComparisonOverride;
compareFormat = value != null ? value.OverrideText : compareFormat;
if (compareFormat.Contains('{'))
{
compareFormat = string.Format(compareFormat, o.Item3, "[" + o.Item4 + "]");
}
return compareFormat;
})),
DbCommandType = info.DbCommandType,
Parameters = info.Parameters
});
}
/// <summary>
/// Executes the non query.
/// </summary>
/// <param name="databaseManager">The database manager.</param>
/// <param name="executableCommandInfo">The executable command information.</param>
/// <returns>System.Int32.</returns>
public override int ExecuteNonQuery(IDatabaseManager databaseManager,
IExecutableCommandInfo executableCommandInfo)
{
int result;
try
{
result = databaseManager.ExecuteNonQuery(
executableCommandInfo.CommandText,
executableCommandInfo.DbCommandType,
Timeout,
executableCommandInfo.Parameters);
}
catch (Exception ex)
{
throw new SusanooExecutionException(ex, executableCommandInfo, Timeout, executableCommandInfo.Parameters);
}
return(result);
}
/// <summary>
/// Executes the scalar.
/// </summary>
/// <typeparam name="TReturn">The type of the return.</typeparam>
/// <param name="databaseManager">The database manager.</param>
/// <param name="executableCommandInfo">The executable command information.</param>
/// <returns>TReturn.</returns>
public override TReturn ExecuteScalar <TReturn>(IDatabaseManager databaseManager,
IExecutableCommandInfo executableCommandInfo)
{
var result = default(TReturn);
try
{
result = databaseManager.ExecuteScalar <TReturn>(
executableCommandInfo.CommandText,
executableCommandInfo.DbCommandType,
Timeout,
executableCommandInfo.Parameters);
}
catch (Exception ex)
{
throw new SusanooExecutionException(ex, executableCommandInfo, Timeout, executableCommandInfo.Parameters);
}
return(result);
}
/// <summary>
/// Executes the scalar asynchronously.
/// </summary>
/// <typeparam name="TReturn">The type of the return.</typeparam>
/// <param name="databaseManager">The database manager.</param>
/// <param name="executableCommandInfo">The executable command information.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>System.Threading.Tasks.Task<TReturn>.</returns>
public override async Task <TReturn> ExecuteScalarAsync <TReturn>(IDatabaseManager databaseManager,
IExecutableCommandInfo executableCommandInfo, CancellationToken cancellationToken)
{
var result = default(TReturn);
try
{
result = await databaseManager.ExecuteScalarAsync <TReturn>(
executableCommandInfo.CommandText,
executableCommandInfo.DbCommandType,
Timeout,
cancellationToken,
executableCommandInfo.Parameters).ConfigureAwait(false);
}
catch (Exception ex)
{
throw new SusanooExecutionException(ex, executableCommandInfo, Timeout, executableCommandInfo.Parameters);
}
return(result);
}
public override int ExecuteNonQuery(IDatabaseManager databaseManager, IExecutableCommandInfo executableCommandInfo)
{
try
{
return(Source.ExecuteNonQuery(databaseManager, executableCommandInfo));
}
catch (SusanooExecutionException ex)
{
try
{
_exceptionInterception(ex);
}
catch (Exception exFault)
{
throw new SusanooExecutionException("Exception interception failed.",
new AggregateException(exFault, ex), ex.Info, ex.Timeout, ex.Parameters);
}
throw;
}
}
/// <summary>
/// Assembles a data CommandBuilder for an ADO.NET provider,
/// executes the CommandBuilder and uses pre-compiled mappings to assign the resultant data to the result object type.
/// </summary>
/// <param name="databaseManager">The database manager.</param>
/// <param name="executableCommandInfo">The executable command information.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task<IEnumerable<TResult>>.</returns>
/// <exception cref="SusanooExecutionException">Any exception is encountered during execution.</exception>
public override async Task <IEnumerable <TResult> > ExecuteAsync(IDatabaseManager databaseManager,
IExecutableCommandInfo executableCommandInfo, CancellationToken cancellationToken)
{
try
{
var records = await databaseManager
.ExecuteDataReaderAsync(
executableCommandInfo.CommandText,
executableCommandInfo.DbCommandType,
Timeout,
cancellationToken,
executableCommandInfo.Parameters)
.ConfigureAwait(false);
var results = CompiledMapping.Deserialize(records, ColumnReport);
if (StreamingScope.Current == null)
{
try
{
results = results?.ToList();
}
finally
{
records.Dispose();
}
}
else
{
StreamingScope.Current.Enlist(records);
}
return(results ?? Enumerable.Empty <TResult>());
}
catch (Exception ex)
{
throw new SusanooExecutionException(ex, executableCommandInfo, Timeout, executableCommandInfo.Parameters);
}
}
public override async Task <TReturn> ExecuteScalarAsync <TReturn>(IDatabaseManager databaseManager,
IExecutableCommandInfo executableCommandInfo, CancellationToken cancellationToken)
{
try
{
return(await Source.ExecuteScalarAsync <TReturn>(databaseManager, executableCommandInfo, cancellationToken)
.ConfigureAwait(false));
}
catch (SusanooExecutionException ex)
{
try
{
_exceptionInterception(ex);
}
catch (Exception exFault)
{
throw new SusanooExecutionException("Exception interception failed.",
new AggregateException(exFault, ex), ex.Info, ex.Timeout, ex.Parameters);
}
throw;
}
}
/// <summary>
/// Assembles a data CommandBuilder for an ADO.NET provider,
/// executes the CommandBuilder and uses pre-compiled mappings to assign the resultant data to the result object type.
/// </summary>
/// <param name="databaseManager">The database manager.</param>
/// <param name="executableCommandInfo">The executable command information.</param>
/// <returns>System.Collections.Generic.IEnumerable<TResult>.</returns>
/// <exception cref="SusanooExecutionException">Any exception is encountered during execution.</exception>
public abstract IEnumerable <TResult> Execute(IDatabaseManager databaseManager,
IExecutableCommandInfo executableCommandInfo);
/// <summary>
/// Assembles a data CommandBuilder for an ADO.NET provider,
/// executes the CommandBuilder and uses pre-compiled mappings to assign the resultant data to the result object type.
/// </summary>
/// <param name="databaseManager">The database manager.</param>
/// <param name="executableCommandInfo">The executable command information.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task<IEnumerable<TResult>>.</returns>
public abstract Task <IResultSetCollection> ExecuteAsync(IDatabaseManager databaseManager,
IExecutableCommandInfo executableCommandInfo,
CancellationToken cancellationToken);
/// <summary>
/// Executes the CommandBuilder using a provided database manager and optionally a filter to read parameters from and explicit
/// parameters.
/// </summary>
/// <param name="databaseManager">The database manager.</param>
/// <param name="executableCommandInfo">The executable command information.</param>
/// <returns>IResultSetCollection.</returns>
/// <exception cref="SusanooExecutionException">Any exception occured during execution.</exception>
public abstract IResultSetCollection Execute(IDatabaseManager databaseManager,
IExecutableCommandInfo executableCommandInfo);
/// <summary>
/// Executes the non query asynchronously.
/// </summary>
/// <param name="databaseManager">The database manager.</param>
/// <param name="executableCommandInfo">The executable command information.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>System.Threading.Tasks.Task<System.Int32>.</returns>
public abstract Task <int> ExecuteNonQueryAsync(IDatabaseManager databaseManager,
IExecutableCommandInfo executableCommandInfo, CancellationToken cancellationToken);
public override IEnumerable <TResult> Execute(IDatabaseManager databaseManager, IExecutableCommandInfo executableCommandInfo)
{
var key = executableCommandInfo.GetDeterministicKey();
var result = _cacheProvider.GetValue <IEnumerable <TResult> >(key);
if (result == null)
{
result = Source.Execute(databaseManager, executableCommandInfo);
if (_expiryPeriod != System.Threading.Timeout.InfiniteTimeSpan)
{
_cacheProvider.SetValue(key, result, _expiryPeriod);
}
else
{
_cacheProvider.SetValue(key, result);
}
}
return(result);
}
/// <summary>
/// Assembles a data CommandBuilder for an ADO.NET provider,
/// executes the CommandBuilder and uses pre-compiled mappings to assign the resultant data to the result object type.
/// </summary>
/// <param name="databaseManager">The database manager.</param>
/// <param name="executableCommandInfo">The executable command information.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task<IEnumerable<TResult>>.</returns>
public override async Task <IResultSetCollection> ExecuteAsync(IDatabaseManager databaseManager, IExecutableCommandInfo executableCommandInfo,
CancellationToken cancellationToken)
{
var transformed = _transforms.Aggregate(executableCommandInfo, (current, commandTransform) =>
commandTransform.Transform(current));
return(await Source.ExecuteAsync(databaseManager, transformed, cancellationToken));
}
/// <summary>
/// Executes the CommandBuilder using a provided database manager and optionally a filter to read parameters from and explicit
/// parameters.
/// </summary>
/// <param name="databaseManager">The database manager.</param>
/// <param name="executableCommandInfo">The executable command information.</param>
/// <returns>IResultSetCollection.</returns>
/// <exception cref="SusanooExecutionException">Any exception occured during execution.</exception>
public override IResultSetCollection Execute(IDatabaseManager databaseManager, IExecutableCommandInfo executableCommandInfo)
{
var transformed = _transforms.Aggregate(executableCommandInfo, (current, commandTransform) =>
commandTransform.Transform(current));
return(Source.Execute(databaseManager, transformed));
}
public override async Task <IResultSetCollection> ExecuteAsync(IDatabaseManager databaseManager, IExecutableCommandInfo executableCommandInfo,
CancellationToken cancellationToken)
{
try
{
return(await Source.ExecuteAsync(databaseManager, executableCommandInfo, cancellationToken));
}
catch (SusanooExecutionException ex)
{
try
{
_exceptionHandler(ex);
}
catch (Exception exFault)
{
throw new SusanooExecutionException("Exception interception failed.", new AggregateException(exFault, ex), ex.Info, ex.Timeout, ex.Parameters);
}
throw;
}
}
/// <summary>
/// Executes the scalar asynchronously.
/// </summary>
/// <typeparam name="TReturn">The type of the return.</typeparam>
/// <param name="databaseManager">The database manager.</param>
/// <param name="executableCommandInfo">The executable command information.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>System.Threading.Tasks.Task<TReturn>.</returns>
public abstract Task <TReturn> ExecuteScalarAsync <TReturn>(IDatabaseManager databaseManager,
IExecutableCommandInfo executableCommandInfo, CancellationToken cancellationToken);
/// <summary>
/// Executes the non query.
/// </summary>
/// <param name="databaseManager">The database manager.</param>
/// <param name="executableCommandInfo">The executable command information.</param>
/// <returns>System.Int32.</returns>
public abstract int ExecuteNonQuery(IDatabaseManager databaseManager,
IExecutableCommandInfo executableCommandInfo);
/// <summary>
/// Executes the scalar.
/// </summary>
/// <typeparam name="TReturn">The type of the return.</typeparam>
/// <param name="databaseManager">The database manager.</param>
/// <param name="executableCommandInfo">The executable command information.</param>
/// <returns>TReturn.</returns>
public abstract TReturn ExecuteScalar <TReturn>(IDatabaseManager databaseManager,
IExecutableCommandInfo executableCommandInfo);
/// <summary>
/// Executes the CommandBuilder using a provided database manager and optionally a filter to read parameters from and explicit
/// parameters.
/// </summary>
/// <param name="databaseManager">The database manager.</param>
/// <param name="executableCommandInfo">The executable command information.</param>
/// <returns>Tuple<
/// IEnumerable<TResult1>,
/// IEnumerable<TResult2>>.</returns>
/// <exception cref="SusanooExecutionException">Any exception occured during execution.</exception>
public override IResultSetCollection Execute(IDatabaseManager databaseManager,
IExecutableCommandInfo executableCommandInfo)
{
var results = new IEnumerable[_mappers.Length];
IResultSetCollection finalResults;
try
{
var record = databaseManager
.ExecuteDataReader(
executableCommandInfo.CommandText,
executableCommandInfo.DbCommandType,
Timeout,
executableCommandInfo.Parameters);
var ix = 0;
do
{
results[ix] = _mappers[ix].Deserialize(record, RetrieveColumnIndexInfo());
ix++;
} while (ix < results.Length);
if (StreamingScope.Current == null)
{
try
{
for (int i = 0; i < results.Length; i++)
{
results[i] = results[i].Cast <object>().ToList();
if (!record.NextResult())
{
for (int j = i + 1; j < results.Length; j++)
{
results[j] = null;
}
break;
}
}
finalResults = new ResultSetCollection(results, null);
}
finally
{
record.Dispose();
}
}
else
{
StreamingScope.Current.Enlist(record);
finalResults = new ResultSetCollection(results, record);
}
}
catch (Exception ex)
{
throw new SusanooExecutionException(ex, executableCommandInfo, Timeout, executableCommandInfo.Parameters);
}
return(finalResults);
}
/// <summary>
/// Assembles a data CommandBuilder for an ADO.NET provider,
/// executes the CommandBuilder and uses pre-compiled mappings to assign the resultant data to the result object type.
/// </summary>
/// <param name="databaseManager">The database manager.</param>
/// <param name="executableCommandInfo">The executable command information.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task<IEnumerable<TResult>>.</returns>
/// <exception cref="SusanooExecutionException">Any exception is encountered during execution.</exception>
public abstract Task <IEnumerable <TResult> > ExecuteAsync(IDatabaseManager databaseManager,
IExecutableCommandInfo executableCommandInfo, CancellationToken cancellationToken);
