/// <summary>
/// Set command parameters value mapped to Row
/// </summary>
internal void SetColumnParametersValues(DbCommand command, SyncRow row)
{
if (row.Table == null)
{
throw new ArgumentException("Schema table columns does not correspond to row values");
}
var schemaTable = row.Table;
foreach (DbParameter parameter in command.Parameters)
{
// foreach parameter, check if we have a column
if (!string.IsNullOrEmpty(parameter.SourceColumn))
{
var column = schemaTable.Columns.FirstOrDefault(sc => sc.ColumnName.Equals(parameter.SourceColumn, SyncGlobalization.DataSourceStringComparison));
if (column != null)
{
object value = row[column] ?? DBNull.Value;
DbTableManagerFactory.SetParameterValue(command, parameter.ParameterName, value);
}
}
}
// return value
var syncRowCountParam = DbTableManagerFactory.GetParameter(command, "sync_row_count");
if (syncRowCountParam != null)
{
syncRowCountParam.Direction = ParameterDirection.Output;
}
}
/// <summary>
/// Set common parameters to SelectChanges Sql command
/// </summary>
private void SetSelectChangesCommonParameters(SyncContext context, SyncTable syncTable, Guid?excludingScopeId, bool isNew, long lastTimestamp, DbCommand selectIncrementalChangesCommand)
{
// Generate the isNewScope Flag.
var isNewScope = isNew ? 1 : 0;
var isReinit = context.SyncType == SyncType.Reinitialize ? 1 : 0;
switch (context.SyncWay)
{
case SyncWay.Upload:
// Overwrite if we are in Reinitialize mode (not RenitializeWithUpload)
isNewScope = context.SyncType == SyncType.Reinitialize ? 1 : isNewScope;
lastTimestamp = context.SyncType == SyncType.Reinitialize ? 0 : lastTimestamp;
isReinit = context.SyncType == SyncType.Reinitialize ? 1 : 0;
break;
case SyncWay.Download:
// Ovewrite on bot Reinitialize and ReinitializeWithUpload
isNewScope = context.SyncType != SyncType.Normal ? 1 : isNewScope;
lastTimestamp = context.SyncType != SyncType.Normal ? 0 : lastTimestamp;
isReinit = context.SyncType != SyncType.Normal ? 1 : 0;
break;
default:
break;
}
// Set the parameters
DbTableManagerFactory.SetParameterValue(selectIncrementalChangesCommand, "sync_min_timestamp", lastTimestamp);
DbTableManagerFactory.SetParameterValue(selectIncrementalChangesCommand, "sync_scope_id", excludingScopeId.HasValue ? (object)excludingScopeId.Value : DBNull.Value);
// Check filters
SyncFilter tableFilter = null;
// Sqlite does not have any filter, since he can't be server side
if (this.CanBeServerProvider)
{
tableFilter = syncTable.GetFilter();
}
var hasFilters = tableFilter != null;
if (!hasFilters)
{
return;
}
// context parameters can be null at some point.
var contexParameters = context.Parameters ?? new SyncParameters();
foreach (var filterParam in tableFilter.Parameters)
{
var parameter = contexParameters.FirstOrDefault(p =>
p.Name.Equals(filterParam.Name, SyncGlobalization.DataSourceStringComparison));
object val = parameter?.Value;
DbTableManagerFactory.SetParameterValue(selectIncrementalChangesCommand, filterParam.Name, val);
}
}
/// <summary>
/// Add common parameters which could be part of the command
/// if not found, no set done
/// </summary>
private void AddScopeParametersValues(DbCommand command, Guid?id, long lastTimestamp, bool isDeleted, bool forceWrite)
{
// Dotmim.Sync parameters
DbTableManagerFactory.SetParameterValue(command, "sync_force_write", (forceWrite ? 1 : 0));
DbTableManagerFactory.SetParameterValue(command, "sync_min_timestamp", lastTimestamp);
DbTableManagerFactory.SetParameterValue(command, "sync_scope_id", id.HasValue ? (object)id.Value : DBNull.Value);
DbTableManagerFactory.SetParameterValue(command, "sync_row_is_tombstone", isDeleted);
}
/// <summary>
/// Delete all metadatas from one table before a timestamp limit
/// </summary>
internal async Task <int> DeleteMetadatasAsync(long timestampLimit)
{
using (var command = this.GetCommand(DbCommandType.DeleteMetadata))
{
if (command == null)
{
throw new MissingCommandException(DbCommandType.DeleteMetadata.ToString());
}
// Deriving Parameters
await this.SetCommandParametersAsync(DbCommandType.DeleteMetadata, command).ConfigureAwait(false);
// Set the special parameters for delete metadata
DbTableManagerFactory.SetParameterValue(command, "sync_row_timestamp", timestampLimit);
var alreadyOpened = Connection.State == ConnectionState.Open;
if (!alreadyOpened)
{
await this.Connection.OpenAsync().ConfigureAwait(false);
}
if (Transaction != null)
{
command.Transaction = Transaction;
}
var metadataDeletedRowsCount = await command.ExecuteNonQueryAsync().ConfigureAwait(false);
// Check if we have a return value instead
var syncRowCountParam = DbTableManagerFactory.GetParameter(command, "sync_row_count");
if (syncRowCountParam != null)
{
metadataDeletedRowsCount = (int)syncRowCountParam.Value;
}
if (!alreadyOpened)
{
Connection.Close();
}
return(metadataDeletedRowsCount);
}
}
/// <summary>
/// Delete all metadatas from one table before a timestamp limit
/// </summary>
internal async Task <int> DeleteMetadatasAsync(long timestampLimit, DbConnection connection, DbTransaction transaction)
{
var command = await this.PrepareCommandAsync(DbCommandType.DeleteMetadata, connection, transaction);
// Set the special parameters for delete metadata
DbTableManagerFactory.SetParameterValue(command, "sync_row_timestamp", timestampLimit);
var metadataDeletedRowsCount = await command.ExecuteNonQueryAsync().ConfigureAwait(false);
// Check if we have a return value instead
var syncRowCountParam = DbTableManagerFactory.GetParameter(command, "sync_row_count");
if (syncRowCountParam != null)
{
metadataDeletedRowsCount = (int)syncRowCountParam.Value;
}
return(metadataDeletedRowsCount);
}
