public ConcreteMigrationSqlGenerator(
IUpdateSqlGenerator sqlGenerator,
IRelationalTypeMapper typeMapper,
IRelationalMetadataExtensionProvider annotations)
: base(sqlGenerator, typeMapper, annotations)
{
}
public TestSqlServerModificationCommandBatch(
ISqlServerSqlGenerator sqlGenerator,
IRelationalMetadataExtensionProvider metadataExtensionProvider,
int?maxBatchSize)
: base(sqlGenerator, metadataExtensionProvider, maxBatchSize)
{
}
public SqlServerDatabase(
[NotNull] IModel model,
[NotNull] IEntityKeyFactorySource entityKeyFactorySource,
[NotNull] IEntityMaterializerSource entityMaterializerSource,
[NotNull] IClrAccessorSource <IClrPropertyGetter> clrPropertyGetterSource,
[NotNull] ISqlServerConnection connection,
[NotNull] ICommandBatchPreparer batchPreparer,
[NotNull] IBatchExecutor batchExecutor,
[NotNull] IDbContextOptions options,
[NotNull] ILoggerFactory loggerFactory,
[NotNull] IRelationalValueBufferFactoryFactory valueBufferFactoryFactory,
[NotNull] IMethodCallTranslator compositeMethodCallTranslator,
[NotNull] IMemberTranslator compositeMemberTranslator,
[NotNull] IRelationalTypeMapper typeMapper,
[NotNull] IRelationalMetadataExtensionProvider relationalExtensions)
: base(
model,
entityKeyFactorySource,
entityMaterializerSource,
clrPropertyGetterSource,
connection,
batchPreparer,
batchExecutor,
options,
loggerFactory,
valueBufferFactoryFactory,
compositeMethodCallTranslator,
compositeMemberTranslator,
typeMapper,
relationalExtensions)
{
}
public SqlServerQueryCompilationContext(
[NotNull] IModel model,
[NotNull] ILogger logger,
[NotNull] ILinqOperatorProvider linqOperatorProvider,
[NotNull] IResultOperatorHandler resultOperatorHandler,
[NotNull] IEntityMaterializerSource entityMaterializerSource,
[NotNull] IEntityKeyFactorySource entityKeyFactorySource,
[NotNull] IClrAccessorSource <IClrPropertyGetter> clrPropertyGetterSource,
[NotNull] IQueryMethodProvider queryMethodProvider,
[NotNull] IMethodCallTranslator compositeMethodCallTranslator,
[NotNull] IMemberTranslator compositeMemberTranslator,
[NotNull] IRelationalValueBufferFactoryFactory valueBufferFactoryFactory,
[NotNull] IRelationalTypeMapper typeMapper,
[NotNull] IRelationalMetadataExtensionProvider relationalExtensions)
: base(
model,
logger,
linqOperatorProvider,
resultOperatorHandler,
entityMaterializerSource,
entityKeyFactorySource,
clrPropertyGetterSource,
queryMethodProvider,
compositeMethodCallTranslator,
compositeMemberTranslator,
valueBufferFactoryFactory,
typeMapper,
relationalExtensions)
{
}
public MigrationOperationFactory(
[NotNull] IRelationalMetadataExtensionProvider extensionProvider)
{
Check.NotNull(extensionProvider, "extensionProvider");
_extensionProvider = extensionProvider;
}
protected ReaderModificationCommandBatch(
[NotNull] ISqlGenerator sqlGenerator,
[NotNull] IRelationalMetadataExtensionProvider metadataExtensionProvider)
: base(sqlGenerator)
{
Check.NotNull(metadataExtensionProvider, nameof(metadataExtensionProvider));
_metadataExtensionProvider = metadataExtensionProvider;
}
public EntityTypeCodeGeneratorHelper([NotNull] EntityTypeGeneratorModel generatorModel,
[NotNull] IRelationalMetadataExtensionProvider extensionsProvider)
{
Check.NotNull(generatorModel, nameof(generatorModel));
Check.NotNull(extensionsProvider, nameof(extensionsProvider));
GeneratorModel = generatorModel;
ExtensionsProvider = extensionsProvider;
}
protected DbContextCodeGeneratorHelper([NotNull] DbContextGeneratorModel generatorModel,
IRelationalMetadataExtensionProvider extensionsProvider)
{
Check.NotNull(generatorModel, nameof(generatorModel));
Check.NotNull(extensionsProvider, nameof(extensionsProvider));
GeneratorModel = generatorModel;
ExtensionsProvider = extensionsProvider;
}
public RelationalValueGeneratorSelector(
[NotNull] IValueGeneratorCache cache,
[NotNull] IRelationalMetadataExtensionProvider relationalExtensions)
: base(cache)
{
Check.NotNull(relationalExtensions, nameof(relationalExtensions));
RelationalExtensions = relationalExtensions;
}
protected DbContextCodeGeneratorHelper([NotNull] DbContextGeneratorModel generatorModel,
IRelationalMetadataExtensionProvider extensionsProvider)
{
Check.NotNull(generatorModel, nameof(generatorModel));
Check.NotNull(extensionsProvider, nameof(extensionsProvider));
GeneratorModel = generatorModel;
ExtensionsProvider = extensionsProvider;
}
public RelationalModelValidator(
[NotNull] ILoggerFactory loggerFactory,
[NotNull] IRelationalMetadataExtensionProvider relationalExtensions)
: base(loggerFactory)
{
Check.NotNull(relationalExtensions, nameof(relationalExtensions));
_relationalExtensions = relationalExtensions;
}
protected ReaderModificationCommandBatch(
[NotNull] ISqlGenerator sqlGenerator,
[NotNull] IRelationalMetadataExtensionProvider metadataExtensionProvider)
: base(sqlGenerator)
{
Check.NotNull(metadataExtensionProvider, nameof(metadataExtensionProvider));
_metadataExtensionProvider = metadataExtensionProvider;
}
public RelationalModelValidator(
[NotNull] ILoggerFactory loggerFactory,
[NotNull] IRelationalMetadataExtensionProvider relationalExtensions)
: base(loggerFactory)
{
Check.NotNull(relationalExtensions, nameof(relationalExtensions));
_relationalExtensions = relationalExtensions;
}
protected MigrationOperationSqlGenerator(
[NotNull] IRelationalMetadataExtensionProvider extensionProvider,
[NotNull] RelationalTypeMapper typeMapper)
{
Check.NotNull(extensionProvider, "extensionProvider");
Check.NotNull(typeMapper, "typeMapper");
_extensionProvider = extensionProvider;
_typeMapper = typeMapper;
}
public MigrationsModelDiffer(
[NotNull] IRelationalMetadataExtensionProvider annotations,
[NotNull] IMigrationsAnnotationProvider migrationsAnnotations)
{
Check.NotNull(annotations, nameof(annotations));
Check.NotNull(migrationsAnnotations, nameof(migrationsAnnotations));
Annotations = annotations;
MigrationsAnnotations = migrationsAnnotations;
}
public override ModificationCommandBatch Create(
IDbContextOptions options,
IRelationalMetadataExtensionProvider metadataExtensionProvider)
{
var optionsExtension = options.Extensions.OfType <SqlServerOptionsExtension>().FirstOrDefault();
var maxBatchSize = optionsExtension?.MaxBatchSize;
return(new TestSqlServerModificationCommandBatch(
(ISqlServerUpdateSqlGenerator)UpdateSqlGenerator,
maxBatchSize));
}
public ModelDiffer(
[NotNull] IRelationalTypeMapper typeMapper,
[NotNull] IRelationalMetadataExtensionProvider metadataExtensions,
[NotNull] IMigrationAnnotationProvider annotations)
{
Check.NotNull(typeMapper, nameof(typeMapper));
Check.NotNull(metadataExtensions, nameof(metadataExtensions));
Check.NotNull(annotations, nameof(annotations));
TypeMapper = typeMapper;
MetadataExtensions = metadataExtensions;
Annotations = annotations;
}
protected MigrationsSqlGenerator(
[NotNull] IUpdateSqlGenerator sql,
[NotNull] IRelationalTypeMapper typeMapper,
[NotNull] IRelationalMetadataExtensionProvider annotations)
{
Check.NotNull(sql, nameof(sql));
Check.NotNull(typeMapper, nameof(typeMapper));
Check.NotNull(annotations, nameof(annotations));
Sql = sql;
_typeMapper = typeMapper;
_annotations = annotations;
}
public SqlServerValueGeneratorSelector(
[NotNull] ISqlServerValueGeneratorCache cache,
[NotNull] ISqlServerSequenceValueGeneratorFactory sequenceFactory,
[NotNull] ISqlServerConnection connection,
[NotNull] IRelationalMetadataExtensionProvider relationalExtensions)
: base(cache, relationalExtensions)
{
Check.NotNull(sequenceFactory, nameof(sequenceFactory));
Check.NotNull(connection, nameof(connection));
_sequenceFactory = sequenceFactory;
_connection = connection;
}
protected MigrationsSqlGenerator(
[NotNull] IUpdateSqlGenerator sql,
[NotNull] IRelationalTypeMapper typeMapper,
[NotNull] IRelationalMetadataExtensionProvider annotations)
{
Check.NotNull(sql, nameof(sql));
Check.NotNull(typeMapper, nameof(typeMapper));
Check.NotNull(annotations, nameof(annotations));
Sql = sql;
_typeMapper = typeMapper;
_annotations = annotations;
}
public MigrationOperationProcessor(
[NotNull] IRelationalMetadataExtensionProvider extensionProvider,
[NotNull] RelationalTypeMapper typeMapper,
[NotNull] MigrationOperationFactory operationFactory)
{
Check.NotNull(extensionProvider, "extensionProvider");
Check.NotNull(typeMapper, "typeMapper");
Check.NotNull(operationFactory, "operationFactory");
_extensionProvider = extensionProvider;
_typeMapper = typeMapper;
_operationFactory = operationFactory;
}
public TestCommandBatchPreparer(
IModificationCommandBatchFactory modificationCommandBatchFactory,
IParameterNameGeneratorFactory parameterNameGeneratorFactory,
IComparer <ModificationCommand> modificationCommandComparer,
IRelationalValueBufferFactoryFactory valueBufferFactoryFactory,
IRelationalMetadataExtensionProvider metadataExtensionProvider)
: base(
modificationCommandBatchFactory,
parameterNameGeneratorFactory,
modificationCommandComparer,
valueBufferFactoryFactory,
metadataExtensionProvider)
{
}
public HistoryRepository(
[NotNull] IDatabaseCreator databaseCreator,
[NotNull] ISqlStatementExecutor executor,
[NotNull] IRelationalConnection connection,
[NotNull] IDbContextOptions options,
[NotNull] IMigrationsModelDiffer modelDiffer,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] IRelationalMetadataExtensionProvider annotations,
[NotNull] IUpdateSqlGenerator sql)
{
Check.NotNull(databaseCreator, nameof(databaseCreator));
Check.NotNull(executor, nameof(executor));
Check.NotNull(connection, nameof(connection));
Check.NotNull(options, nameof(options));
Check.NotNull(modelDiffer, nameof(modelDiffer));
Check.NotNull(migrationsSqlGenerator, nameof(migrationsSqlGenerator));
Check.NotNull(annotations, nameof(annotations));
Check.NotNull(sql, nameof(sql));
_databaseCreator = (IRelationalDatabaseCreator)databaseCreator;
_executor = executor;
_connection = connection;
_modelDiffer = modelDiffer;
_migrationsSqlGenerator = migrationsSqlGenerator;
Sql = sql;
var relationalOptions = RelationalOptionsExtension.Extract(options);
TableName = relationalOptions?.MigrationsHistoryTableName ?? DefaultTableName;
TableSchema = relationalOptions.MigrationsHistoryTableSchema;
_model = new LazyRef <IModel>(
() =>
{
var modelBuilder = new ModelBuilder(new ConventionSet());
modelBuilder.Entity <HistoryRow>(
x =>
{
ConfigureTable(x);
x.ToTable(TableName, TableSchema);
});
return(modelBuilder.Model);
});
var entityType = new LazyRef <IEntityType>(() => _model.Value.GetEntityType(typeof(HistoryRow)));
_migrationIdColumnName = new LazyRef <string>(
() => annotations.For(entityType.Value.FindProperty(nameof(HistoryRow.MigrationId))).ColumnName);
_productVersionColumnName = new LazyRef <string>(
() => annotations.For(entityType.Value.FindProperty(nameof(HistoryRow.ProductVersion))).ColumnName);
}
public SqlServerModificationCommandBatch(
[NotNull] ISqlServerSqlGenerator sqlGenerator,
[NotNull] IRelationalMetadataExtensionProvider metadataExtensionProvider,
[CanBeNull] int?maxBatchSize)
: base(sqlGenerator, metadataExtensionProvider)
{
if (maxBatchSize.HasValue &&
maxBatchSize.Value <= 0)
{
throw new ArgumentOutOfRangeException(nameof(maxBatchSize), RelationalStrings.InvalidMaxBatchSize);
}
_maxBatchSize = Math.Min(maxBatchSize ?? Int32.MaxValue, MaxRowCount);
}
public override ModificationCommandBatch Create(
IEntityOptions options,
IRelationalMetadataExtensionProvider metadataExtensionProvider)
{
Check.NotNull(options, nameof(options));
Check.NotNull(metadataExtensionProvider, nameof(metadataExtensionProvider));
var optionsExtension = options.Extensions.OfType<SqlServerOptionsExtension>().FirstOrDefault();
var maxBatchSize = optionsExtension?.MaxBatchSize;
return new SqlServerModificationCommandBatch(
(ISqlServerSqlGenerator)SqlGenerator,
metadataExtensionProvider,
maxBatchSize);
}
public override ModificationCommandBatch Create(
IEntityOptions options,
IRelationalMetadataExtensionProvider metadataExtensionProvider)
{
Check.NotNull(options, nameof(options));
Check.NotNull(metadataExtensionProvider, nameof(metadataExtensionProvider));
var optionsExtension = options.Extensions.OfType <SqlServerOptionsExtension>().FirstOrDefault();
var maxBatchSize = optionsExtension?.MaxBatchSize;
return(new SqlServerModificationCommandBatch(
(ISqlServerSqlGenerator)SqlGenerator,
metadataExtensionProvider,
maxBatchSize));
}
protected RelationalDatabase(
[NotNull] IModel model,
[NotNull] IEntityKeyFactorySource entityKeyFactorySource,
[NotNull] IEntityMaterializerSource entityMaterializerSource,
[NotNull] IClrAccessorSource <IClrPropertyGetter> clrPropertyGetterSource,
[NotNull] IRelationalConnection connection,
[NotNull] ICommandBatchPreparer batchPreparer,
[NotNull] IBatchExecutor batchExecutor,
[NotNull] IDbContextOptions options,
[NotNull] ILoggerFactory loggerFactory,
[NotNull] IRelationalValueBufferFactoryFactory valueBufferFactoryFactory,
[NotNull] IMethodCallTranslator compositeMethodCallTranslator,
[NotNull] IMemberTranslator compositeMemberTranslator,
[NotNull] IRelationalTypeMapper typeMapper,
[NotNull] IRelationalMetadataExtensionProvider relationalExtensions)
: base(model, loggerFactory)
{
Check.NotNull(entityKeyFactorySource, nameof(entityKeyFactorySource));
Check.NotNull(entityMaterializerSource, nameof(entityMaterializerSource));
Check.NotNull(clrPropertyGetterSource, nameof(clrPropertyGetterSource));
Check.NotNull(connection, nameof(connection));
Check.NotNull(batchPreparer, nameof(batchPreparer));
Check.NotNull(batchExecutor, nameof(batchExecutor));
Check.NotNull(options, nameof(options));
Check.NotNull(valueBufferFactoryFactory, nameof(valueBufferFactoryFactory));
Check.NotNull(compositeMethodCallTranslator, nameof(compositeMethodCallTranslator));
Check.NotNull(compositeMemberTranslator, nameof(compositeMemberTranslator));
Check.NotNull(typeMapper, nameof(typeMapper));
Check.NotNull(relationalExtensions, nameof(relationalExtensions));
EntityKeyFactorySource = entityKeyFactorySource;
EntityMaterializerSource = entityMaterializerSource;
ClrPropertyGetterSource = clrPropertyGetterSource;
_batchPreparer = batchPreparer;
_batchExecutor = batchExecutor;
_connection = connection;
_options = options;
_compositeMethodCallTranslator = compositeMethodCallTranslator;
_compositeMemberTranslator = compositeMemberTranslator;
TypeMapper = typeMapper;
ValueBufferFactoryFactory = valueBufferFactoryFactory;
RelationalExtensions = relationalExtensions;
}
public CommandBatchPreparer(
[NotNull] IModificationCommandBatchFactory modificationCommandBatchFactory,
[NotNull] IParameterNameGeneratorFactory parameterNameGeneratorFactory,
[NotNull] IComparer <ModificationCommand> modificationCommandComparer,
[NotNull] IRelationalValueBufferFactoryFactory valueBufferFactoryFactory,
[NotNull] IRelationalMetadataExtensionProvider metadataExtensions)
{
Check.NotNull(modificationCommandBatchFactory, nameof(modificationCommandBatchFactory));
Check.NotNull(parameterNameGeneratorFactory, nameof(parameterNameGeneratorFactory));
Check.NotNull(modificationCommandComparer, nameof(modificationCommandComparer));
Check.NotNull(valueBufferFactoryFactory, nameof(valueBufferFactoryFactory));
Check.NotNull(metadataExtensions, nameof(metadataExtensions));
_modificationCommandBatchFactory = modificationCommandBatchFactory;
_parameterNameGeneratorFactory = parameterNameGeneratorFactory;
_modificationCommandComparer = modificationCommandComparer;
_valueBufferFactoryFactory = valueBufferFactoryFactory;
_metadataExtensionProvider = metadataExtensions;
}
protected RelationalQueryCompilationContext(
[NotNull] IModel model,
[NotNull] ILogger logger,
[NotNull] ILinqOperatorProvider linqOperatorProvider,
[NotNull] IResultOperatorHandler resultOperatorHandler,
[NotNull] IEntityMaterializerSource entityMaterializerSource,
[NotNull] IEntityKeyFactorySource entityKeyFactorySource,
[NotNull] IClrAccessorSource <IClrPropertyGetter> clrPropertyGetterSource,
[NotNull] IQueryMethodProvider queryMethodProvider,
[NotNull] IMethodCallTranslator compositeMethodCallTranslator,
[NotNull] IMemberTranslator compositeMemberTranslator,
[NotNull] IRelationalValueBufferFactoryFactory valueBufferFactoryFactory,
[NotNull] IRelationalTypeMapper typeMapper,
[NotNull] IRelationalMetadataExtensionProvider relationalExtensions)
: base(
model,
logger,
linqOperatorProvider,
resultOperatorHandler,
entityMaterializerSource,
entityKeyFactorySource,
clrPropertyGetterSource)
{
Check.NotNull(queryMethodProvider, nameof(queryMethodProvider));
Check.NotNull(compositeMethodCallTranslator, nameof(compositeMethodCallTranslator));
Check.NotNull(compositeMemberTranslator, nameof(compositeMemberTranslator));
Check.NotNull(valueBufferFactoryFactory, nameof(valueBufferFactoryFactory));
Check.NotNull(typeMapper, nameof(typeMapper));
Check.NotNull(relationalExtensions, nameof(relationalExtensions));
QueryMethodProvider = queryMethodProvider;
CompositeMethodCallTranslator = compositeMethodCallTranslator;
CompositeMemberTranslator = compositeMemberTranslator;
ValueBufferFactoryFactory = valueBufferFactoryFactory;
TypeMapper = typeMapper;
RelationalExtensions = relationalExtensions;
}
public virtual Expression CreateMaterializer(
[NotNull] IEntityType entityType,
[NotNull] SelectExpression selectExpression,
[NotNull] Func <IProperty, SelectExpression, int> projectionAdder,
[NotNull] IRelationalMetadataExtensionProvider relationalExtensions,
[CanBeNull] IQuerySource querySource)
{
Check.NotNull(entityType, nameof(entityType));
Check.NotNull(selectExpression, nameof(selectExpression));
Check.NotNull(projectionAdder, nameof(projectionAdder));
var valueBufferParameter
= Expression.Parameter(typeof(ValueBuffer));
var concreteEntityTypes
= entityType.GetConcreteTypesInHierarchy().ToArray();
var indexMap = new int[concreteEntityTypes[0].GetProperties().Count()];
var propertyIndex = 0;
foreach (var property in concreteEntityTypes[0].GetProperties())
{
indexMap[propertyIndex++]
= projectionAdder(property, selectExpression);
}
var materializer
= _entityMaterializerSource
.CreateMaterializeExpression(
concreteEntityTypes[0], valueBufferParameter, indexMap);
if (concreteEntityTypes.Length == 1 &&
concreteEntityTypes[0].RootType() == concreteEntityTypes[0])
{
return(Expression.Lambda <Func <ValueBuffer, object> >(materializer, valueBufferParameter));
}
var discriminatorProperty = relationalExtensions.For(concreteEntityTypes[0]).DiscriminatorProperty;
var discriminatorColumn
= selectExpression.Projection
.OfType <AliasExpression>()
.Single(c => c.TryGetColumnExpression()?.Property == discriminatorProperty);
var firstDiscriminatorValue
= Expression.Constant(
relationalExtensions.For(concreteEntityTypes[0]).DiscriminatorValue);
var discriminatorPredicate
= Expression.Equal(discriminatorColumn, firstDiscriminatorValue);
if (concreteEntityTypes.Length == 1)
{
selectExpression.Predicate
= new DiscriminatorPredicateExpression(discriminatorPredicate, querySource);
return(Expression.Lambda <Func <ValueBuffer, object> >(materializer, valueBufferParameter));
}
var discriminatorValueVariable
= Expression.Variable(discriminatorProperty.ClrType);
var returnLabelTarget = Expression.Label(typeof(object));
var blockExpressions
= new Expression[]
{
Expression.Assign(
discriminatorValueVariable,
_entityMaterializerSource
.CreateReadValueExpression(
valueBufferParameter,
discriminatorProperty.ClrType,
discriminatorProperty.Index)),
Expression.IfThenElse(
Expression.Equal(discriminatorValueVariable, firstDiscriminatorValue),
Expression.Return(returnLabelTarget, materializer),
Expression.Throw(
Expression.Call(
_createUnableToDiscriminateException,
Expression.Constant(concreteEntityTypes[0])))),
Expression.Label(
returnLabelTarget,
Expression.Default(returnLabelTarget.Type))
};
foreach (var concreteEntityType in concreteEntityTypes.Skip(1))
{
indexMap = new int[concreteEntityType.GetProperties().Count()];
propertyIndex = 0;
foreach (var property in concreteEntityType.GetProperties())
{
indexMap[propertyIndex++]
= projectionAdder(property, selectExpression);
}
var discriminatorValue
= Expression.Constant(
relationalExtensions.For(concreteEntityType).DiscriminatorValue);
materializer
= _entityMaterializerSource
.CreateMaterializeExpression(concreteEntityType, valueBufferParameter, indexMap);
blockExpressions[1]
= Expression.IfThenElse(
Expression.Equal(discriminatorValueVariable, discriminatorValue),
Expression.Return(returnLabelTarget, materializer),
blockExpressions[1]);
discriminatorPredicate
= Expression.OrElse(
Expression.Equal(discriminatorColumn, discriminatorValue),
discriminatorPredicate);
}
selectExpression.Predicate
= new DiscriminatorPredicateExpression(discriminatorPredicate, querySource);
return(Expression.Lambda <Func <ValueBuffer, object> >(
Expression.Block(new[] { discriminatorValueVariable }, blockExpressions),
valueBufferParameter));
}
public FakeRelationalDatabase(
IModel model,
IEntityKeyFactorySource entityKeyFactorySource,
IEntityMaterializerSource entityMaterializerSource,
IClrAccessorSource<IClrPropertyGetter> clrPropertyGetterSource,
IRelationalConnection connection,
ICommandBatchPreparer batchPreparer,
IBatchExecutor batchExecutor,
IDbContextOptions options,
ILoggerFactory loggerFactory,
IRelationalValueBufferFactoryFactory valueBufferFactoryFactory,
IMethodCallTranslator compositeMethodCallTranslator,
IMemberTranslator compositeMemberTranslator,
IRelationalTypeMapper typeMapper,
IRelationalMetadataExtensionProvider relationalExtensions)
: base(
model,
entityKeyFactorySource,
entityMaterializerSource,
clrPropertyGetterSource,
connection,
batchPreparer,
batchExecutor,
options,
loggerFactory,
valueBufferFactoryFactory,
compositeMethodCallTranslator,
compositeMemberTranslator,
typeMapper,
relationalExtensions)
{
}
public override ModificationCommandBatch Create(
IDbContextOptions options,
IRelationalMetadataExtensionProvider metadataExtensionProvider)
{
return new SingularModificationCommandBatch(UpdateSqlGenerator);
}
public TestCommandBatchPreparer(
IModificationCommandBatchFactory modificationCommandBatchFactory,
IParameterNameGeneratorFactory parameterNameGeneratorFactory,
IComparer<ModificationCommand> modificationCommandComparer,
IRelationalValueBufferFactoryFactory valueBufferFactoryFactory,
IRelationalMetadataExtensionProvider metadataExtensionProvider)
: base(
modificationCommandBatchFactory,
parameterNameGeneratorFactory,
modificationCommandComparer,
valueBufferFactoryFactory,
metadataExtensionProvider)
{
}
public FakeQueryCompilationContext(
IModel model,
ILogger logger,
ILinqOperatorProvider linqOperatorProvider,
IResultOperatorHandler resultOperatorHandler,
IEntityMaterializerSource entityMaterializerSource,
IClrAccessorSource<IClrPropertyGetter> clrPropertyGetterSource,
IEntityKeyFactorySource entityKeyFactorySource,
IQueryMethodProvider queryMethodProvider,
IMethodCallTranslator compositeMethodCallTranslator,
IMemberTranslator compositeMemberTranslator,
IRelationalValueBufferFactoryFactory valueBufferFactoryFactory,
IRelationalTypeMapper typeMapper,
IRelationalMetadataExtensionProvider relationalExtensions)
: base(
model,
logger,
linqOperatorProvider,
resultOperatorHandler,
entityMaterializerSource,
entityKeyFactorySource,
clrPropertyGetterSource,
queryMethodProvider,
compositeMethodCallTranslator,
compositeMemberTranslator,
valueBufferFactoryFactory,
typeMapper,
relationalExtensions)
{
}
public abstract ModificationCommandBatch Create(
IEntityOptions options,
IRelationalMetadataExtensionProvider metadataExtensionProvider);
public RelationalNameBuilder([NotNull] IRelationalMetadataExtensionProvider extensionProvider)
{
Check.NotNull(extensionProvider, "extensionProvider");
_extensionProvider = extensionProvider;
}
public override ModificationCommandBatch Create(
IEntityOptions options,
IRelationalMetadataExtensionProvider metadataExtensionProvider)
{
return new SingularModificationCommandBatch(SqlGenerator, metadataExtensionProvider);
}
public override ModificationCommandBatch Create(
IEntityOptions options,
IRelationalMetadataExtensionProvider metadataExtensionProvider)
{
return(new SingularModificationCommandBatch(SqlGenerator, metadataExtensionProvider));
}
public override ModificationCommandBatch Create(
IDbContextOptions options,
IRelationalMetadataExtensionProvider metadataExtensionProvider)
{
return(new SingularModificationCommandBatch(UpdateSqlGenerator));
}
public SqlServerDbContextCodeGeneratorHelper(
[NotNull] DbContextGeneratorModel generatorModel,
[NotNull] IRelationalMetadataExtensionProvider extensionsProvider)
: base(generatorModel, extensionsProvider)
{
}
public override ModificationCommandBatch Create(
IDbContextOptions options,
IRelationalMetadataExtensionProvider metadataExtensionProvider)
=> new NpgsqlModificationCommandBatch(UpdateSqlGenerator);
public ConcreteMigrationSqlGenerator(
IUpdateSqlGenerator sqlGenerator,
IRelationalTypeMapper typeMapper,
IRelationalMetadataExtensionProvider annotations)
: base(sqlGenerator, typeMapper, annotations)
{
}
