/// <summary>
/// This is used to query a scalar function.
/// </summary>
/// <param name="scalarFunctionName">Name of the scalar function.</param>
/// <param name="functionArgumentValue">The function argument.</param>
/// <returns></returns>
public ScalarDbCommandBuilder <AbstractCommand, AbstractParameter> ScalarFunction(AbstractObjectName scalarFunctionName, object functionArgumentValue)
{
return(new AbstractScalarFunction(this, scalarFunctionName, functionArgumentValue));
}
/// <summary>
/// Delete multiple records using a filter object.
/// </summary>
/// <param name="tableName">Name of the table.</param>
/// <param name="filterValue">The filter value.</param>
/// <param name="filterOptions">The options.</param>
public MultipleRowDbCommandBuilder <AbstractCommand, AbstractParameter> DeleteWithFilter(AbstractObjectName tableName, object filterValue, FilterOptions filterOptions = FilterOptions.None)
{
var table = DatabaseMetadata.GetTableOrView(tableName);
if (!AuditRules.UseSoftDelete(table))
{
return(OnDeleteMany(tableName, filterValue, filterOptions));
}
return(OnUpdateMany(tableName, null, UpdateOptions.SoftDelete | UpdateOptions.IgnoreRowsAffected).WithFilter(filterValue, filterOptions));
}
/// <summary>
/// Gets a record by its primary key.
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <param name="tableName">Name of the table.</param>
/// <param name="key">The key.</param>
/// <returns>MultipleRowDbCommandBuilder<OleDbCommand, OleDbParameter>.</returns>
public SingleRowDbCommandBuilder <AbstractCommand, AbstractParameter> GetByKey <TKey>(AbstractObjectName tableName, TKey key)
where TKey : struct
{
return(GetByKeyList(tableName, keys: (IEnumerable <TKey>) new List <TKey> {
key
}));
}
/// <summary>
/// Update a record by its primary key.
/// </summary>
/// <typeparam name="TArgument">The type of the t argument.</typeparam>
/// <typeparam name="TKey"></typeparam>
/// <param name="tableName">Name of the table.</param>
/// <param name="newValues">The new values to use.</param>
/// <param name="key">The key.</param>
/// <param name="options">The options.</param>
/// <returns>MultipleRowDbCommandBuilder<AbstractCommand, AbstractParameter>.</returns>
public SingleRowDbCommandBuilder <AbstractCommand, AbstractParameter> UpdateByKey <TArgument, TKey>(AbstractObjectName tableName, TArgument newValues, TKey key, UpdateOptions options = UpdateOptions.None)
where TKey : struct
{
return(UpdateByKeyList(tableName, newValues, new List <TKey> {
key
}, options));
}
/// <summary>
/// Creates an operation to directly query a table or view
/// </summary>
/// <param name="tableOrViewName"></param>
/// <param name="whereClause"></param>
/// <param name="argumentValue"></param>
/// <returns></returns>
public TableDbCommandBuilder <AbstractCommand, AbstractParameter, AbstractLimitOption> From(AbstractObjectName tableOrViewName, string whereClause, object argumentValue)
{
return(OnFromTableOrView(tableOrViewName, whereClause, argumentValue));
}
/// <summary>
/// Loads a procedure definition and populates it using the parameter object.
/// </summary>
/// <param name="procedureName">Name of the procedure.</param>
/// <param name="argumentValue">The argument value.</param>
/// <returns></returns>
/// <remarks>
/// The procedure's definition is loaded from the database and used to determine which properties on the parameter object to use.
/// </remarks>
public MultipleTableDbCommandBuilder <AbstractCommand, AbstractParameter> Procedure(AbstractObjectName procedureName, object argumentValue)
{
return(new AbstractProcedureCall(this, procedureName, argumentValue));
}
/// <summary>
/// Delete a record by its primary key.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="tableName">Name of the table.</param>
/// <param name="key">The key.</param>
/// <param name="options">The options.</param>
/// <returns>MultipleRowDbCommandBuilder<AbstractCommand, AbstractParameter>.</returns>
public SingleRowDbCommandBuilder <AbstractCommand, AbstractParameter> DeleteByKey <T>(AbstractObjectName tableName, T key, DeleteOptions options = DeleteOptions.None)
where T : struct
{
return(DeleteByKeyList(tableName, new List <T> {
key
}, options));
}
/// <summary>
/// Gets a record by its primary key.
/// </summary>
/// <param name="tableName">Name of the table.</param>
/// <param name="key">The key.</param>
public SingleRowDbCommandBuilder <AbstractCommand, AbstractParameter> GetByKey(AbstractObjectName tableName, string key)
{
return(GetByKey <string>(tableName, key));
}
/// <summary>
/// Update a record by its primary key.
/// </summary>
/// <typeparam name="TArgument">The type of the t argument.</typeparam>
/// <param name="tableName">Name of the table.</param>
/// <param name="newValues">The new values to use.</param>
/// <param name="key">The key.</param>
/// <param name="options">The options.</param>
/// <returns>MultipleRowDbCommandBuilder<OleDbCommand, OleDbParameter>.</returns>
public SingleRowDbCommandBuilder <AbstractCommand, AbstractParameter> UpdateByKey <TArgument>(AbstractObjectName tableName, TArgument newValues, string key, UpdateOptions options = UpdateOptions.None)
{
return(UpdateByKeyList(tableName, newValues, new List <string> {
key
}, options));
}
/// <summary>
/// Creates a command to perform a delete operation.
/// </summary>
/// <param name="tableName"></param>
/// <param name="argumentValue"></param>
/// <param name="options"></param>
/// <returns></returns>
public ObjectDbCommandBuilder <AbstractCommand, AbstractParameter, TArgument> Delete <TArgument>(AbstractObjectName tableName, TArgument argumentValue, DeleteOptions options = DeleteOptions.None)
where TArgument : class
{
var table = DatabaseMetadata.GetTableOrView(tableName);
if (!AuditRules.UseSoftDelete(table))
{
return(OnDeleteObject <TArgument>(tableName, argumentValue, options));
}
UpdateOptions effectiveOptions = UpdateOptions.SoftDelete | UpdateOptions.IgnoreRowsAffected;
if (options.HasFlag(DeleteOptions.UseKeyAttribute))
{
effectiveOptions = effectiveOptions | UpdateOptions.UseKeyAttribute;
}
return(OnUpdateObject <TArgument>(tableName, argumentValue, effectiveOptions));
}
/// <summary>
/// Update multiple records using an update value.
/// </summary>
/// <param name="tableName">Name of the table.</param>
/// <param name="newValues">The new values to use.</param>
/// <param name="options">The options.</param>
/// <remarks>Use .WithFilter to apply a WHERE clause.</remarks>
public IUpdateManyDbCommandBuilder <AbstractCommand, AbstractParameter> UpdateSet(AbstractObjectName tableName, object newValues, UpdateOptions options = UpdateOptions.None)
{
return(OnUpdateMany(tableName, newValues, options));
}
/// <summary>
/// Loads a procedure definition
/// </summary>
/// <param name="procedureName">Name of the procedure.</param>
/// <returns></returns>
public ProcedureDbCommandBuilder <AbstractCommand, AbstractParameter> Procedure(AbstractObjectName procedureName)
{
return(new AbstractProcedureCall(this, procedureName, null));
}
/// <summary>
/// Inserts the batch of records as one operation.
/// </summary>
/// <typeparam name="TObject"></typeparam>
/// <param name="tableName">Name of the table.</param>
/// <param name="objects">The objects to insert.</param>
/// <param name="options">The options.</param>
/// <returns>MultipleRowDbCommandBuilder<SqlCommand, SqlParameter>.</returns>
public InsertBatchResult InsertBatch <TObject>(AbstractObjectName tableName, IEnumerable <TObject> objects, InsertOptions options = InsertOptions.None)
where TObject : class
{
return(OnInsertBatch(tableName, objects, options));
}
/// <summary>
/// Gets a record by its primary key.
/// </summary>
/// <param name="tableName">Name of the table.</param>
/// <param name="key">The key.</param>
/// <returns>MultipleRowDbCommandBuilder<OleDbCommand, OleDbParameter>.</returns>
public SingleRowDbCommandBuilder <AbstractCommand, AbstractParameter> GetByKey(AbstractObjectName tableName, string key)
{
return(GetByKeyList(tableName, keys: (IEnumerable <string>) new List <string> {
key
}));
}
/// <summary>
/// This is used to query a table valued function.
/// </summary>
/// <param name="tableFunctionName">Name of the table function.</param>
/// <returns></returns>
public TableDbCommandBuilder <AbstractCommand, AbstractParameter, AbstractLimitOption> TableFunction(AbstractObjectName tableFunctionName)
{
return(new AbstractTableFunction(this, tableFunctionName, null));
}
/// <summary>
/// Update multiple records using an update expression.
/// </summary>
/// <param name="tableName">Name of the table.</param>
/// <param name="updateExpression">The update expression.</param>
/// <param name="options">The update options.</param>
/// <remarks>Use .WithFilter to apply a WHERE clause.</remarks>
public IUpdateManyDbCommandBuilder <AbstractCommand, AbstractParameter> UpdateSet(AbstractObjectName tableName, string updateExpression, UpdateOptions options = UpdateOptions.None)
{
return(OnUpdateMany(tableName, updateExpression, null, options));
}
/// <summary>
/// This is used to query a table valued function.
/// </summary>
/// <param name="tableFunctionName">Name of the table function.</param>
/// <param name="functionArgumentValue">The function argument.</param>
/// <returns></returns>
public TableDbCommandBuilder <AbstractCommand, AbstractParameter, AbstractLimitOption> TableFunction(AbstractObjectName tableFunctionName, object functionArgumentValue)
{
return(new AbstractTableFunction(this, tableFunctionName, functionArgumentValue));
}
public MultipleRowDbCommandBuilder <AbstractCommand, AbstractParameter> GetByKeyList <TKey>(AbstractObjectName tableName, IEnumerable <TKey> keys)
{
var primaryKeys = DatabaseMetadata.GetTableOrView(tableName).PrimaryKeyColumns;
if (primaryKeys.Count != 1)
{
throw new MappingException($"{nameof(GetByKeyList)} operation isn't allowed on {tableName} because it doesn't have a single primary key. Use DataSource.From instead.");
}
return(OnGetByKeyList <object, TKey>(tableName, primaryKeys.Single(), keys));
}
/// <summary>
/// This is used to query a scalar function.
/// </summary>
/// <param name="scalarFunctionName">Name of the scalar function.</param>
/// <returns></returns>
public ScalarDbCommandBuilder <AbstractCommand, AbstractParameter> ScalarFunction(AbstractObjectName scalarFunctionName)
{
return(new AbstractScalarFunction(this, scalarFunctionName, null));
}
public MultipleRowDbCommandBuilder <AbstractCommand, AbstractParameter, TObject> GetByKeyList <TObject, TKey>(AbstractObjectName tableName, string keyColumn, IEnumerable <TKey> keys)
where TObject : class
{
var primaryKeys = DatabaseMetadata.GetTableOrView(tableName).Columns.Where(c => c.SqlName.Equals(keyColumn, StringComparison.OrdinalIgnoreCase)).ToList();
if (primaryKeys.Count == 0)
{
throw new MappingException($"Cannot find a column named {keyColumn} on table {tableName}.");
}
return(OnGetByKeyList <TObject, TKey>(tableName, primaryKeys.Single(), keys));
}
/// <summary>
/// Delete a record by its primary key.
/// </summary>
/// <param name="tableName">Name of the table.</param>
/// <param name="key">The key.</param>
/// <param name="options">The options.</param>
/// <returns>MultipleRowDbCommandBuilder<AbstractCommand, AbstractParameter>.</returns>
public SingleRowDbCommandBuilder <AbstractCommand, AbstractParameter> DeleteByKey(AbstractObjectName tableName, string key, DeleteOptions options = DeleteOptions.None)
{
return(DeleteByKeyList(tableName, new List <string> {
key
}, options));
}
/// <summary>
/// Creates a operation used to perform an "upsert" operation.
/// </summary>
/// <param name="tableName"></param>
/// <param name="argumentValue"></param>
/// <param name="options"></param>
/// <returns></returns>
public ObjectDbCommandBuilder <AbstractCommand, AbstractParameter, TArgument> Upsert <TArgument>(AbstractObjectName tableName, TArgument argumentValue, UpsertOptions options = UpsertOptions.None)
where TArgument : class
{
return(OnInsertOrUpdateObject <TArgument>(tableName, argumentValue, options));
}
/// <summary>
/// Creates an operation to directly query a table or view
/// </summary>
/// <param name="tableOrViewName"></param>
/// <returns></returns>
public TableDbCommandBuilder <AbstractCommand, AbstractParameter, AbstractLimitOption> From(AbstractObjectName tableOrViewName)
{
return(OnFromTableOrView(tableOrViewName, null, null));
}
TableDbCommandBuilder <AbstractCommand, AbstractParameter, AbstractLimitOption> OnFromTableOrView(AbstractObjectName tableOrViewName, object filterValue, FilterOptions filterOptions) => OnFromTableOrView <object>(tableOrViewName, filterValue, filterOptions);
/// <summary>
/// Creates an operation to directly query a table or view
/// </summary>
/// <param name="tableOrViewName">Name of the table or view.</param>
/// <param name="filterValue">The filter value.</param>
/// <param name="filterOptions">The filter options.</param>
/// <returns>TableDbCommandBuilder<AbstractCommand, AbstractParameter, AbstractLimitOption>.</returns>
public TableDbCommandBuilder <AbstractCommand, AbstractParameter, AbstractLimitOption> From(AbstractObjectName tableOrViewName, object filterValue, FilterOptions filterOptions = FilterOptions.None)
{
return(OnFromTableOrView(tableOrViewName, filterValue, filterOptions));
}
TableDbCommandBuilder <AbstractCommand, AbstractParameter, AbstractLimitOption> OnFromTableOrView(AbstractObjectName tableOrViewName, string?whereClause, object?argumentValue) => OnFromTableOrView <object>(tableOrViewName, whereClause, argumentValue);
/// <summary>
/// Delete multiple records using a where expression.
/// </summary>
/// <param name="tableName">Name of the table.</param>
/// <param name="whereClause">The where clause.</param>
/// <param name="argumentValue">The argument value for the where clause.</param>
public MultipleRowDbCommandBuilder <AbstractCommand, AbstractParameter> DeleteWithFilter(AbstractObjectName tableName, string whereClause, object argumentValue)
{
var table = DatabaseMetadata.GetTableOrView(tableName);
if (!AuditRules.UseSoftDelete(table))
{
return(OnDeleteMany(tableName, whereClause, argumentValue));
}
return(OnUpdateMany(tableName, null, UpdateOptions.SoftDelete | UpdateOptions.IgnoreRowsAffected).WithFilter(whereClause, argumentValue));
}
/// <summary>
/// Update multiple records using an update expression.
/// </summary>
/// <param name="tableName">Name of the table.</param>
/// <param name="updateExpression">The update expression.</param>
/// <param name="updateArgumentValue">The argument value.</param>
/// <param name="options">The update options.</param>
/// <remarks>Use .WithFilter to apply a WHERE clause.</remarks>
public IUpdateManyCommandBuilder <AbstractCommand, AbstractParameter> UpdateSet(AbstractObjectName tableName, string updateExpression, object updateArgumentValue, UpdateOptions options = UpdateOptions.None)
{
return(OnUpdateMany(tableName, updateExpression, updateArgumentValue, options));
}
