MultipleRowDbCommandBuilder <OleDbCommand, OleDbParameter> GetByKeyList <T>(AccessObjectName tableName, ColumnMetadata <OleDbType> columnMetadata, IEnumerable <T> keys) { var keyList = keys.AsList(); string where; if (keys.Count() > 1) { where = columnMetadata.SqlName + " IN (" + string.Join(", ", keyList.Select((s, i) => "@Param" + i)) + ")"; } else { where = columnMetadata.SqlName + " = @Param0"; } var parameters = new List <OleDbParameter>(); for (var i = 0; i < keyList.Count; i++) { var param = new OleDbParameter("@Param" + i, keyList[i]); if (columnMetadata.DbType.HasValue) { param.OleDbType = columnMetadata.DbType.Value; } parameters.Add(param); } return(new AccessTableOrView(this, tableName, where, parameters)); }
AccessTableOrView <TObject> OnGetByKey <TObject, TKey>(AccessObjectName tableName, ColumnMetadata <OleDbType> columnMetadata, TKey key) where TObject : class { string where = columnMetadata.SqlName + " = @Param0"; var parameters = new List <OleDbParameter>(); var param = new OleDbParameter("@Param0", key); if (columnMetadata.DbType.HasValue) { param.OleDbType = columnMetadata.DbType.Value; } parameters.Add(param); return(new AccessTableOrView <TObject>(this, tableName, where, parameters)); }
/// <summary> /// Updates 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> public IUpdateManyCommandBuilder <OleDbCommand, OleDbParameter> UpdateSet(AccessObjectName tableName, object newValues, UpdateOptions options = UpdateOptions.None) { return(new AccessUpdateMany(this, tableName, newValues, options)); }
/// <summary> /// Deletes 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 <OleDbCommand, OleDbParameter> DeleteWithFilter(AccessObjectName tableName, object filterValue, FilterOptions filterOptions = FilterOptions.None) { var table = DatabaseMetadata.GetTableOrView(tableName); if (!AuditRules.UseSoftDelete(table)) { return(new AccessDeleteMany(this, tableName, filterValue, filterOptions)); } return(new AccessUpdateMany(this, tableName, null, UpdateOptions.SoftDelete | UpdateOptions.IgnoreRowsAffected).WithFilter(filterValue, filterOptions)); }
public MultipleRowDbCommandBuilder <OleDbCommand, OleDbParameter> DeleteByKeyList <TKey>(AccessObjectName tableName, IEnumerable <TKey> keys, DeleteOptions options = DeleteOptions.None) { var primaryKeys = DatabaseMetadata.GetTableOrView(tableName).Columns.Where(c => c.IsPrimaryKey).ToList(); if (primaryKeys.Count != 1) { throw new MappingException($"DeleteByKey operation isn't allowed on {tableName} because it doesn't have a single primary key."); } var keyList = keys.AsList(); var columnMetadata = primaryKeys.Single(); string where; if (keys.Count() > 1) { where = columnMetadata.SqlName + " IN (" + string.Join(", ", keyList.Select((s, i) => "@Param" + i)) + ")"; } else { where = columnMetadata.SqlName + " = @Param0"; } var parameters = new List <OleDbParameter>(); for (var i = 0; i < keyList.Count; i++) { var param = new OleDbParameter("@Param" + i, keyList[i]); if (columnMetadata.DbType.HasValue) { param.OleDbType = columnMetadata.DbType.Value; } parameters.Add(param); } var table = DatabaseMetadata.GetTableOrView(tableName); if (!AuditRules.UseSoftDelete(table)) { return(new AccessDeleteMany(this, tableName, where, parameters, options)); } UpdateOptions effectiveOptions = UpdateOptions.SoftDelete | UpdateOptions.IgnoreRowsAffected; if (options.HasFlag(DeleteOptions.UseKeyAttribute)) { effectiveOptions = effectiveOptions | UpdateOptions.UseKeyAttribute; } return(new AccessUpdateMany(this, tableName, null, where, parameters, parameters.Count, effectiveOptions)); }
/// <summary> /// Delete multiple rows by key. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="tableName">Name of the table.</param> /// <param name="keys">The keys.</param> /// <returns></returns> /// <remarks>This only works on tables that have a scalar primary key.</remarks> public MultipleRowDbCommandBuilder <OleDbCommand, OleDbParameter> DeleteByKey <T>(AccessObjectName tableName, params T[] keys) where T : struct { return(DeleteByKeyList(tableName, keys)); }
/// <summary> /// Creates a <see cref="AccessDeleteObject{TArgument}" /> used to perform a delete operation. /// </summary> /// <param name="tableName"></param> /// <param name="argumentValue"></param> /// <param name="options"></param> /// <returns></returns> public ObjectDbCommandBuilder <OleDbCommand, OleDbParameter, TArgument> Delete <TArgument>(AccessObjectName tableName, TArgument argumentValue, DeleteOptions options = DeleteOptions.None) where TArgument : class { var table = DatabaseMetadata.GetTableOrView(tableName); if (!AuditRules.UseSoftDelete(table)) { return(new AccessDeleteObject <TArgument>(this, tableName, argumentValue, options)); } UpdateOptions effectiveOptions = UpdateOptions.SoftDelete | UpdateOptions.IgnoreRowsAffected; if (options.HasFlag(DeleteOptions.UseKeyAttribute)) { effectiveOptions = effectiveOptions | UpdateOptions.UseKeyAttribute; } return(new AccessUpdateObject <TArgument>(this, tableName, argumentValue, effectiveOptions)); }
public MultipleRowDbCommandBuilder <OleDbCommand, OleDbParameter> UpdateByKeyList <TArgument, TKey>(AccessObjectName tableName, TArgument newValues, IEnumerable <TKey> keys, UpdateOptions options = UpdateOptions.None) { var primaryKeys = DatabaseMetadata.GetTableOrView(tableName).Columns.Where(c => c.IsPrimaryKey).ToList(); if (primaryKeys.Count != 1) { throw new MappingException($"UpdateByKey operation isn't allowed on {tableName} because it doesn't have a single primary key."); } var keyList = keys.AsList(); var columnMetadata = primaryKeys.Single(); string where; if (keys.Count() > 1) { where = columnMetadata.SqlName + " IN (" + string.Join(", ", keyList.Select((s, i) => "@Param" + i)) + ")"; } else { where = columnMetadata.SqlName + " = @Param0"; } var parameters = new List <OleDbParameter>(); for (var i = 0; i < keyList.Count; i++) { var param = new OleDbParameter("@Param" + i, keyList[i]); if (columnMetadata.DbType.HasValue) { param.OleDbType = columnMetadata.DbType.Value; } parameters.Add(param); } return(new AccessUpdateMany(this, tableName, newValues, where, parameters, parameters.Count, options)); }
/// <summary> /// Delete multiple rows by 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="keys">The keys.</param> /// <returns></returns> /// <remarks>This only works on tables that have a scalar primary key.</remarks> public MultipleRowDbCommandBuilder <OleDbCommand, OleDbParameter> UpdateByKey <TArgument, TKey>(AccessObjectName tableName, TArgument newValues, params TKey[] keys) where TKey : struct { return(UpdateByKeyList(tableName, newValues, keys)); }
/// <summary> /// Returns true if the two objects are equal. /// </summary> /// <param name="other"></param> /// <returns></returns> /// <remarks>This is a case-insensitive comparison.</remarks> public bool Equals(AccessObjectName other) { return this == other; }
ObjectDbCommandBuilder <OleDbCommand, OleDbParameter, TArgument> OnInsertObject <TArgument>(AccessObjectName tableName, TArgument argumentValue, InsertOptions options) where TArgument : class { return(new AccessInsertObject <TArgument>(this, tableName, argumentValue, options)); }
MultipleRowDbCommandBuilder <OleDbCommand, OleDbParameter> OnDeleteMany(AccessObjectName tableName, object filterValue, FilterOptions filterOptions) { return(new AccessDeleteMany(this, tableName, filterValue, filterOptions)); }
MultipleRowDbCommandBuilder <OleDbCommand, OleDbParameter> OnDeleteMany(AccessObjectName tableName, string whereClause, object argumentValue) { return(new AccessDeleteMany(this, tableName, whereClause, argumentValue)); }
/// <summary> /// Returns true if the two objects are equal. /// </summary> /// <param name="other"></param> /// <returns></returns> /// <remarks>This is a case-insensitive comparison.</remarks> public bool Equals(AccessObjectName other) => this == other;
IUpdateManyDbCommandBuilder <OleDbCommand, OleDbParameter> OnUpdateMany(AccessObjectName tableName, object?newValues, UpdateOptions options) { return(new AccessUpdateMany(this, tableName, newValues, options)); }
/// <summary> /// Delete 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 <OleDbCommand, OleDbParameter> UpdateByKey <TArgument>(AccessObjectName tableName, TArgument newValues, string key, UpdateOptions options = UpdateOptions.None) { return(UpdateByKeyList(tableName, newValues, new List <string> { key }, options)); }
/// <summary> /// Creates a <see cref="AccessTableOrView" /> used to directly query a table or view /// </summary> /// <param name="tableOrViewName"></param> /// <returns></returns> public TableDbCommandBuilder <OleDbCommand, OleDbParameter, AccessLimitOption> From(AccessObjectName tableOrViewName) { return(new AccessTableOrView(this, tableOrViewName, null, null)); }
/// <summary> /// Delete multiple rows by 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="keys">The keys.</param> /// <returns></returns> /// <remarks>This only works on tables that have a scalar primary key.</remarks> public MultipleRowDbCommandBuilder <OleDbCommand, OleDbParameter> UpdateByKey <TArgument>(AccessObjectName tableName, TArgument newValues, params string[] keys) { return(UpdateByKeyList(tableName, newValues, keys)); }
/// <summary> /// Creates a <see cref="AccessTableOrView" /> used to directly query a table or view /// </summary> /// <param name="tableOrViewName"></param> /// <param name="whereClause"></param> /// <param name="argumentValue"></param> /// <returns></returns> public TableDbCommandBuilder <OleDbCommand, OleDbParameter, AccessLimitOption> From(AccessObjectName tableOrViewName, string whereClause, object argumentValue) { return(new AccessTableOrView(this, tableOrViewName, whereClause, 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<OleDbCommand, OleDbParameter>.</returns> public SingleRowDbCommandBuilder <OleDbCommand, OleDbParameter> DeleteByKey <T>(AccessObjectName tableName, T key, DeleteOptions options = DeleteOptions.None) where T : struct { return(DeleteByKeyList(tableName, new List <T> { key }, options)); }
/// <summary> /// Creates a <see cref="AccessTableOrView" /> used 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<OleDbCommand, OleDbParameter, AccessLimitOption>.</returns> public TableDbCommandBuilder <OleDbCommand, OleDbParameter, AccessLimitOption> From(AccessObjectName tableOrViewName, object filterValue, FilterOptions filterOptions = FilterOptions.None) { return(new AccessTableOrView(this, tableOrViewName, filterValue, filterOptions)); }
/// <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<OleDbCommand, OleDbParameter>.</returns> public SingleRowDbCommandBuilder <OleDbCommand, OleDbParameter> DeleteByKey(AccessObjectName tableName, string key, DeleteOptions options = DeleteOptions.None) { return(DeleteByKeyList(tableName, new List <string> { key }, options)); }
/// <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 <OleDbCommand, OleDbParameter> GetByKey <TKey>(AccessObjectName tableName, TKey key) where TKey : struct { return(GetByKeyList(tableName, new List <TKey> { key })); }
/// <summary> /// Delete multiple rows by key. /// </summary> /// <param name="tableName">Name of the table.</param> /// <param name="keys">The keys.</param> /// <returns></returns> /// <remarks>This only works on tables that have a scalar primary key.</remarks> public MultipleRowDbCommandBuilder <OleDbCommand, OleDbParameter> DeleteByKey(AccessObjectName tableName, params string[] keys) { return(DeleteByKeyList(tableName, keys)); }
/// <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 <OleDbCommand, OleDbParameter> GetByKey(AccessObjectName tableName, string key) { return(GetByKeyList(tableName, new List <string> { key })); }
/// <summary> /// Deletes 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 <OleDbCommand, OleDbParameter> DeleteWithFilter(AccessObjectName tableName, string whereClause, object argumentValue) { var table = DatabaseMetadata.GetTableOrView(tableName); if (!AuditRules.UseSoftDelete(table)) { return(new AccessDeleteMany(this, tableName, whereClause, argumentValue)); } return(new AccessUpdateMany(this, tableName, null, UpdateOptions.SoftDelete | UpdateOptions.IgnoreRowsAffected).WithFilter(whereClause, argumentValue)); }
/// <summary> /// Gets a set of records by their primary key. /// </summary> /// <typeparam name="TKey"></typeparam> /// <param name="tableName">Name of the table.</param> /// <param name="keys">The keys.</param> /// <returns></returns> /// <remarks>This only works on tables that have a scalar primary key.</remarks> public MultipleRowDbCommandBuilder <OleDbCommand, OleDbParameter> GetByKey <TKey>(AccessObjectName tableName, params TKey[] keys) where TKey : struct { return(GetByKeyList(tableName, keys)); }
/// <summary> /// Updates 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> public IUpdateManyCommandBuilder <OleDbCommand, OleDbParameter> UpdateSet(AccessObjectName tableName, string updateExpression, object updateArgumentValue, UpdateOptions options = UpdateOptions.None) { return(new AccessUpdateMany(this, tableName, updateExpression, updateArgumentValue, options)); }
///// <summary> ///// Creates a <see cref="AccessInsertOrUpdateObject{TArgument}"/> used to perform an "upsert" operation. ///// </summary> ///// <param name="tableName"></param> ///// <param name="argumentValue"></param> ///// <param name="options"></param> ///// <returns></returns> //public ObjectDbCommandBuilder<OleDbCommand, OleDbParameter, TArgument> Upsert<TArgument>(AccessObjectName tableName, TArgument argumentValue, UpsertOptions options = UpsertOptions.None) //where TArgument : class //{ // return new AccessInsertOrUpdateObject<TArgument>(this, tableName, argumentValue, options); //} /// <summary> /// Creates a <see cref="AccessUpdateObject{TArgument}" /> used to perform an update operation. /// </summary> /// <param name="tableName"></param> /// <param name="argumentValue"></param> /// <param name="options"></param> /// <returns></returns> public ObjectDbCommandBuilder <OleDbCommand, OleDbParameter, TArgument> Update <TArgument>(AccessObjectName tableName, TArgument argumentValue, UpdateOptions options = UpdateOptions.None) where TArgument : class { return(new AccessUpdateObject <TArgument>(this, tableName, argumentValue, options)); }
/// <summary> /// Returns true if the two objects are equal. /// </summary> /// <param name="other"></param> /// <returns></returns> /// <remarks>This is a case-insensitive comparison.</remarks> public bool Equals(AccessObjectName other) { return(this == other); }
/// <summary> /// Delete 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<OleDbCommand, OleDbParameter>.</returns> public SingleRowDbCommandBuilder <OleDbCommand, OleDbParameter> UpdateByKey <TArgument, TKey>(AccessObjectName tableName, TArgument newValues, TKey key, UpdateOptions options = UpdateOptions.None) where TKey : struct { return(UpdateByKeyList(tableName, newValues, new List <TKey> { key }, options)); }