private static void DropSequences(StorageDriver driver, IEnumerable <Sequence> sequences, ISqlExecutor executor)
{
var statements = BreakEvery(sequences
.Select(s => driver.Compile(SqlDdl.Drop(s)).GetCommandText()), 25).ToChainedBuffer();
executor.ExecuteMany(statements);
}
private static void DropTables(StorageDriver driver, IEnumerable <Table> tables, ISqlExecutor executor)
{
var statements = BreakEvery(tables
.Select(t => driver.Compile(SqlDdl.Drop(t)).GetCommandText()), 25);
executor.ExecuteMany(statements);
}
private void CreateAccessor()
{
var nodeConfiguration = new NodeConfiguration();
var configuration = DomainConfigurationFactory.Create();
var descriptor = ProviderDescriptor.Get(configuration.ConnectionInfo.Provider);
var driverFactory = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory);
var storageDriver = StorageDriver.Create(driverFactory, configuration);
var nameBuilder = new NameBuilder(configuration, storageDriver.ProviderInfo);
var handlerFactory = (HandlerFactory)Activator.CreateInstance(descriptor.HandlerFactory);
var accessor = new UpgradeServiceAccessor {
Configuration = configuration,
StorageDriver = storageDriver,
NameBuilder = nameBuilder,
HandlerFactory = handlerFactory
};
configuration.Lock();
var connection = storageDriver.CreateConnection(null);
connection.Open();
accessor.MappingResolver = MappingResolver.Create(configuration, nodeConfiguration, storageDriver.GetDefaultSchema(connection));
if (storageDriver.ProviderInfo.Supports(ProviderFeatures.SingleConnection))
{
accessor.RegisterTemporaryResource(connection);
}
else
{
accessor.RegisterResource(connection);
}
accessor.Connection = connection;
accessor.Connection.Extensions.AddOne(new TypeDelegator(typeof(IProviderExecutor)));
this.accessor = accessor;
}
private void BuildServices()
{
var services = context.Services;
var configuration = context.Configuration;
services.Configuration = configuration;
services.IndexFilterCompiler = new PartialIndexFilterCompiler();
if (context.ParentDomain == null)
{
var descriptor = ProviderDescriptor.Get(configuration.ConnectionInfo.Provider);
var driverFactory = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory);
var handlerFactory = (HandlerFactory)Activator.CreateInstance(descriptor.HandlerFactory);
var driver = StorageDriver.Create(driverFactory, configuration);
services.HandlerFactory = handlerFactory;
services.StorageDriver = driver;
services.NameBuilder = new NameBuilder(configuration, driver.ProviderInfo);
}
else
{
var handlers = context.ParentDomain.Handlers;
services.HandlerFactory = handlers.Factory;
services.StorageDriver = handlers.StorageDriver;
services.NameBuilder = handlers.NameBuilder;
}
CreateConnection(services);
context.DefaultSchemaInfo = defaultSchemaInfo = services.StorageDriver.GetDefaultSchema(services.Connection);
services.MappingResolver = MappingResolver.Create(configuration, context.NodeConfiguration, defaultSchemaInfo);
BuildExternalServices(services, configuration);
services.Lock();
context.TypeIdProvider = new TypeIdProvider(context);
}
// Constructors
public DomainModelConverter(
HandlerAccessor handlers,
ITypeIdProvider typeIdProvider,
PartialIndexFilterCompiler compiler,
MappingResolver resolver,
IFullTextCatalogNameBuilder fulltextCatalogNameBuilder,
bool isUpgradingStage)
{
ArgumentValidator.EnsureArgumentNotNull(handlers, "handlers");
ArgumentValidator.EnsureArgumentNotNull(typeIdProvider, "typeIdProvider");
ArgumentValidator.EnsureArgumentNotNull(compiler, "compiler");
ArgumentValidator.EnsureArgumentNotNull(resolver, "resolver");
this.handlers = handlers;
this.compiler = compiler;
this.typeIdProvider = typeIdProvider;
this.resolver = resolver;
this.isUpgradingStage = isUpgradingStage;
this.fulltextCatalogNameBuilder = fulltextCatalogNameBuilder;
sourceModel = handlers.Domain.Model;
configuration = handlers.Domain.Configuration;
providerInfo = handlers.ProviderInfo;
driver = handlers.StorageDriver;
nameBuilder = handlers.NameBuilder;
FieldMapping = new Dictionary <StoredFieldInfo, StoredFieldInfo>();
StorageModel = null;
CurrentModelTypes = new Dictionary <string, StoredTypeInfo>();
}
private static void DropForeignKeys(StorageDriver driver, IEnumerable <Table> tables, ISqlExecutor executor)
{
var statements = BreakEvery(tables
.SelectMany(t => t.TableConstraints.OfType <ForeignKey>())
.Select(fk => driver.Compile(SqlDdl.Alter(fk.Table, SqlDdl.DropConstraint(fk))).GetCommandText()), 25);
executor.ExecuteMany(statements);
}
public QueryBuilder(Session session)
: base(session)
{
var sqlSessionHandler = (SqlSessionHandler)session.Handler.GetRealHandler();
driver = session.Domain.Handlers.StorageDriver;
commandFactory = sqlSessionHandler.CommandFactory;
queryProvider = session.Query.Provider;
}
private static Task DropTablesAsync(
StorageDriver driver, IEnumerable <Table> tables, ISqlExecutor executor, CancellationToken token)
{
var statements = tables
.Select(t => driver.Compile(SqlDdl.Drop(t)).GetCommandText())
.ToList();
return(executor.ExecuteManyAsync(statements, token));
}
private static Task DropForeignKeysAsync(
StorageDriver driver, IEnumerable <Table> tables, ISqlExecutor executor, CancellationToken token)
{
var statements = tables
.SelectMany(t => t.TableConstraints.OfType <ForeignKey>())
.Select(fk => driver.Compile(SqlDdl.Alter(fk.Table, SqlDdl.DropConstraint(fk))).GetCommandText())
.ToList();
return(executor.ExecuteManyAsync(statements, token));
}
// Constructors
public UpgradeActionSequenceBuilder(StorageDriver driver, UpgradeActionSequence result, SqlUpgradeStage stage)
{
ArgumentValidator.EnsureArgumentNotNull(driver, "driver");
ArgumentValidator.EnsureArgumentNotNull(result, "result");
this.driver = driver;
output = SelectOutput(result, stage);
Result = result;
Stage = stage;
}
// Constructors
public MetadataWriter(StorageDriver driver, MetadataMapping mapping, SqlExtractionTask task, IProviderExecutor executor)
{
ArgumentValidator.EnsureArgumentNotNull(driver, "driver");
ArgumentValidator.EnsureArgumentNotNull(mapping, "mapping");
ArgumentValidator.EnsureArgumentNotNull(task, "task");
ArgumentValidator.EnsureArgumentNotNull(executor, "executor");
this.driver = driver;
this.mapping = mapping;
this.task = task;
this.executor = executor;
}
public void Dispose()
{
if (_ORM != null)
{
_ORM.Dispose();
_ORM = null;
}
if (_StorageDriver != null)
{
_StorageDriver = null;
}
}
// 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 void InitializeStorageDriver()
{
switch (_Bucket.StorageType)
{
case StorageDriverType.Disk:
if (!Directory.Exists(_Bucket.DiskDirectory))
{
Directory.CreateDirectory(_Bucket.DiskDirectory);
}
_StorageDriver = new DiskStorageDriver(_Bucket.DiskDirectory);
break;
default:
throw new ArgumentException("Unknown storage driver type '" + _Bucket.StorageType.ToString() + "' in bucket GUID " + _Bucket.GUID + ".");
}
}
// 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;
}
}
// Constructors
public MetadataMapping(StorageDriver driver, NameBuilder nameBuilder)
{
this.nameBuilder = nameBuilder;
Assembly = TableOf(typeof (Assembly));
AssemblyName = ColumnOf((Assembly x) => x.Name);
AssemblyVersion = ColumnOf((Assembly x) => x.Version);
Type = TableOf(typeof (Metadata.Type));
TypeId = ColumnOf((Metadata.Type x) => x.Id);
TypeName = ColumnOf((Metadata.Type x) => x.Name);
Extension = TableOf(typeof (Extension));
ExtensionName = ColumnOf((Extension x) => x.Name);
ExtensionText = ColumnOf((Extension x) => x.Text);
StringMapping = driver.GetTypeMapping(WellKnownTypes.String);
IntMapping = driver.GetTypeMapping(WellKnownTypes.Int32);
}
private async ValueTask BuildServices(bool isAsync, CancellationToken token = default)
{
var services = context.Services;
var configuration = context.Configuration;
services.Configuration = configuration;
services.IndexFilterCompiler = new PartialIndexFilterCompiler();
if (context.ParentDomain == null)
{
var descriptor = ProviderDescriptor.Get(configuration.ConnectionInfo.Provider);
var driverFactory = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory);
var handlerFactory = (HandlerFactory)Activator.CreateInstance(descriptor.HandlerFactory);
var driver = isAsync
? await StorageDriver.CreateAsync(driverFactory, configuration, token).ConfigureAwait(false)
: StorageDriver.Create(driverFactory, configuration);
services.HandlerFactory = handlerFactory;
services.StorageDriver = driver;
services.NameBuilder = new NameBuilder(configuration, driver.ProviderInfo);
}
else
{
var handlers = context.ParentDomain.Handlers;
services.HandlerFactory = handlers.Factory;
services.StorageDriver = handlers.StorageDriver;
services.NameBuilder = handlers.NameBuilder;
}
await CreateConnection(services, isAsync, token).ConfigureAwait(false);
context.DefaultSchemaInfo = defaultSchemaInfo = isAsync
? await services.StorageDriver.GetDefaultSchemaAsync(services.Connection, token).ConfigureAwait(false)
: services.StorageDriver.GetDefaultSchema(services.Connection);
services.MappingResolver = MappingResolver.Create(configuration, context.NodeConfiguration, defaultSchemaInfo);
BuildExternalServices(services, configuration);
services.Lock();
context.TypeIdProvider = new TypeIdProvider(context);
}
internal DomainExtractedModelBuilder(UpgradeServiceAccessor services, StorageModel model, bool makeSharedFinally)
{
ArgumentValidator.EnsureArgumentNotNull(services, "services");
ArgumentValidator.EnsureArgumentNotNull(model, "model");
this.model = model;
this.mappingResolver = services.MappingResolver;
this.provider = services.ProviderInfo;
this.driver = services.StorageDriver;
this.makeSharedFinally = makeSharedFinally;
this.targetResult = new SchemaExtractionResult();
if (provider.Supports(ProviderFeatures.Collations))
{
var collation = services.Configuration.Collation;
if (!string.IsNullOrEmpty(collation))
{
collationName = collation;
}
}
}
private void BuildServices(UpgradeContext context)
{
var services = context.Services;
var configuration = context.Configuration;
services.Configuration = configuration;
services.IndexFilterCompiler = new PartialIndexFilterCompiler();
var descriptor = ProviderDescriptor.Get(configuration.ConnectionInfo.Provider);
var driverFactory = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory);
var handlerFactory = (HandlerFactory)Activator.CreateInstance(descriptor.HandlerFactory);
var driver = StorageDriver.Create(driverFactory, configuration);
services.HandlerFactory = handlerFactory;
services.StorageDriver = driver;
services.NameBuilder = new NameBuilder(configuration, driver.ProviderInfo);
BuildExternalServices(services, context);
services.Lock();
context.TypeIdProvider = new TypeIdProvider(context);
}
// Constructors
internal QueryCommand(StorageDriver driver, Session session, DbCommand realCommand)
{
this.driver = driver;
this.session = session;
this.realCommand = realCommand;
}
