/// <summary>
/// Bulk insert an instance of <see cref="DbDataReader"/> object into the database.
/// </summary>
/// <typeparam name="TEntity">The type of the data entity object.</typeparam>
/// <param name="repository">The instance of <see cref="DbRepository{TDbConnection}"/> object.</param>
/// <param name="reader">The <see cref="DbDataReader"/> object to be used in the bulk-insert operation.</param>
/// <param name="mappings">The list of the columns to be used for mappings. If this parameter is not set, then all columns will be used for mapping.</param>
/// <param name="options">The bulk-copy options to be used.</param>
/// <param name="batchSize">The size per batch to be used.</param>
/// <param name="transaction">The transaction to be used.</param>
/// <returns>The number of rows affected by the execution.</returns>
public static int BulkInsert <TEntity>(this DbRepository <SqlConnection> repository,
DbDataReader reader,
IEnumerable <BulkInsertMapItem> mappings = null,
SqlBulkCopyOptions?options = null,
int?batchSize = null,
SqlTransaction transaction = null)
where TEntity : class
{
// Create a connection
var connection = (transaction?.Connection ?? repository.CreateConnection());
try
{
// Call the method
return(connection.BulkInsert <TEntity>(reader: reader,
mappings: mappings,
options: options,
bulkCopyTimeout: repository.CommandTimeout,
batchSize: batchSize,
transaction: transaction));
}
catch
{
// Throw back the error
throw;
}
finally
{
// Dispose the connection
if (repository.ConnectionPersistency == ConnectionPersistency.PerCall)
{
if (transaction == null)
{
connection.Dispose();
}
}
}
}
/// <summary>
/// Inserts a list of entities into the target table by bulk. Underneath this operation is a call directly to the existing
/// <see cref="NpgsqlConnection.BeginBinaryExport(string)"/> method via the 'BinaryImport' extended method.
/// </summary>
/// <typeparam name="TEntity">The type of the entity.</typeparam>
/// <param name="repository">The instance of <see cref="DbRepository{TDbConnection}"/> object.</param>
/// <param name="tableName">The name of the target table from the database.</param>
/// <param name="entities">The list of entities to be bulk-inserted to the target table.
/// This can be an <see cref="IEnumerable{T}"/> of the following objects (<typeparamref name="TEntity"/> (as class/model), <see cref="ExpandoObject"/>,
/// <see cref="IDictionary{TKey, TValue}"/> (of <see cref="string"/>/<see cref="object"/>) and Anonymous Types).</param>
/// <param name="mappings">The list of mappings to be used. If not specified, only the matching properties/columns from the target table will be used. (This is not an entity mapping)</param>
/// <param name="bulkCopyTimeout">The timeout expiration of the operation (see <see cref="NpgsqlBinaryImporter.Timeout"/>).</param>
/// <param name="batchSize">The size per batch to be sent to the database. If not specified, all the rows of the table will be sent together in one-go.</param>
/// <param name="identityBehavior">The behavior of how the identity column would work during the operation.</param>
/// <param name="pseudoTableType">The value that defines whether an actual or temporary table will be created for the pseudo-table.</param>
/// <param name="transaction">The current transaction object in used. If not specified, an implicit transaction will be created and used.</param>
/// <returns>The number of rows that has been inserted into the target table.</returns>
public static int BinaryBulkInsert <TEntity>(this DbRepository <NpgsqlConnection> repository,
string tableName,
IEnumerable <TEntity> entities,
IEnumerable <NpgsqlBulkInsertMapItem> mappings = null,
int?bulkCopyTimeout = null,
int?batchSize = null,
BulkImportIdentityBehavior identityBehavior = default,
BulkImportPseudoTableType pseudoTableType = default,
NpgsqlTransaction transaction = null)
where TEntity : class
{
// Create a connection
var connection = (transaction?.Connection ?? repository.CreateConnection());
try
{
// Call the method
return(connection.BinaryBulkInsert <TEntity>(tableName: (tableName ?? ClassMappedNameCache.Get <TEntity>()),
entities: entities,
mappings: mappings,
bulkCopyTimeout: bulkCopyTimeout,
batchSize: batchSize,
identityBehavior: identityBehavior,
pseudoTableType: pseudoTableType,
transaction: transaction));
}
finally
{
// Dispose the connection
if (repository.ConnectionPersistency == ConnectionPersistency.PerCall)
{
if (transaction == null)
{
connection.Dispose();
}
}
}
}
/// <summary>
/// Inserts the rows of the <see cref="DataTable"/> into the target table by bulk. It uses the <see cref="DataTable.TableName"/> property
/// as the target table. Underneath this operation is a call directly to the existing <see cref="NpgsqlConnection.BeginBinaryExport(string)"/> method.
/// </summary>
/// <param name="repository">The instance of <see cref="DbRepository{TDbConnection}"/> object.</param>
/// <param name="table">The source <see cref="DataTable"/> object that contains the rows to be bulk-inserted to the target table.</param>
/// <param name="rowState">The state of the rows to be bulk-inserted. If not specified, all the rows of the table will be used.</param>
/// <param name="mappings">The list of mappings to be used. If not specified, only the matching properties/columns from the target table will be used. (This is not an entity mapping)</param>
/// <param name="bulkCopyTimeout">The timeout expiration of the operation (see <see cref="NpgsqlBinaryImporter.Timeout"/>).</param>
/// <param name="batchSize">The size per batch to be sent to the database. If not specified, all the rows of the table will be sent together in one-go.</param>
/// <param name="identityBehavior">The behavior of how the identity column would work during the operation.</param>
/// <param name="pseudoTableType">The value that defines whether an actual or temporary table will be created for the pseudo-table.</param>
/// <param name="transaction">The current transaction object in used. If not specified, an implicit transaction will be created and used.</param>
/// <returns>The number of rows that has been inserted into the target table.</returns>
public static int BinaryBulkInsert(this DbRepository <NpgsqlConnection> repository,
DataTable table,
DataRowState?rowState = null,
IEnumerable <NpgsqlBulkInsertMapItem> mappings = null,
int?bulkCopyTimeout = null,
int?batchSize = null,
BulkImportIdentityBehavior identityBehavior = default,
BulkImportPseudoTableType pseudoTableType = default,
NpgsqlTransaction transaction = null)
{
// Create a connection
var connection = (transaction?.Connection ?? repository.CreateConnection());
try
{
// Call the method
return(connection.BinaryBulkInsert(tableName: table?.TableName,
table: table,
rowState: rowState,
mappings: mappings,
bulkCopyTimeout: bulkCopyTimeout,
batchSize: batchSize,
identityBehavior: identityBehavior,
pseudoTableType: pseudoTableType,
transaction: transaction));
}
finally
{
// Dispose the connection
if (repository.ConnectionPersistency == ConnectionPersistency.PerCall)
{
if (transaction == null)
{
connection.Dispose();
}
}
}
}
/// <summary>
/// Update the existing rows via <see cref="DbDataReader"/> by bulk. Underneath this operation is a call directly to the existing
/// <see cref="NpgsqlConnection.BeginBinaryExport(string)"/> method via the 'BinaryImport' extended method.
/// </summary>
/// <param name="repository">The instance of <see cref="DbRepository{TDbConnection}"/> object.</param>
/// <param name="tableName">The name of the target table from the database.</param>
/// <param name="reader">The instance of <see cref="DbDataReader"/> object that contains the rows to be bulk-updated to the target table.</param>
/// <param name="qualifiers">The list of qualifier fields to be used during the operation. Ensure to target the indexed columns to make the execution more performant. If not specified, the primary key will be used.</param>
/// <param name="mappings">The list of mappings to be used. If not specified, only the matching properties/columns from the target table will be used. (This is not the entity mappings, but is working on top of it)</param>
/// <param name="bulkCopyTimeout">The timeout expiration of the operation (see <see cref="NpgsqlBinaryImporter.Timeout"/>).</param>
/// <param name="keepIdentity">A value that indicates whether the existing identity property values from the entities will be kept during the operation.</param>
/// <param name="pseudoTableType">The value that defines whether an actual or temporary table will be created for the pseudo-table.</param>
/// <param name="transaction">The current transaction object in used. If not specified, an implicit transaction will be created and used.</param>
/// <returns>The number of rows that has been updated into the target table.</returns>
public static int BinaryBulkUpdate(this DbRepository <NpgsqlConnection> repository,
string tableName,
DbDataReader reader,
IEnumerable <Field> qualifiers = null,
IEnumerable <NpgsqlBulkInsertMapItem> mappings = null,
int?bulkCopyTimeout = null,
bool keepIdentity = false,
BulkImportPseudoTableType pseudoTableType = default,
NpgsqlTransaction transaction = null)
{
// Create a connection
var connection = (transaction?.Connection ?? repository.CreateConnection());
try
{
// Call the method
return(connection.BinaryBulkUpdate(tableName: tableName,
reader: reader,
qualifiers: qualifiers,
mappings: mappings,
bulkCopyTimeout: bulkCopyTimeout,
keepIdentity: keepIdentity,
pseudoTableType: pseudoTableType,
transaction: transaction));
}
finally
{
// Dispose the connection
if (repository.ConnectionPersistency == ConnectionPersistency.PerCall)
{
if (transaction == null)
{
connection.Dispose();
}
}
}
}
/// <summary>
/// Inserts the rows of the <see cref="DbDataReader"/> into the target table by bulk in an asynchronous way. Underneath this operation is a call directly to the existing
/// <see cref="NpgsqlConnection.BeginBinaryExport(string)"/> method.
/// </summary>
/// <param name="repository">The instance of <see cref="DbRepository{TDbConnection}"/> object.</param>
/// <param name="tableName">The name of the target table from the database.</param>
/// <param name="reader">The instance of <see cref="DbDataReader"/> object that contains the rows to be bulk-inserted to the target table.</param>
/// <param name="mappings">The list of mappings to be used. If not specified, only the matching properties/columns from the target table will be used. (This is not an entity mapping)</param>
/// <param name="bulkCopyTimeout">The timeout expiration of the operation (see <see cref="NpgsqlBinaryImporter.Timeout"/>).</param>
/// <param name="identityBehavior">The behavior of how the identity column would work during the operation.</param>
/// <param name="pseudoTableType">The value that defines whether an actual or temporary table will be created for the pseudo-table.</param>
/// <param name="transaction">The current transaction object in used. If not specified, an implicit transaction will be created and used.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> object to be used during the asynchronous operation.</param>
/// <returns>The number of rows that has been inserted into the target table.</returns>
public static async Task <int> BinaryBulkInsertAsync(this DbRepository <NpgsqlConnection> repository,
string tableName,
DbDataReader reader,
IEnumerable <NpgsqlBulkInsertMapItem> mappings = null,
int?bulkCopyTimeout = null,
BulkImportIdentityBehavior identityBehavior = default,
BulkImportPseudoTableType pseudoTableType = default,
NpgsqlTransaction transaction = null,
CancellationToken cancellationToken = default)
{
// Create a connection
var connection = (transaction?.Connection ?? repository.CreateConnection());
try
{
// Call the method
return(await connection.BinaryBulkInsertAsync(tableName : tableName,
reader : reader,
mappings : mappings,
bulkCopyTimeout : bulkCopyTimeout,
identityBehavior : identityBehavior,
pseudoTableType : pseudoTableType,
transaction : transaction,
cancellationToken : cancellationToken));
}
finally
{
// Dispose the connection
if (repository.ConnectionPersistency == ConnectionPersistency.PerCall)
{
if (transaction == null)
{
connection.Dispose();
}
}
}
}
/// <summary>
/// Bulk insert an instance of <see cref="DbDataReader"/> object into the database in an asynchronous way.
/// </summary>
/// <param name="repository">The instance of <see cref="DbRepository{TDbConnection}"/> object.</param>
/// <param name="tableName">The target table for bulk-insert operation.</param>
/// <param name="reader">The <see cref="DbDataReader"/> object to be used in the bulk-insert operation.</param>
/// <param name="mappings">The list of the columns to be used for mappings. If this parameter is not set, then all columns will be used for mapping.</param>
/// <param name="options">The bulk-copy options to be used.</param>
/// <param name="batchSize">The size per batch to be used.</param>
/// <param name="transaction">The transaction to be used.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> object to be used during the asynchronous operation.</param>
/// <returns>The number of rows affected by the execution.</returns>
public static async Task <int> BulkInsertAsync(this DbRepository <SqlConnection> repository,
string tableName,
DbDataReader reader,
IEnumerable <BulkInsertMapItem> mappings = null,
SqlBulkCopyOptions?options = null,
int?batchSize = null,
SqlTransaction transaction = null,
CancellationToken cancellationToken = default)
{
// Create a connection
var connection = (transaction?.Connection ?? repository.CreateConnection());
try
{
// Call the method
return(await connection.BulkInsertAsync(tableName : tableName,
reader : reader,
mappings : mappings,
options : options,
bulkCopyTimeout : repository.CommandTimeout,
batchSize : batchSize,
transaction : transaction,
cancellationToken : cancellationToken));
}
finally
{
// Dispose the connection
if (repository.ConnectionPersistency == ConnectionPersistency.PerCall)
{
if (transaction == null)
{
connection.Dispose();
}
}
}
}
