public virtual async Task <bool> RemoveExpirationAsync(TKey key)
{
using var cancellationTokenSource = CreateCancellationTokenSource();
await using var connection = await GetConnectionAsync(cancellationTokenSource.Token).ConfigureAwait(false);
var keyColumnValues = KeyMapper.GetColumnValues(key);
var columnValues = new Dictionary <string, object>
{
{ _expirationColumnName, DBNull.Value }
};
await using var command = connection.CreateTextCommand(
DatabaseDriver.GetSqlStatementTemplate(SqlStatement.Update),
new
{
schemaName = DatabaseDriver.ParseIdentifier(Table.Schema ?? DatabaseDriver.DefaultSchema),
tableName = DatabaseDriver.ParseIdentifier(Table.Name),
columnValues = SqlHelper.GetCommaEqualsStatement(DatabaseDriver, columnValues.Keys.ToArray()),
filter = SqlHelper.GetCombinedAndStatement(DatabaseDriver,
SqlHelper.GetAndEqualsStatement(DatabaseDriver, keyColumnValues.Keys.ToArray()),
SqlHelper.GetIsNotNullStatement(DatabaseDriver, columnValues.Keys.ToArray()))
},
keyColumnValues.Concat(columnValues).Select(c => c.ToDbParameter(DatabaseDriver)));
var teste = SqlHelper.GetCombinedAndStatement(DatabaseDriver,
SqlHelper.GetAndEqualsStatement(DatabaseDriver, keyColumnValues.Keys.ToArray()),
SqlHelper.GetIsNotNullStatement(DatabaseDriver, columnValues.Keys.ToArray()));
if (await command.ExecuteNonQueryAsync(cancellationTokenSource.Token).ConfigureAwait(false) == 0)
{
return(false);
}
return(true);
}
public virtual async Task SetAbsoluteKeyExpirationAsync(TKey key, DateTimeOffset expiration)
{
using (var cancellationTokenSource = CreateCancellationTokenSource())
{
using (var connection = await GetConnectionAsync(cancellationTokenSource.Token).ConfigureAwait(false))
{
var keyColumnValues = KeyMapper.GetColumnValues(key);
var columnValues = new Dictionary <string, object>
{
{ _expirationColumnName, expiration }
};
using (var command = connection.CreateTextCommand(
DatabaseDriver.GetSqlStatementTemplate(SqlStatement.Update),
new
{
schemaName = DatabaseDriver.ParseIdentifier(Table.Schema ?? DatabaseDriver.DefaultSchema),
tableName = DatabaseDriver.ParseIdentifier(Table.Name),
columnValues = SqlHelper.GetCommaEqualsStatement(DatabaseDriver, columnValues.Keys.ToArray()),
filter = SqlHelper.GetAndEqualsStatement(DatabaseDriver, keyColumnValues.Keys.ToArray())
},
keyColumnValues.Concat(columnValues).Select(c => c.ToDbParameter(DatabaseDriver))))
{
if (await command.ExecuteNonQueryAsync(cancellationTokenSource.Token).ConfigureAwait(false) ==
0)
{
throw new ArgumentException("Invalid key", nameof(key));
}
}
}
}
}
public virtual async Task SetPropertyValueAsync <TProperty>(TKey key, string propertyName, TProperty propertyValue)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
if (!Table.Columns.ContainsKey(propertyName))
{
throw new ArgumentException(@"Invalid property", nameof(propertyName));
}
if (Table.KeyColumnsNames.Contains(propertyName))
{
throw new ArgumentException(@"A key property cannot be changed", nameof(propertyName));
}
using (var cancellationTokenSource = CreateCancellationTokenSource())
{
using (var connection = await GetConnectionAsync(cancellationTokenSource.Token).ConfigureAwait(false))
{
var keyColumnValues = KeyMapper.GetColumnValues(key);
var columnValues = new Dictionary <string, object> {
{ propertyName, Mapper.DbTypeMapper.ToDbType(propertyValue, Table.Columns[propertyName].Type) }
};
using (var command = connection.CreateMergeCommand(DatabaseDriver, Table.Schema, Table.Name, keyColumnValues, columnValues))
{
if (await command.ExecuteNonQueryAsync(cancellationTokenSource.Token).ConfigureAwait(false) == 0)
{
throw new Exception("The database operation failed");
}
}
}
}
}
public virtual async Task <TProperty> GetPropertyValueOrDefaultAsync <TProperty>(TKey key, string propertyName)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
if (!Table.Columns.ContainsKey(propertyName))
{
throw new ArgumentException(@"Invalid property", nameof(propertyName));
}
using (var cancellationTokenSource = CreateCancellationTokenSource())
{
using (var connection = await GetConnectionAsync(cancellationTokenSource.Token).ConfigureAwait(false))
{
var keyColumnValues = KeyMapper.GetColumnValues(key);
using (var command = connection.CreateSelectTop1Command(DatabaseDriver, Table.Schema, Table.Name, new[] { propertyName }, keyColumnValues))
{
var dbValue = await command.ExecuteScalarAsync(cancellationTokenSource.Token).ConfigureAwait(false);
if (dbValue != null && !(dbValue is DBNull))
{
return((TProperty)Mapper.DbTypeMapper.FromDbType(
dbValue,
Table.Columns[propertyName].Type,
typeof(TValue).GetTypeInfo().GetProperty(propertyName).PropertyType));
}
}
}
}
return(default(TProperty));
}
public virtual async Task MergeAsync(TKey key, TValue value)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
using (var cancellationTokenSource = CreateCancellationTokenSource())
{
using (var connection = await GetConnectionAsync(cancellationTokenSource.Token).ConfigureAwait(false))
{
var keyColumnValues = KeyMapper.GetColumnValues(key);
var columnValues = GetColumnValues(value);
if (columnValues.Any())
{
using (var command = connection.CreateMergeCommand(DatabaseDriver, Table.Schema, Table.Name, keyColumnValues, columnValues))
{
if (await command.ExecuteNonQueryAsync(cancellationTokenSource.Token).ConfigureAwait(false) == 0)
{
throw new Exception("The database operation failed");
}
}
}
}
}
}
public virtual Task <ISet <TItem> > GetValueOrEmptyAsync(TKey key)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
var keyColumnValues = KeyMapper.GetColumnValues(key);
return(new InternalSet(ConnectionString, Table, Mapper, DatabaseDriver, keyColumnValues).AsCompletedTask <ISet <TItem> >());
}
public virtual Task <ISet <TItem> > GetValueOrEmptyAsync(TKey key, CancellationToken cancellationToken = default)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
var keyColumnValues = KeyMapper.GetColumnValues(key);
return(new InternalSet(ConnectionString, Table, Mapper, DatabaseDriver, keyColumnValues)
{
FetchQueryResultTotal = this.FetchQueryResultTotal
}
.AsCompletedTask <ISet <TItem> >());
}
public virtual async Task <ISet <TItem> > GetValueOrDefaultAsync(TKey key)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
using (var cancellationTokenSource = CreateCancellationTokenSource())
{
using (var connection = await GetConnectionAsync(cancellationTokenSource.Token).ConfigureAwait(false))
{
var keyColumnValues = KeyMapper.GetColumnValues(key);
if (!await ContainsAsync(keyColumnValues, connection, cancellationTokenSource.Token))
{
return(null);
}
return(new InternalSet(ConnectionString, Table, Mapper, DatabaseDriver, keyColumnValues));
}
}
}
public virtual async Task <long> IncrementAsync(TKey key, long value)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
using (var cancellationTokenSource = CreateCancellationTokenSource())
{
using (var connection = await GetConnectionAsync(cancellationTokenSource.Token).ConfigureAwait(false))
{
var keyColumnValues = KeyMapper.GetColumnValues(key);
var columnValues = GetColumnValues(value);
using (var command = connection.CreateMergeIncrementCommand(DatabaseDriver, Table.Schema, Table.Name, _numberColumnName, keyColumnValues, columnValues))
{
return((long)await command.ExecuteScalarAsync(cancellationTokenSource.Token).ConfigureAwait(false));
}
}
}
}
public virtual async Task <TValue> GetValueOrDefaultAsync(TKey key)
{
using (var cancellationTokenSource = CreateCancellationTokenSource())
{
using (var connection = await GetConnectionAsync(cancellationTokenSource.Token).ConfigureAwait(false))
{
var keyColumnValues = KeyMapper.GetColumnValues(key);
var selectColumns = Table.Columns.Keys.ToArray();
return(await new DbDataReaderAsyncEnumerable <TValue>(
// ReSharper disable once AccessToDisposedClosure
t => connection.AsCompletedTask(),
c => c.CreateSelectCommand(DatabaseDriver, Table.Schema, Table.Name, keyColumnValues, selectColumns),
Mapper,
selectColumns)
.FirstOrDefaultAsync(cancellationTokenSource.Token)
.ConfigureAwait(false));
}
}
}
public virtual async Task <bool> TryAddAsync(TKey key,
ISet <TItem> value,
bool overwrite = false,
CancellationToken cancellationToken = default)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
var keyColumnValues = GetKeyColumnValues(KeyMapper.GetColumnValues(key));
var internalSet = value as InternalSet;
if (internalSet != null)
{
return(keyColumnValues.SequenceEqual(internalSet.MapKeyColumnValues) && overwrite);
}
using (var cts = CreateCancellationTokenSource())
using (var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cts.Token, cancellationToken))
{
using (var connection = await GetConnectionAsync(linkedCts.Token).ConfigureAwait(false))
{
if (!overwrite &&
await ContainsAsync(keyColumnValues, connection, linkedCts.Token))
{
return(false);
}
using (var transaction = connection.BeginTransaction(_addIsolationLevel))
{
if (overwrite)
{
await
TryRemoveAsync(keyColumnValues, connection, linkedCts.Token, transaction)
.ConfigureAwait(false);
}
var success = true;
var items = await value.AsEnumerableAsync(linkedCts.Token).ConfigureAwait(false);
await items.ForEachAsync(
async item =>
{
if (!success)
{
return;
}
var columnValues = GetColumnValues(key, item);
var itemKeyColumnValues = GetKeyColumnValues(columnValues);
using (
var command = connection.CreateInsertWhereNotExistsCommand(DatabaseDriver, Table.Schema, Table.Name, itemKeyColumnValues, columnValues))
{
command.Transaction = transaction;
success =
await command.ExecuteNonQueryAsync(linkedCts.Token).ConfigureAwait(false) > 0;
}
},
linkedCts.Token);
if (success)
{
transaction.Commit();
}
else
{
transaction.Rollback();
}
return(success);
}
}
}
}