InternalGetOperationAsync(ServerScopeInfo serverScopeInfo, ClientScopeInfo clientScopeInfo, SyncContext context, DbConnection connection, DbTransaction transaction, CancellationToken cancellationToken, IProgress <ProgressArgs> progress) { // Create the message to be sent var httpMessage = new HttpMessageOperationRequest(context, clientScopeInfo); // serialize message var serializer = this.SerializerFactory.GetSerializer <HttpMessageOperationRequest>(); var binaryData = await serializer.SerializeAsync(httpMessage); // No batch size submitted here, because the schema will be generated in memory and send back to the user. var response = await this.httpRequestHandler.ProcessRequestAsync (this.HttpClient, context, this.ServiceUri, binaryData, HttpStep.GetOperation, this.SerializerFactory, this.Converter, 0, this.SyncPolicy, cancellationToken, progress).ConfigureAwait(false); HttpMessageOperationResponse operationResponse = null; using (var streamResponse = await response.Content.ReadAsStreamAsync().ConfigureAwait(false)) { if (streamResponse.CanRead) { operationResponse = await this.SerializerFactory.GetSerializer <HttpMessageOperationResponse>().DeserializeAsync(streamResponse); } } if (operationResponse == null) { throw new ArgumentException("Http Message content for Get Operation scope can't be null"); } // Return scopes and new shema return(context, operationResponse.SyncOperation); }
public async Task <List <ServerScopeInfo> > GetAllServerScopesAsync(string scopeName, DbConnection connection, DbTransaction transaction) { var tableName = $"{scopeTableName.Unquoted().Normalized().ToString()}_server"; List <ServerScopeInfo> scopes = new List <ServerScopeInfo>(); var commandText = $@"SELECT sync_scope_name , sync_scope_schema , sync_scope_setup , sync_scope_version , sync_scope_last_clean_timestamp FROM `{tableName}` WHERE sync_scope_name = @sync_scope_name"; using (var command = new MySqlCommand(commandText, (MySqlConnection)connection, (MySqlTransaction)transaction)) { var p = command.CreateParameter(); p.ParameterName = "@sync_scope_name"; p.Value = scopeName; p.DbType = DbType.String; command.Parameters.Add(p); using (DbDataReader reader = await command.ExecuteReaderAsync().ConfigureAwait(false)) { if (reader.HasRows) { // read only the first one while (reader.Read()) { var scopeInfo = new ServerScopeInfo(); scopeInfo.Name = reader["sync_scope_name"] as String; scopeInfo.Schema = reader["sync_scope_schema"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSet>((string)reader["sync_scope_schema"]); scopeInfo.Setup = reader["sync_scope_setup"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSetup>((string)reader["sync_scope_setup"]); scopeInfo.Version = reader["sync_scope_version"] as string; scopeInfo.LastCleanupTimestamp = reader["sync_scope_last_clean_timestamp"] != DBNull.Value ? (long)reader["sync_scope_last_clean_timestamp"] : 0L; scopes.Add(scopeInfo); } } } return(scopes); } }
public virtual async Task <ServerScopeInfo> InsertOrUpdateServerScopeInfoAsync(ServerScopeInfo serverScopeInfo) { var command = connection.CreateCommand(); if (transaction != null) { command.Transaction = transaction; } bool alreadyOpened = connection.State == ConnectionState.Open; try { if (!alreadyOpened) { await connection.OpenAsync().ConfigureAwait(false); } var tableName = $"{scopeTableName.Unquoted().Normalized().ToString()}_server"; command.CommandText = $@" MERGE {tableName} AS ""base"" USING ( SELECT @sync_scope_name AS sync_scope_name, @sync_scope_schema AS sync_scope_schema, @sync_scope_setup AS sync_scope_setup, @sync_scope_version AS sync_scope_version, @sync_scope_last_clean_timestamp AS sync_scope_last_clean_timestamp ) AS ""changes"" ON ""base"".""sync_scope_name"" = ""changes"".""sync_scope_name"" WHEN NOT MATCHED THEN INSERT (""sync_scope_name"", ""sync_scope_schema"", ""sync_scope_setup"", ""sync_scope_version"", ""sync_scope_last_clean_timestamp"") VALUES (""changes"".""sync_scope_name"", ""changes"".""sync_scope_schema"", ""changes"".""sync_scope_setup"", ""changes"".""sync_scope_version"", ""changes"".""sync_scope_last_clean_timestamp"") WHEN MATCHED THEN UPDATE SET ""sync_scope_name"" = ""changes"".""sync_scope_name"", ""sync_scope_schema"" = ""changes"".""sync_scope_schema"", ""sync_scope_setup"" = ""changes"".""sync_scope_setup"", ""sync_scope_version"" = ""changes"".""sync_scope_version"", ""sync_scope_last_clean_timestamp"" = ""changes"".""sync_scope_last_clean_timestamp"" OUTPUT INSERTED.""sync_scope_name"", INSERTED.""sync_scope_schema"", INSERTED.""sync_scope_setup"", INSERTED.""sync_scope_version"", INSERTED.""sync_scope_last_clean_timestamp""; "; var p = command.CreateParameter(); p.ParameterName = "@sync_scope_name"; p.Value = serverScopeInfo.Name; p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_schema"; p.Value = serverScopeInfo.Schema == null ? DBNull.Value : (object)JsonConvert.SerializeObject(serverScopeInfo.Schema); p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_setup"; p.Value = serverScopeInfo.Setup == null ? DBNull.Value : (object)JsonConvert.SerializeObject(serverScopeInfo.Setup); p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_version"; p.Value = string.IsNullOrEmpty(serverScopeInfo.Version) ? DBNull.Value : (object)serverScopeInfo.Version; p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_last_clean_timestamp"; p.Value = serverScopeInfo.LastCleanupTimestamp; p.DbType = DbType.Int64; command.Parameters.Add(p); using (var reader = await command.ExecuteReaderAsync().ConfigureAwait(false)) { if (reader.HasRows) { while (reader.Read()) { serverScopeInfo.Name = reader["sync_scope_name"] as string; serverScopeInfo.Schema = reader["sync_scope_schema"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSet>((string)reader["sync_scope_schema"]); serverScopeInfo.Setup = reader["sync_scope_setup"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSetup>((string)reader["sync_scope_setup"]); serverScopeInfo.Version = reader["sync_scope_version"] as string; serverScopeInfo.LastCleanupTimestamp = reader["sync_scope_last_clean_timestamp"] != DBNull.Value ? (long)reader["sync_scope_last_clean_timestamp"] : 0; } } } return(serverScopeInfo); } catch (Exception ex) { Debug.WriteLine($"Error during CreateTableScope : {ex}"); throw; } finally { if (!alreadyOpened && connection.State != ConnectionState.Closed) { connection.Close(); } if (command != null) { command.Dispose(); } } }
public async Task <ServerScopeInfo> InsertOrUpdateServerScopeInfoAsync(ServerScopeInfo serverScopeInfo, DbConnection connection, DbTransaction transaction) { bool exist; var tableName = $"{scopeTableName.Unquoted().Normalized().ToString()}_server"; var commandText = $@"Select count(*) from `{tableName}` where sync_scope_name = @sync_scope_name"; using (var command = new MySqlCommand(commandText, (MySqlConnection)connection, (MySqlTransaction)transaction)) { var p = command.CreateParameter(); p.ParameterName = "@sync_scope_name"; p.Value = serverScopeInfo.Name; p.DbType = DbType.String; command.Parameters.Add(p); exist = ((long)await command.ExecuteScalarAsync().ConfigureAwait(false)) > 0; } string stmtText = exist ? $"Update `{tableName}` set sync_scope_schema=@sync_scope_schema, sync_scope_setup=@sync_scope_setup, sync_scope_version=@sync_scope_version, sync_scope_last_clean_timestamp=@sync_scope_last_clean_timestamp where sync_scope_name=@sync_scope_name" : $"Insert into `{tableName}` (sync_scope_name, sync_scope_schema, sync_scope_setup, sync_scope_version, sync_scope_last_clean_timestamp) values (@sync_scope_name, @sync_scope_schema, @sync_scope_setup, @sync_scope_version, @sync_scope_last_clean_timestamp)"; using (var command = new MySqlCommand(stmtText, (MySqlConnection)connection, (MySqlTransaction)transaction)) { var p = command.CreateParameter(); p.ParameterName = "@sync_scope_name"; p.Value = serverScopeInfo.Name; p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_schema"; p.Value = serverScopeInfo.Schema == null ? DBNull.Value : (object)JsonConvert.SerializeObject(serverScopeInfo.Schema); p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_setup"; p.Value = serverScopeInfo.Setup == null ? DBNull.Value : (object)JsonConvert.SerializeObject(serverScopeInfo.Setup); p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_version"; p.Value = serverScopeInfo.Version; p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_last_clean_timestamp"; p.Value = serverScopeInfo.LastCleanupTimestamp; p.DbType = DbType.Int64; command.Parameters.Add(p); using (DbDataReader reader = command.ExecuteReader()) { if (reader.HasRows) { while (reader.Read()) { serverScopeInfo.Name = reader["sync_scope_name"] as string; serverScopeInfo.Schema = reader["sync_scope_schema"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSet>((string)reader["sync_scope_schema"]); serverScopeInfo.Setup = reader["sync_scope_setup"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSetup>((string)reader["sync_scope_setup"]); serverScopeInfo.Version = reader["sync_scope_version"] as string; serverScopeInfo.LastCleanupTimestamp = reader["sync_scope_last_clean_timestamp"] != DBNull.Value ? (long)reader["sync_scope_last_clean_timestamp"] : 0L; } } } return(serverScopeInfo); } }
public Task <ServerScopeInfo> InsertOrUpdateServerScopeInfoAsync(ServerScopeInfo serverScopeInfo) => Task.FromResult(serverScopeInfo);
/// <summary> /// We can't get changes from server, from a web client orchestrator /// </summary> public override Task <(long RemoteClientTimestamp, BatchInfo ServerBatchInfo, DatabaseChangesSelected ServerChangesSelected)> GetChangesAsync(ScopeInfo clientScope, ServerScopeInfo serverScope = null, CancellationToken cancellationToken = default, IProgress <ProgressArgs> progress = null) => throw new NotImplementedException();
public Task <ServerScopeInfo> InsertOrUpdateServerScopeInfoAsync(ServerScopeInfo serverScopeInfo, DbConnection connection, DbTransaction transaction) => Task.FromResult(serverScopeInfo);
public async Task <List <ServerScopeInfo> > GetAllServerScopesAsync(string scopeName) { var command = connection.CreateCommand(); if (transaction != null) { command.Transaction = transaction; } bool alreadyOpened = connection.State == ConnectionState.Open; var tableName = $"{scopeTableName.Unquoted().Normalized().ToString()}_server"; List <ServerScopeInfo> scopes = new List <ServerScopeInfo>(); try { if (!alreadyOpened) { await connection.OpenAsync().ConfigureAwait(false); } command.CommandText = $@"SELECT sync_scope_name , sync_scope_schema , sync_scope_setup , sync_scope_version , sync_scope_last_clean_timestamp FROM `{tableName}` WHERE sync_scope_name = @sync_scope_name"; var p = command.CreateParameter(); p.ParameterName = "@sync_scope_name"; p.Value = scopeName; p.DbType = DbType.String; command.Parameters.Add(p); using (DbDataReader reader = await command.ExecuteReaderAsync().ConfigureAwait(false)) { if (reader.HasRows) { // read only the first one while (reader.Read()) { var scopeInfo = new ServerScopeInfo(); scopeInfo.Name = reader["sync_scope_name"] as String; scopeInfo.Schema = reader["sync_scope_schema"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSet>((string)reader["sync_scope_schema"]); scopeInfo.Setup = reader["sync_scope_setup"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSetup>((string)reader["sync_scope_setup"]); scopeInfo.Version = reader["sync_scope_version"] as string; scopeInfo.LastCleanupTimestamp = reader["sync_scope_last_clean_timestamp"] != DBNull.Value ? (long)reader["sync_scope_last_clean_timestamp"] : 0L; scopes.Add(scopeInfo); } } } return(scopes); } catch (Exception ex) { Debug.WriteLine($"Error during GetAllScopes : {ex}"); throw; } finally { if (!alreadyOpened && connection.State != ConnectionState.Closed) { connection.Close(); } if (command != null) { command.Dispose(); } } }
public override Task <bool> IsOutDated(ScopeInfo clientScopeInfo, ServerScopeInfo serverScopeInfo, CancellationToken cancellationToken = default, IProgress <ProgressArgs> progress = null) => base.IsOutDated(clientScopeInfo, serverScopeInfo, cancellationToken, progress);
public Task <ServerScopeInfo> InsertOrUpdateServerScopeInfoAsync(ServerScopeInfo serverScopeInfo, DbConnection connection, DbTransaction transaction) => throw new NotImplementedException();
public Migration(ClientScopeInfo oldClientScopeInfo, ServerScopeInfo newServerScopeInfo) { this.oldClientScopeInfo = oldClientScopeInfo; this.newServerScopeInfo = newServerScopeInfo; }
public async Task LocalOrchestrator_MultipleScopes_Check_Metadatas_Are_Deleted() { var dbName = HelperDatabase.GetRandomName("tcp_lo_"); await HelperDatabase.CreateDatabaseAsync(ProviderType.Sql, dbName, true); var cs = HelperDatabase.GetConnectionString(ProviderType.Sql, dbName); var sqlProvider = new SqlSyncProvider(cs); var ctx = new AdventureWorksContext((dbName, ProviderType.Sql, sqlProvider), true, false); await ctx.Database.EnsureCreatedAsync(); var options = new SyncOptions(); var localOrchestrator = new LocalOrchestrator(sqlProvider, options); var setup = new SyncSetup(this.Tables); var setup2 = new SyncSetup(this.Tables); setup2.Filters.Add("Customer", "EmployeeID"); var schema = await localOrchestrator.GetSchemaAsync(setup); var localScopeInfo1 = await localOrchestrator.GetClientScopeInfoAsync(); var localScopeInfo2 = await localOrchestrator.GetClientScopeInfoAsync("A"); var serverScope1 = new ServerScopeInfo { Name = localScopeInfo1.Name, Schema = schema, Setup = setup, Version = localScopeInfo1.Version }; var serverScope2 = new ServerScopeInfo { Name = localScopeInfo2.Name, Schema = schema, Setup = setup2, Version = localScopeInfo2.Version }; // Provision two scopes (already tested in previous test) localScopeInfo1 = await localOrchestrator.ProvisionAsync(serverScope1); localScopeInfo2 = await localOrchestrator.ProvisionAsync(serverScope2); Assert.NotNull(localScopeInfo1.Setup); Assert.NotNull(localScopeInfo1.Schema); Assert.NotNull(localScopeInfo2.Setup); Assert.NotNull(localScopeInfo2.Schema); // Deprovision await localOrchestrator.DeprovisionAsync("A"); foreach (var table in localScopeInfo1.Setup.Tables) { var tableName = table.TableName; var schemaName = table.SchemaName; foreach (var objectSpType in Enum.GetValues(typeof(Builders.DbStoredProcedureType))) { var spType = (Builders.DbStoredProcedureType)objectSpType; var exists1 = await localOrchestrator.ExistStoredProcedureAsync( localScopeInfo1, tableName, schemaName, spType); var exists2 = await localOrchestrator.ExistStoredProcedureAsync( localScopeInfo2, tableName, schemaName, spType); if (spType == Builders.DbStoredProcedureType.SelectChangesWithFilters || spType == Builders.DbStoredProcedureType.SelectInitializedChangesWithFilters) { Assert.False(exists1); } else { Assert.True(exists1); } Assert.False(exists2); } foreach (var objectSpType in Enum.GetValues(typeof(Builders.DbTriggerType))) { var trigType = (Builders.DbTriggerType)objectSpType; var existsTrig1 = await localOrchestrator.ExistTriggerAsync(localScopeInfo1, tableName, schemaName, trigType); var existsTrig2 = await localOrchestrator.ExistTriggerAsync(localScopeInfo2, tableName, schemaName, trigType); Assert.False(existsTrig1); Assert.False(existsTrig2); } var trackTableExists1 = await localOrchestrator.ExistTrackingTableAsync(localScopeInfo1, tableName, schemaName); var trackTableExists2 = await localOrchestrator.ExistTrackingTableAsync(localScopeInfo2, tableName, schemaName); // Tracking table are still existing for others scopes Assert.True(trackTableExists1); Assert.True(trackTableExists2); } // Deprovision await localOrchestrator.DeprovisionAsync(); foreach (var table in localScopeInfo1.Setup.Tables) { var tableName = table.TableName; var schemaName = table.SchemaName; foreach (var objectSpType in Enum.GetValues(typeof(Builders.DbStoredProcedureType))) { var spType = (Builders.DbStoredProcedureType)objectSpType; var exists1 = await localOrchestrator.ExistStoredProcedureAsync( localScopeInfo1, tableName, schemaName, spType); var exists2 = await localOrchestrator.ExistStoredProcedureAsync( localScopeInfo2, tableName, schemaName, spType); Assert.False(exists1); Assert.False(exists2); } } HelperDatabase.DropDatabase(ProviderType.Sql, dbName); }
public override async Task <ServerScopeInfo> InsertOrUpdateServerScopeInfoAsync(ServerScopeInfo serverScopeInfo, DbConnection connection, DbTransaction transaction) { var tableName = $"{scopeTableName.Unquoted().Normalized().ToString()}_server"; var commandText = $@" Declare @minVersion int; Select @minVersion = MIN(CHANGE_TRACKING_MIN_VALID_VERSION(T.object_id)) from sys.tables T where CHANGE_TRACKING_MIN_VALID_VERSION(T.object_id) is not null; MERGE {tableName} AS [base] USING ( SELECT @sync_scope_name AS sync_scope_name, @sync_scope_schema AS sync_scope_schema, @sync_scope_setup AS sync_scope_setup, @sync_scope_version AS sync_scope_version ) AS [changes] ON [base].[sync_scope_name] = [changes].[sync_scope_name] WHEN NOT MATCHED THEN INSERT ([sync_scope_name], [sync_scope_schema], [sync_scope_setup], [sync_scope_version], [sync_scope_last_clean_timestamp]) VALUES ([changes].[sync_scope_name], [changes].[sync_scope_schema], [changes].[sync_scope_setup], [changes].[sync_scope_version], @minVersion) WHEN MATCHED THEN UPDATE SET [sync_scope_name] = [changes].[sync_scope_name], [sync_scope_schema] = [changes].[sync_scope_schema], [sync_scope_setup] = [changes].[sync_scope_setup], [sync_scope_version] = [changes].[sync_scope_version], [sync_scope_last_clean_timestamp] = @minVersion OUTPUT INSERTED.[sync_scope_name], INSERTED.[sync_scope_schema], INSERTED.[sync_scope_setup], INSERTED.[sync_scope_version], INSERTED.[sync_scope_last_clean_timestamp]; "; using (var command = new SqlCommand(commandText, (SqlConnection)connection, (SqlTransaction)transaction)) { var p = command.CreateParameter(); p.ParameterName = "@sync_scope_name"; p.Value = serverScopeInfo.Name; p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_schema"; p.Value = serverScopeInfo.Schema == null ? DBNull.Value : (object)JsonConvert.SerializeObject(serverScopeInfo.Schema); p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_setup"; p.Value = serverScopeInfo.Setup == null ? DBNull.Value : (object)JsonConvert.SerializeObject(serverScopeInfo.Setup); p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_version"; p.Value = string.IsNullOrEmpty(serverScopeInfo.Version) ? DBNull.Value : (object)serverScopeInfo.Version; p.DbType = DbType.String; command.Parameters.Add(p); //p = command.CreateParameter(); //p.ParameterName = "@sync_scope_last_clean_timestamp"; //p.Value = serverScopeInfo.LastCleanupTimestamp; //p.DbType = DbType.Int64; //command.Parameters.Add(p); using (var reader = await command.ExecuteReaderAsync().ConfigureAwait(false)) { if (reader.HasRows) { while (reader.Read()) { serverScopeInfo.Name = reader["sync_scope_name"] as string; serverScopeInfo.Schema = reader["sync_scope_schema"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSet>((string)reader["sync_scope_schema"]); serverScopeInfo.Setup = reader["sync_scope_setup"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSetup>((string)reader["sync_scope_setup"]); serverScopeInfo.Version = reader["sync_scope_version"] as string; serverScopeInfo.LastCleanupTimestamp = reader["sync_scope_last_clean_timestamp"] != DBNull.Value ? (long)reader["sync_scope_last_clean_timestamp"] : 0; } } } return(serverScopeInfo); } }
public override async Task <ServerScopeInfo> InsertOrUpdateServerScopeInfoAsync(ServerScopeInfo serverScopeInfo) { var command = connection.CreateCommand(); if (transaction != null) { command.Transaction = transaction; } bool alreadyOpened = connection.State == ConnectionState.Open; try { if (!alreadyOpened) { await connection.OpenAsync().ConfigureAwait(false); } var tableName = $"{scopeTableName.Unquoted().Normalized().ToString()}_server"; command.CommandText = $@" Declare @minVersion int; Select @minVersion = MIN(CHANGE_TRACKING_MIN_VALID_VERSION(T.object_id)) from sys.tables T where CHANGE_TRACKING_MIN_VALID_VERSION(T.object_id) is not null; MERGE {tableName} AS [base] USING ( SELECT @sync_scope_name AS sync_scope_name, @sync_scope_schema AS sync_scope_schema, @sync_scope_setup AS sync_scope_setup, @sync_scope_version AS sync_scope_version ) AS [changes] ON [base].[sync_scope_name] = [changes].[sync_scope_name] WHEN NOT MATCHED THEN INSERT ([sync_scope_name], [sync_scope_schema], [sync_scope_setup], [sync_scope_version], [sync_scope_last_clean_timestamp]) VALUES ([changes].[sync_scope_name], [changes].[sync_scope_schema], [changes].[sync_scope_setup], [changes].[sync_scope_version], @minVersion) WHEN MATCHED THEN UPDATE SET [sync_scope_name] = [changes].[sync_scope_name], [sync_scope_schema] = [changes].[sync_scope_schema], [sync_scope_setup] = [changes].[sync_scope_setup], [sync_scope_version] = [changes].[sync_scope_version], [sync_scope_last_clean_timestamp] = @minVersion OUTPUT INSERTED.[sync_scope_name], INSERTED.[sync_scope_schema], INSERTED.[sync_scope_setup], INSERTED.[sync_scope_version], INSERTED.[sync_scope_last_clean_timestamp]; "; var p = command.CreateParameter(); p.ParameterName = "@sync_scope_name"; p.Value = serverScopeInfo.Name; p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_schema"; p.Value = serverScopeInfo.Schema == null ? DBNull.Value : (object)JsonConvert.SerializeObject(serverScopeInfo.Schema); p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_setup"; p.Value = serverScopeInfo.Setup == null ? DBNull.Value : (object)JsonConvert.SerializeObject(serverScopeInfo.Setup); p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_version"; p.Value = string.IsNullOrEmpty(serverScopeInfo.Version) ? DBNull.Value : (object)serverScopeInfo.Version; p.DbType = DbType.String; command.Parameters.Add(p); //p = command.CreateParameter(); //p.ParameterName = "@sync_scope_last_clean_timestamp"; //p.Value = serverScopeInfo.LastCleanupTimestamp; //p.DbType = DbType.Int64; //command.Parameters.Add(p); using (var reader = await command.ExecuteReaderAsync().ConfigureAwait(false)) { if (reader.HasRows) { while (reader.Read()) { serverScopeInfo.Name = reader["sync_scope_name"] as string; serverScopeInfo.Schema = reader["sync_scope_schema"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSet>((string)reader["sync_scope_schema"]); serverScopeInfo.Setup = reader["sync_scope_setup"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSetup>((string)reader["sync_scope_setup"]); serverScopeInfo.Version = reader["sync_scope_version"] as string; serverScopeInfo.LastCleanupTimestamp = reader["sync_scope_last_clean_timestamp"] != DBNull.Value ? (long)reader["sync_scope_last_clean_timestamp"] : 0; } } } return(serverScopeInfo); } catch (Exception ex) { Debug.WriteLine($"Error during CreateTableScope : {ex}"); throw; } finally { if (!alreadyOpened && connection.State != ConnectionState.Closed) { connection.Close(); } if (command != null) { command.Dispose(); } } }
public async Task <List <ServerScopeInfo> > GetAllServerScopesAsync(string scopeName) { using (var command = connection.CreateCommand()) { var tableName = $"{scopeTableName.Unquoted().Normalized().ToString()}_server"; if (transaction != null) { command.Transaction = transaction; } bool alreadyOpened = connection.State == ConnectionState.Open; var scopes = new List <ServerScopeInfo>(); if (!alreadyOpened) { await connection.OpenAsync().ConfigureAwait(false); } command.CommandText = $@"SELECT ""sync_scope_name"" , ""sync_scope_schema"" , ""sync_scope_setup"" , ""sync_scope_version"" , ""sync_scope_last_clean_timestamp"" FROM ""{tableName}"" WHERE ""sync_scope_name"" = @sync_scope_name"; var p = command.CreateParameter(); p.ParameterName = "@sync_scope_name"; p.Value = scopeName; p.DbType = DbType.String; command.Parameters.Add(p); using (var reader = await command.ExecuteReaderAsync().ConfigureAwait(false)) { if (reader.HasRows) { // read only the first one while (reader.Read()) { var serverScopeInfo = new ServerScopeInfo(); serverScopeInfo.Name = reader["sync_scope_name"] as string; serverScopeInfo.Schema = reader["sync_scope_schema"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSet>((string)reader["sync_scope_schema"]); serverScopeInfo.Setup = reader["sync_scope_setup"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSetup>((string)reader["sync_scope_setup"]); serverScopeInfo.Version = reader["sync_scope_version"] as string; serverScopeInfo.LastCleanupTimestamp = reader["sync_scope_last_clean_timestamp"] != DBNull.Value ? (long)reader["sync_scope_last_clean_timestamp"] : 0; scopes.Add(serverScopeInfo); } } } if (!alreadyOpened && connection.State != ConnectionState.Closed) { connection.Close(); } return(scopes); } }
InternalGetSnapshotAsync(ServerScopeInfo serverScopeInfo, SyncContext context, DbConnection connection = default, DbTransaction transaction = default, CancellationToken cancellationToken = default, IProgress <ProgressArgs> progress = null) { await using var runner = await this.GetConnectionAsync(context, SyncMode.Reading, SyncStage.ScopeLoading, connection, transaction, cancellationToken, progress).ConfigureAwait(false); // Make a remote call to get Schema from remote provider if (serverScopeInfo.Schema == null) { (context, serverScopeInfo) = await this.InternalGetServerScopeInfoAsync( context, null, false, runner.Connection, runner.Transaction, runner.CancellationToken, runner.Progress).ConfigureAwait(false); serverScopeInfo.Schema.EnsureSchema(); } // Generate a batch directory var batchDirectoryRoot = this.Options.BatchDirectory; var batchDirectoryName = string.Concat(DateTime.UtcNow.ToString("yyyy_MM_dd_ss"), Path.GetRandomFileName().Replace(".", "")); var batchDirectoryFullPath = Path.Combine(batchDirectoryRoot, batchDirectoryName); if (!Directory.Exists(batchDirectoryFullPath)) { Directory.CreateDirectory(batchDirectoryFullPath); } // Create the BatchInfo serialized (forced because in a snapshot call, so we are obviously serialized on disk) var serverBatchInfo = new BatchInfo(serverScopeInfo.Schema, batchDirectoryRoot, batchDirectoryName); // Firstly, get the snapshot summary var changesToSend = new HttpMessageSendChangesRequest(context, null); var serializer = this.SerializerFactory.GetSerializer <HttpMessageSendChangesRequest>(); var binaryData = await serializer.SerializeAsync(changesToSend); var response0 = await this.httpRequestHandler.ProcessRequestAsync( this.HttpClient, context, this.ServiceUri, binaryData, HttpStep.GetSummary, this.SerializerFactory, this.Converter, 0, this.SyncPolicy, cancellationToken, progress).ConfigureAwait(false); HttpMessageSummaryResponse summaryResponseContent = null; using (var streamResponse = await response0.Content.ReadAsStreamAsync().ConfigureAwait(false)) { var responseSerializer = this.SerializerFactory.GetSerializer <HttpMessageSummaryResponse>(); if (streamResponse.CanRead) { summaryResponseContent = await responseSerializer.DeserializeAsync(streamResponse); serverBatchInfo.RowsCount = summaryResponseContent.BatchInfo?.RowsCount ?? 0; if (summaryResponseContent.BatchInfo?.BatchPartsInfo != null) { foreach (var bpi in summaryResponseContent.BatchInfo.BatchPartsInfo) { serverBatchInfo.BatchPartsInfo.Add(bpi); } } } } if (summaryResponseContent == null) { throw new Exception("Summary can't be null"); } context = summaryResponseContent.SyncContext; // no snapshot if ((serverBatchInfo.BatchPartsInfo == null || serverBatchInfo.BatchPartsInfo.Count <= 0) && serverBatchInfo.RowsCount <= 0) { return(context, 0, null, new DatabaseChangesSelected()); } // If we have a snapshot we are raising the batches downloading process that will occurs await this.InterceptAsync(new HttpBatchesDownloadingArgs(context, serverBatchInfo, this.GetServiceHost()), progress, cancellationToken).ConfigureAwait(false); await serverBatchInfo.BatchPartsInfo.ForEachAsync(async bpi => { var changesToSend3 = new HttpMessageGetMoreChangesRequest(context, bpi.Index); var serializer3 = this.SerializerFactory.GetSerializer <HttpMessageGetMoreChangesRequest>(); var binaryData3 = await serializer3.SerializeAsync(changesToSend3); await this.InterceptAsync(new HttpGettingServerChangesRequestArgs(bpi.Index, serverBatchInfo.BatchPartsInfo.Count, summaryResponseContent.SyncContext, this.GetServiceHost()), progress, cancellationToken).ConfigureAwait(false); var response = await this.httpRequestHandler.ProcessRequestAsync( this.HttpClient, context, this.ServiceUri, binaryData3, HttpStep.GetMoreChanges, this.SerializerFactory, this.Converter, 0, this.SyncPolicy, cancellationToken, progress).ConfigureAwait(false); if (this.SerializerFactory.Key != "json") { var s = this.SerializerFactory.GetSerializer <HttpMessageSendChangesResponse>(); using var responseStream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false); var getMoreChanges = await s.DeserializeAsync(responseStream); if (getMoreChanges != null && getMoreChanges.Changes != null && getMoreChanges.Changes.HasRows) { var localSerializer = new LocalJsonSerializer(); var interceptorsWriting = this.interceptors.GetInterceptors <SerializingRowArgs>(); if (interceptorsWriting.Count > 0) { localSerializer.OnWritingRow(async(syncTable, rowArray) => { var args = new SerializingRowArgs(context, syncTable, rowArray); await this.InterceptAsync(args, progress, cancellationToken).ConfigureAwait(false); return(args.Result); }); } // Should have only one table var table = getMoreChanges.Changes.Tables[0]; var schemaTable = DbSyncAdapter.CreateChangesTable(serverScopeInfo.Schema.Tables[table.TableName, table.SchemaName]); var fullPath = Path.Combine(batchDirectoryFullPath, bpi.FileName); // open the file and write table header await localSerializer.OpenFileAsync(fullPath, schemaTable).ConfigureAwait(false); foreach (var row in table.Rows) { await localSerializer.WriteRowToFileAsync(new SyncRow(schemaTable, row), schemaTable).ConfigureAwait(false); } // Close file await localSerializer.CloseFileAsync(fullPath, schemaTable).ConfigureAwait(false); } } else { // Serialize await SerializeAsync(response, bpi.FileName, batchDirectoryFullPath, this).ConfigureAwait(false); } // Raise response from server containing a batch changes await this.InterceptAsync(new HttpGettingServerChangesResponseArgs(serverBatchInfo, bpi.Index, bpi.RowsCount, summaryResponseContent.SyncContext, this.GetServiceHost()), progress, cancellationToken).ConfigureAwait(false); }); await this.InterceptAsync(new HttpBatchesDownloadedArgs(summaryResponseContent, summaryResponseContent.SyncContext, this.GetServiceHost()), progress, cancellationToken).ConfigureAwait(false); return(context, summaryResponseContent.RemoteClientTimestamp, serverBatchInfo, summaryResponseContent.ServerChangesSelected); }
public virtual async Task <ServerScopeInfo> InsertOrUpdateServerScopeInfoAsync(ServerScopeInfo serverScopeInfo, DbConnection connection, DbTransaction transaction) { var tableName = $"{scopeTableName.Unquoted().Normalized().ToString()}_server"; var commandText = $@" MERGE {tableName} AS ""base"" USING ( SELECT @sync_scope_name AS sync_scope_name, @sync_scope_schema AS sync_scope_schema, @sync_scope_setup AS sync_scope_setup, @sync_scope_version AS sync_scope_version, @sync_scope_last_clean_timestamp AS sync_scope_last_clean_timestamp ) AS ""changes"" ON ""base"".""sync_scope_name"" = ""changes"".""sync_scope_name"" WHEN NOT MATCHED THEN INSERT (""sync_scope_name"", ""sync_scope_schema"", ""sync_scope_setup"", ""sync_scope_version"", ""sync_scope_last_clean_timestamp"") VALUES (""changes"".""sync_scope_name"", ""changes"".""sync_scope_schema"", ""changes"".""sync_scope_setup"", ""changes"".""sync_scope_version"", ""changes"".""sync_scope_last_clean_timestamp"") WHEN MATCHED THEN UPDATE SET ""sync_scope_name"" = ""changes"".""sync_scope_name"", ""sync_scope_schema"" = ""changes"".""sync_scope_schema"", ""sync_scope_setup"" = ""changes"".""sync_scope_setup"", ""sync_scope_version"" = ""changes"".""sync_scope_version"", ""sync_scope_last_clean_timestamp"" = ""changes"".""sync_scope_last_clean_timestamp"" OUTPUT INSERTED.""sync_scope_name"", INSERTED.""sync_scope_schema"", INSERTED.""sync_scope_setup"", INSERTED.""sync_scope_version"", INSERTED.""sync_scope_last_clean_timestamp""; "; using (var command = new NpgsqlCommand(commandText, (NpgsqlConnection)connection, (NpgsqlTransaction)transaction)) { var p = command.CreateParameter(); p.ParameterName = "@sync_scope_name"; p.Value = serverScopeInfo.Name; p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_schema"; p.Value = serverScopeInfo.Schema == null ? DBNull.Value : (object)JsonConvert.SerializeObject(serverScopeInfo.Schema); p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_setup"; p.Value = serverScopeInfo.Setup == null ? DBNull.Value : (object)JsonConvert.SerializeObject(serverScopeInfo.Setup); p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_version"; p.Value = string.IsNullOrEmpty(serverScopeInfo.Version) ? DBNull.Value : (object)serverScopeInfo.Version; p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_last_clean_timestamp"; p.Value = serverScopeInfo.LastCleanupTimestamp; p.DbType = DbType.Int64; command.Parameters.Add(p); using (var reader = await command.ExecuteReaderAsync().ConfigureAwait(false)) { if (reader.HasRows) { while (reader.Read()) { serverScopeInfo.Name = reader["sync_scope_name"] as string; serverScopeInfo.Schema = reader["sync_scope_schema"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSet>((string)reader["sync_scope_schema"]); serverScopeInfo.Setup = reader["sync_scope_setup"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSetup>((string)reader["sync_scope_setup"]); serverScopeInfo.Version = reader["sync_scope_version"] as string; serverScopeInfo.LastCleanupTimestamp = reader["sync_scope_last_clean_timestamp"] != DBNull.Value ? (long)reader["sync_scope_last_clean_timestamp"] : 0; } } } return(serverScopeInfo); } }
public Task <ServerScopeInfo> InsertOrUpdateServerScopeInfoAsync(ServerScopeInfo serverScopeInfo) => throw new NotImplementedException();
public async Task <ServerScopeInfo> InsertOrUpdateServerScopeInfoAsync(ServerScopeInfo serverScopeInfo) { bool alreadyOpened = connection.State == ConnectionState.Open; bool exist; var tableName = $"{scopeTableName.Unquoted().Normalized().ToString()}_server"; try { using (var command = connection.CreateCommand()) { if (transaction != null) { command.Transaction = transaction; } if (!alreadyOpened) { await connection.OpenAsync().ConfigureAwait(false); } command.CommandText = $@"Select count(*) from `{tableName}` where sync_scope_name = @sync_scope_name"; var p = command.CreateParameter(); p.ParameterName = "@sync_scope_name"; p.Value = serverScopeInfo.Name; p.DbType = DbType.String; command.Parameters.Add(p); exist = ((long)await command.ExecuteScalarAsync().ConfigureAwait(false)) > 0; } string stmtText = exist ? $"Update `{tableName}` set sync_scope_schema=@sync_scope_schema, sync_scope_setup=@sync_scope_setup, sync_scope_version=@sync_scope_version, sync_scope_last_clean_timestamp=@sync_scope_last_clean_timestamp where sync_scope_name=@sync_scope_name" : $"Insert into `{tableName}` (sync_scope_name, sync_scope_schema, sync_scope_setup, sync_scope_version, sync_scope_last_clean_timestamp) values (@sync_scope_name, @sync_scope_schema, @sync_scope_setup, @sync_scope_version, @sync_scope_last_clean_timestamp)"; using (var command = connection.CreateCommand()) { if (transaction != null) { command.Transaction = transaction; } command.CommandText = stmtText; var p = command.CreateParameter(); p.ParameterName = "@sync_scope_name"; p.Value = serverScopeInfo.Name; p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_schema"; p.Value = serverScopeInfo.Schema == null ? DBNull.Value : (object)JsonConvert.SerializeObject(serverScopeInfo.Schema); p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_setup"; p.Value = serverScopeInfo.Setup == null ? DBNull.Value : (object)JsonConvert.SerializeObject(serverScopeInfo.Setup); p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_version"; p.Value = serverScopeInfo.Version; p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_last_clean_timestamp"; p.Value = serverScopeInfo.LastCleanupTimestamp; p.DbType = DbType.Int64; command.Parameters.Add(p); using (DbDataReader reader = command.ExecuteReader()) { if (reader.HasRows) { while (reader.Read()) { serverScopeInfo.Name = reader["sync_scope_name"] as string; serverScopeInfo.Schema = reader["sync_scope_schema"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSet>((string)reader["sync_scope_schema"]); serverScopeInfo.Setup = reader["sync_scope_setup"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSetup>((string)reader["sync_scope_setup"]); serverScopeInfo.Version = reader["sync_scope_version"] as string; serverScopeInfo.LastCleanupTimestamp = reader["sync_scope_last_clean_timestamp"] != DBNull.Value ? (long)reader["sync_scope_last_clean_timestamp"] : 0L; } } } return(serverScopeInfo); } } catch (Exception ex) { Debug.WriteLine($"Error during InsertOrUpdateServerScopeInfoAsync : {ex}"); throw; } finally { if (!alreadyOpened && connection.State != ConnectionState.Closed) { connection.Close(); } } }
public override Task <ServerScopeInfo> SaveServerScopeInfoAsync(ServerScopeInfo serverScopeInfo, DbConnection connection = null, DbTransaction transaction = null, CancellationToken cancellationToken = default, IProgress <ProgressArgs> progress = null) => throw new NotImplementedException();
public override Task <ServerScopeInfo> ProvisionAsync(ServerScopeInfo serverScopeInfo, SyncProvision provision = default, bool overwrite = false, DbConnection connection = default, DbTransaction transaction = default, CancellationToken cancellationToken = default, IProgress <ProgressArgs> progress = null) => throw new NotImplementedException();
public async Task Scenario_Using_ExistingClientDatabase_ProvisionDeprovision_WithoutAccessToServerSide(SyncOptions options) { // This test works only if we have the same exact provider on both sides // create client orchestrator that is the same as server var clientDatabaseName = HelperDatabase.GetRandomName("tcpfilt_cli_"); var clientProvider = this.CreateProvider(this.ServerType, clientDatabaseName); var client = (clientDatabaseName, Server.ProviderType, Provider : clientProvider); // create a client schema without seeding await this.EnsureDatabaseSchemaAndSeedAsync(client, false, UseFallbackSchema); // Since we don't have access to remote orchestrator, // we can simulate a server scope var localOrchestrator = new LocalOrchestrator(client.Provider, options); // Get the local scope var localScopeInfo = await localOrchestrator.GetClientScopeInfoAsync(); // getting local scope did not get the schema var schema = await localOrchestrator.GetSchemaAsync(this.FilterSetup); // getting local schema from these provider will not fill the schema name for each table // and we need the exact same name even if it's not used on client if (client.ProviderType == ProviderType.MySql || client.ProviderType == ProviderType.MariaDB || client.ProviderType == ProviderType.Sqlite) { foreach (var table in schema.Tables) { var setupTable = this.FilterSetup.Tables.First(t => t.TableName == table.TableName); table.SchemaName = setupTable.SchemaName; } } // Simulate a server scope var serverScope = new ServerScopeInfo { Name = localScopeInfo.Name, Schema = schema, Setup = this.FilterSetup, Version = localScopeInfo.Version }; // just check interceptor var onTableCreatedCount = 0; localOrchestrator.OnTableCreated(args => onTableCreatedCount++); // Provision the database with all tracking tables, stored procedures, triggers and scope var clientScope = await localOrchestrator.ProvisionAsync(serverScope); //-------------------------- // ASSERTION //-------------------------- // check if scope table is correctly created var scopeInfoTableExists = await localOrchestrator.ExistScopeInfoTableAsync(clientScope.Name, DbScopeType.Client); Assert.True(scopeInfoTableExists); // get the db manager foreach (var setupTable in this.FilterSetup.Tables) { Assert.True(await localOrchestrator.ExistTrackingTableAsync(clientScope, setupTable.TableName, setupTable.SchemaName)); Assert.True(await localOrchestrator.ExistTriggerAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbTriggerType.Delete)); Assert.True(await localOrchestrator.ExistTriggerAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbTriggerType.Insert)); Assert.True(await localOrchestrator.ExistTriggerAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbTriggerType.Update)); if (client.ProviderType == ProviderType.Sql) { Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.BulkDeleteRows)); Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.BulkTableType)); Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.BulkUpdateRows)); } Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.DeleteMetadata)); Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.DeleteRow)); Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.Reset)); Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectChanges)); Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectInitializedChanges)); Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectRow)); Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.UpdateRow)); // Filters here Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectChangesWithFilters)); Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectInitializedChangesWithFilters)); } //localOrchestrator.OnTableProvisioned(null); //// Deprovision the database with all tracking tables, stored procedures, triggers and scope await localOrchestrator.DeprovisionAsync(SyncProvision.StoredProcedures | SyncProvision.Triggers | SyncProvision.ClientScope | SyncProvision.TrackingTable); // check if scope table is correctly created scopeInfoTableExists = await localOrchestrator.ExistScopeInfoTableAsync(clientScope.Name, DbScopeType.Client); Assert.False(scopeInfoTableExists); // get the db manager foreach (var setupTable in this.FilterSetup.Tables) { Assert.False(await localOrchestrator.ExistTrackingTableAsync(clientScope, setupTable.TableName, setupTable.SchemaName)); Assert.False(await localOrchestrator.ExistTriggerAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbTriggerType.Delete)); Assert.False(await localOrchestrator.ExistTriggerAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbTriggerType.Insert)); Assert.False(await localOrchestrator.ExistTriggerAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbTriggerType.Update)); if (client.ProviderType == ProviderType.Sql) { Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.BulkDeleteRows)); Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.BulkTableType)); Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.BulkUpdateRows)); } Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.DeleteMetadata)); Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.DeleteRow)); Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.Reset)); Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectChanges)); Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectInitializedChanges)); Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectRow)); Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.UpdateRow)); // check filters are deleted Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectChangesWithFilters)); Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectInitializedChangesWithFilters)); } }