private void Initialize()
{
Stage = UpgradeMode.IsMultistage() ? UpgradeStage.Upgrading : UpgradeStage.Final;
Hints = new SetSlim <UpgradeHint>();
RecycledDefinitions = new List <RecycledDefinition>();
Services = new UpgradeServiceAccessor();
}
private void CreateConnection(UpgradeServiceAccessor serviceAccessor)
{
var driver = serviceAccessor.StorageDriver;
var connection = driver.CreateConnection(null);
driver.ApplyNodeConfiguration(connection, context.NodeConfiguration);
try {
driver.OpenConnection(null, connection);
driver.BeginTransaction(null, connection, null);
}
catch {
connection.Dispose();
throw;
}
if (driver.ProviderInfo.Supports(ProviderFeatures.SingleConnection))
{
serviceAccessor.RegisterTemporaryResource(connection);
}
else
{
serviceAccessor.RegisterResource(connection);
}
serviceAccessor.Connection = connection;
}
private static async Task ExtractMetadataAsync(
UpgradeServiceAccessor services, SqlExecutor executor, SqlWorkerResult result, SqlWorkerTask task,
CancellationToken token)
{
var set = new MetadataSet();
var mapping = new MetadataMapping(services.StorageDriver, services.NameBuilder);
var metadataExtractor = new MetadataExtractor(mapping, executor);
foreach (var metadataTask in services.MappingResolver.GetMetadataTasks()
.Where(metadataTask => !ShouldSkipMetadataExtraction(mapping, result, metadataTask)))
{
try {
if (task.HasFlag(SqlWorkerTask.ExtractMetadataAssemblies))
{
await metadataExtractor.ExtractAssembliesAsync(set, metadataTask, token).ConfigureAwait(false);
}
if (task.HasFlag(SqlWorkerTask.ExtractMetadataTypes))
{
await metadataExtractor.ExtractTypesAsync(set, metadataTask, token).ConfigureAwait(false);
}
if (task.HasFlag(SqlWorkerTask.ExtractMetadataExtension))
{
await metadataExtractor.ExtractExtensionsAsync(set, metadataTask, token).ConfigureAwait(false);
}
}
catch (Exception exception) {
UpgradeLog.Warning(
Strings.LogFailedToExtractMetadataFromXYZ, metadataTask.Catalog, metadataTask.Schema, exception);
}
}
result.Metadata = set;
}
// Constructors
public SchemaExtractor(UpgradeContext context, Session session)
{
this.context = context;
services = context.Services;
executor = session.Services.Demand <ISqlExecutor>();
}
private static async Task <SchemaExtractionResult> ExtractSchemaAsync(
UpgradeServiceAccessor services, ISqlExecutor executor, CancellationToken token)
{
var extractionTasks = services.MappingResolver.GetSchemaTasks();
var extractionResult = await executor.ExtractAsync(extractionTasks, token).ConfigureAwait(false);
var schema = new SchemaExtractionResult(extractionResult);
return(new IgnoreRulesHandler(schema, services.Configuration, services.MappingResolver).Handle());
}
private static void DropSchema(UpgradeServiceAccessor services, ISqlExecutor executor)
{
var driver = services.StorageDriver;
var extractionResult = ExtractSchema(services, executor);
var schemas = extractionResult.Catalogs.SelectMany(c => c.Schemas).ToList();
var tables = schemas.SelectMany(s => s.Tables).ToList();
var sequences = schemas.SelectMany(s => s.Sequences);
DropForeignKeys(driver, tables, executor);
DropTables(driver, tables, executor);
DropSequences(driver, sequences, executor);
}
private static void BuildUpgradeHandlers(UpgradeServiceAccessor serviceAccessor, IServiceContainer serviceContainer)
{
// Getting user handlers
var userHandlers =
from handler in serviceContainer.GetAll <IUpgradeHandler>()
let assembly = handler.Assembly ?? handler.GetType().Assembly
where handler.IsEnabled
group handler by assembly;
// Adding user handlers
var handlers = new Dictionary <Assembly, IUpgradeHandler>();
foreach (var group in userHandlers)
{
var candidates = group.ToList();
if (candidates.Count > 1)
{
throw new DomainBuilderException(
string.Format(Strings.ExMoreThanOneEnabledXIsProvidedForAssemblyY, typeof(IUpgradeHandler).GetShortName(), @group.Key));
}
handlers.Add(group.Key, candidates[0]);
}
// Adding default handlers
var assembliesWithUserHandlers = handlers.Select(pair => pair.Key);
var assembliesWithoutUserHandler =
serviceAccessor.Configuration.Types.PersistentTypes
.Select(type => type.Assembly)
.Distinct()
.Except(assembliesWithUserHandlers);
foreach (var assembly in assembliesWithoutUserHandler)
{
var handler = new UpgradeHandler(assembly);
handlers.Add(assembly, handler);
}
// Building a list of handlers sorted by dependencies of their assemblies
var dependencies = handlers.Keys.ToDictionary(
assembly => assembly,
assembly => assembly.GetReferencedAssemblies().Select(assemblyName => assemblyName.ToString()).ToHashSet());
var sortedHandlers = handlers
.SortTopologically((a0, a1) => dependencies[a1.Key].Contains(a0.Key.GetName().ToString()))
.Select(pair => pair.Value);
// Storing the result
serviceAccessor.UpgradeHandlers =
new ReadOnlyDictionary <Assembly, IUpgradeHandler>(handlers);
serviceAccessor.OrderedUpgradeHandlers =
new ReadOnlyList <IUpgradeHandler>(sortedHandlers.ToList());
}
private static async Task DropSchemaAsync(
UpgradeServiceAccessor services, ISqlExecutor executor, CancellationToken token)
{
var driver = services.StorageDriver;
var extractionResult = await ExtractSchemaAsync(services, executor, token).ConfigureAwait(false);
var schemas = extractionResult.Catalogs.SelectMany(c => c.Schemas).ToList();
var tables = schemas.SelectMany(s => s.Tables).ToList();
var sequences = schemas.SelectMany(s => s.Sequences);
await DropForeignKeysAsync(driver, tables, executor, token).ConfigureAwait(false);
await DropTablesAsync(driver, tables, executor, token).ConfigureAwait(false);
await DropSequencesAsync(driver, sequences, executor, token).ConfigureAwait(false);
}
// Constructors
public SqlModelConverter(UpgradeServiceAccessor services, SchemaExtractionResult sourceModel,
IEnumerable <StoredPartialIndexFilterInfo> partialIndexes)
{
ArgumentValidator.EnsureArgumentNotNull(services, "handlers");
ArgumentValidator.EnsureArgumentNotNull(sourceModel, "sourceModel");
ArgumentValidator.EnsureArgumentNotNull(partialIndexes, "partialIndexes");
this.sourceModel = sourceModel;
resolver = services.MappingResolver;
providerInfo = services.ProviderInfo;
driver = services.StorageDriver;
partialIndexMap = new PartialIndexInfoMap(resolver, partialIndexes);
}
private async ValueTask CreateConnection(
UpgradeServiceAccessor serviceAccessor, bool isAsync, CancellationToken token = default)
{
var driver = serviceAccessor.StorageDriver;
var connection = driver.CreateConnection(null);
driver.ApplyNodeConfiguration(connection, context.NodeConfiguration);
try {
if (isAsync)
{
await driver.OpenConnectionAsync(null, connection, token).ConfigureAwait(false);
await driver.BeginTransactionAsync(null, connection, null, token).ConfigureAwait(false);
}
else
{
driver.OpenConnection(null, connection);
driver.BeginTransaction(null, connection, null);
}
}
catch {
if (isAsync)
{
await connection.DisposeAsync().ConfigureAwait(false);
}
else
{
connection.Dispose();
}
throw;
}
if (driver.ProviderInfo.Supports(ProviderFeatures.SingleConnection))
{
serviceAccessor.RegisterTemporaryResource(connection);
}
else
{
serviceAccessor.RegisterResource(connection);
}
serviceAccessor.Connection = connection;
}
private static SqlWorkerResult Run(UpgradeServiceAccessor services, SqlWorkerTask task)
{
var result = new SqlWorkerResult();
var executor = new SqlExecutor(services.StorageDriver, services.Connection);
if ((task & SqlWorkerTask.DropSchema) > 0)
{
DropSchema(services, executor);
}
if ((task & SqlWorkerTask.ExtractSchema) > 0)
{
result.Schema = ExtractSchema(services, executor);
}
if ((task & (SqlWorkerTask.ExtractMetadataTypes | SqlWorkerTask.ExtractMetadataAssemblies | SqlWorkerTask.ExtractMetadataExtension)) > 0)
{
ExtractMetadata(services, executor, result, task);
}
return(result);
}
// Constructors
public SchemaUpgrader(UpgradeContext context, Session session)
{
this.context = context;
this.session = session;
services = context.Services;
connection = context.Services.Connection;
executor = session.Services.Demand <ISqlExecutor>();
driver = services.StorageDriver;
if (driver.ProviderInfo.Supports(ProviderFeatures.TransactionalDdl))
{
statementProcessor = ExecuteTransactionally;
}
else
{
statementProcessor = ExecuteNonTransactionally;
}
}
private static void BuildFullTextCatalogResolver(UpgradeServiceAccessor serviceAccessor, IServiceContainer serviceContainer)
{
//Getting user resolvers
var candidates = from r in serviceContainer.GetAll <IFullTextCatalogNameBuilder>()
let assembly = r.GetType().Assembly
where r.IsEnabled && assembly != typeof(IFullTextCatalogNameBuilder).Assembly
select r;
var userResolversCount = candidates.Count();
if (userResolversCount > 1)
{
throw new DomainBuilderException(string.Format(Strings.ExMoreThanOneEnabledXIsProvided, typeof(IFullTextCatalogNameBuilder).GetShortName()));
}
var resolver = (userResolversCount == 0)
? new FullTextCatalogNameBuilder()
: candidates.First();
//storing sesolver
serviceAccessor.FulltextCatalogNameBuilder = resolver;
}
private static async Task <SqlWorkerResult> RunAsync(
UpgradeServiceAccessor services, SqlWorkerTask task, CancellationToken token)
{
var result = new SqlWorkerResult();
var executor = new SqlExecutor(services.StorageDriver, services.Connection);
if ((task & SqlWorkerTask.DropSchema) > 0)
{
await DropSchemaAsync(services, executor, token).ConfigureAwait(false);
}
if ((task & SqlWorkerTask.ExtractSchema) > 0)
{
result.Schema = await ExtractSchemaAsync(services, executor, token).ConfigureAwait(false);
}
if ((task & (SqlWorkerTask.ExtractMetadataTypes | SqlWorkerTask.ExtractMetadataAssemblies | SqlWorkerTask.ExtractMetadataExtension)) > 0)
{
await ExtractMetadataAsync(services, executor, result, task, token).ConfigureAwait(false);
}
return(result);
}
private void BuildExternalServices(UpgradeServiceAccessor serviceAccessor, DomainConfiguration configuration)
{
var standardRegistrations = new[] {
new ServiceRegistration(typeof(DomainConfiguration), configuration),
new ServiceRegistration(typeof(UpgradeContext), context)
};
var modules = configuration.Types.Modules
.Select(type => new ServiceRegistration(typeof(IModule), type, false));
var handlers = configuration.Types.UpgradeHandlers
.Select(type => new ServiceRegistration(typeof(IUpgradeHandler), type, false));
var ftCatalogResolvers = configuration.Types.FullTextCatalogResolvers
.Select(type => new ServiceRegistration(typeof(IFullTextCatalogNameBuilder), type, false));
var registrations = standardRegistrations.Concat(modules).Concat(handlers).Concat(ftCatalogResolvers);
var serviceContainer = new ServiceContainer(registrations);
serviceAccessor.RegisterResource(serviceContainer);
BuildModules(serviceAccessor, serviceContainer);
BuildUpgradeHandlers(serviceAccessor, serviceContainer);
BuildFullTextCatalogResolver(serviceAccessor, serviceContainer);
}
private static SchemaExtractionResult ExtractSchema(UpgradeServiceAccessor services, ISqlExecutor executor)
{
var schema = new SchemaExtractionResult(executor.Extract(services.MappingResolver.GetSchemaTasks()));
return(new IgnoreRulesHandler(schema, services.Configuration, services.MappingResolver).Handle());
}
private static void BuildModules(UpgradeServiceAccessor serviceAccessor, IServiceContainer serviceContainer)
{
serviceAccessor.Modules = new ReadOnlyList <IModule>(serviceContainer.GetAll <IModule>().ToList());
}
public static Func <SqlWorkerResult> Create(UpgradeServiceAccessor services, SqlWorkerTask task)
{
return(() => Run(services, task));
}
public static Func <Task <SqlWorkerResult> > Create(
UpgradeServiceAccessor services, SqlWorkerTask task, CancellationToken token) =>
() => RunAsync(services, task, token);
