protected virtual IModel CreateModel(
[NotNull] DbContext context,
[CanBeNull] IConventionSetBuilder conventionSetBuilder,
[NotNull] IModelValidator validator)
{
Check.NotNull(context, nameof(context));
Check.NotNull(validator, nameof(validator));
var conventionSet = CreateConventionSet(conventionSetBuilder);
var model = new Model();
var productVersion = typeof(ModelSource).GetTypeInfo().Assembly
.GetCustomAttribute <AssemblyInformationalVersionAttribute>()?.InformationalVersion;
model[CoreAnnotationNames.ProductVersionAnnotation] = productVersion;
var modelBuilder = new ModelBuilder(conventionSet, model);
FindSets(modelBuilder, context);
OnModelCreating(context, modelBuilder);
modelBuilder.Validate();
validator.Validate(model);
return(model);
}
protected virtual IModel CreateModel(
[NotNull] DbContext context,
[CanBeNull] IConventionSetBuilder conventionSetBuilder,
[NotNull] IModelValidator validator)
{
Check.NotNull(context, nameof(context));
Check.NotNull(validator, nameof(validator));
var conventionSet = CreateConventionSet(conventionSetBuilder);
var model = new Model();
model.SetProductVersion(ProductInfo.GetVersion());
var modelBuilder = new ModelBuilder(conventionSet, model);
FindSets(modelBuilder, context);
OnModelCreating(context, modelBuilder);
modelBuilder.Validate();
validator.Validate(model);
return(model);
}
/// <summary>
/// <para>
/// Creates the service dependencies parameter object for a <see cref="HistoryRepository" />.
/// </para>
/// <para>
/// Do not call this constructor directly from either provider or application code as it may change
/// as new dependencies are added. Instead, use this type in your constructor so that an instance
/// will be created and injected automatically by the dependency injection container. To create
/// an instance with some dependent services replaced, first resolve the object from the dependency
/// injection container, then replace selected services using the 'With...' methods. Do not call
/// the constructor at any point in this process.
/// </para>
/// <para>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </para>
/// </summary>
/// <param name="databaseCreator"> The database creator. </param>
/// <param name="rawSqlCommandBuilder"> A command builder for building raw SQL commands. </param>
/// <param name="connection"> The connection to the database. </param>
/// <param name="options"> Options for the current context instance. </param>
/// <param name="modelDiffer"> The model differ. </param>
/// <param name="migrationsSqlGenerator"> The SQL generator for Migrations operations. </param>
/// <param name="sqlGenerationHelper"> Helpers for generating update SQL. </param>
/// <param name="conventionSetBuilder"> The convention set to use when creating the model. </param>
/// <param name="typeMappingSource"> The type mapper. </param>
/// <param name="modelLogger"> The logger for model building events. </param>
public HistoryRepositoryDependencies(
[NotNull] IRelationalDatabaseCreator databaseCreator,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] IRelationalConnection connection,
[NotNull] IDbContextOptions options,
[NotNull] IMigrationsModelDiffer modelDiffer,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] ISqlGenerationHelper sqlGenerationHelper,
[NotNull] IConventionSetBuilder conventionSetBuilder,
[NotNull] IRelationalTypeMappingSource typeMappingSource,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Model> modelLogger)
{
Check.NotNull(databaseCreator, nameof(databaseCreator));
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
Check.NotNull(connection, nameof(connection));
Check.NotNull(options, nameof(options));
Check.NotNull(modelDiffer, nameof(modelDiffer));
Check.NotNull(migrationsSqlGenerator, nameof(migrationsSqlGenerator));
Check.NotNull(sqlGenerationHelper, nameof(sqlGenerationHelper));
Check.NotNull(conventionSetBuilder, nameof(conventionSetBuilder));
Check.NotNull(typeMappingSource, nameof(typeMappingSource));
Check.NotNull(modelLogger, nameof(modelLogger));
DatabaseCreator = databaseCreator;
RawSqlCommandBuilder = rawSqlCommandBuilder;
Connection = connection;
Options = options;
ModelDiffer = modelDiffer;
MigrationsSqlGenerator = migrationsSqlGenerator;
SqlGenerationHelper = sqlGenerationHelper;
ConventionSetBuilder = conventionSetBuilder;
TypeMappingSource = typeMappingSource;
ModelLogger = modelLogger;
}
/// <summary>
/// <para>
/// Creates the service dependencies parameter object for a <see cref="HistoryRepository" />.
/// </para>
/// <para>
/// Do not call this constructor directly from either provider or application code as it may change
/// as new dependencies are added. Instead, use this type in your constructor so that an instance
/// will be created and injected automatically by the dependency injection container. To create
/// an instance with some dependent services replaced, first resolve the object from the dependency
/// injection container, then replace selected services using the 'With...' methods. Do not call
/// the constructor at any point in this process.
/// </para>
/// <para>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </para>
/// </summary>
/// <param name="databaseCreator"> The database creator. </param>
/// <param name="rawSqlCommandBuilder"> A command builder for building raw SQL commands. </param>
/// <param name="connection"> The connection to the database. </param>
/// <param name="options"> Options for the current context instance. </param>
/// <param name="modelDiffer"> The model differ. </param>
/// <param name="migrationsSqlGenerator"> The SQL generator for Migrations operations. </param>
/// <param name="sqlGenerationHelper"> Helpers for generating update SQL. </param>
/// <param name="coreConventionSetBuilder"> The core convention set to use when creating the model. </param>
/// <param name="conventionSetBuilder"> The convention set to use when creating the model. </param>
public HistoryRepositoryDependencies(
[NotNull] IRelationalDatabaseCreator databaseCreator,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] IRelationalConnection connection,
[NotNull] IDbContextOptions options,
[NotNull] IMigrationsModelDiffer modelDiffer,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] ISqlGenerationHelper sqlGenerationHelper,
[NotNull] ICoreConventionSetBuilder coreConventionSetBuilder,
[NotNull] IConventionSetBuilder conventionSetBuilder)
{
Check.NotNull(databaseCreator, nameof(databaseCreator));
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
Check.NotNull(connection, nameof(connection));
Check.NotNull(options, nameof(options));
Check.NotNull(modelDiffer, nameof(modelDiffer));
Check.NotNull(migrationsSqlGenerator, nameof(migrationsSqlGenerator));
Check.NotNull(sqlGenerationHelper, nameof(sqlGenerationHelper));
Check.NotNull(coreConventionSetBuilder, nameof(coreConventionSetBuilder));
Check.NotNull(conventionSetBuilder, nameof(conventionSetBuilder));
DatabaseCreator = databaseCreator;
RawSqlCommandBuilder = rawSqlCommandBuilder;
Connection = connection;
Options = options;
ModelDiffer = modelDiffer;
MigrationsSqlGenerator = migrationsSqlGenerator;
SqlGenerationHelper = sqlGenerationHelper;
CoreConventionSetBuilder = coreConventionSetBuilder;
ConventionSetBuilder = conventionSetBuilder;
}
/// <summary>
/// Returns the model from the cache, or creates a model if it is not present in the cache.
/// </summary>
/// <param name="context"> The context the model is being produced for. </param>
/// <param name="conventionSetBuilder"> The convention set to use when creating the model. </param>
/// <returns> The model to be used. </returns>
public virtual IModel GetModel(
DbContext context,
IConventionSetBuilder conventionSetBuilder)
{
var cache = Dependencies.MemoryCache;
var cacheKey = Dependencies.ModelCacheKeyFactory.Create(context);
retry:
if (!cache.TryGetValue(cacheKey, out Lazy <IModel> model))
{
if (!_modelSyncObjects.TryAdd(cacheKey, value: null))
{
goto retry;
}
try
{
// Using a Lazy here so that OnModelCreating, etc. really only gets called once, since it may not be thread safe.
model = new Lazy <IModel>(
() => CreateModel(context, conventionSetBuilder),
LazyThreadSafetyMode.ExecutionAndPublication);
cache.Set(cacheKey, model, new MemoryCacheEntryOptions {
Size = 100, Priority = CacheItemPriority.High
});
}
finally
{
_modelSyncObjects.TryRemove(cacheKey, out _);
}
}
return(model.Value);
}
/// <summary>
/// Returns the model from the cache, or creates a model if it is not present in the cache.
/// </summary>
/// <param name="context"> The context the model is being produced for. </param>
/// <param name="conventionSetBuilder"> The convention set to use when creating the model. </param>
/// <param name="validator"> The validator to verify the model can be successfully used with the context. </param>
/// <returns> The model to be used. </returns>
public virtual IModel GetModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
=> _models.GetOrAdd(
Dependencies.ModelCacheKeyFactory.Create(context),
// Using a Lazy here so that OnModelCreating, etc. really only gets called once, since it may not be thread safe.
k => new Lazy <IModel>(
() => CreateModel(context, conventionSetBuilder, validator),
LazyThreadSafetyMode.ExecutionAndPublication)).Value;
/// <summary>
/// Returns the model from the cache, or creates a model if it is not present in the cache.
/// </summary>
/// <param name="context"> The context the model is being produced for. </param>
/// <param name="conventionSetBuilder"> The convention set to use when creating the model. </param>
/// <param name="modelDependencies"> The dependencies object for the model. </param>
/// <returns> The model to be used. </returns>
public virtual IModel GetModel(
DbContext context,
IConventionSetBuilder conventionSetBuilder,
ModelDependencies modelDependencies)
{
var cache = Dependencies.MemoryCache;
var cacheKey = Dependencies.ModelCacheKeyFactory.Create(context);
if (!cache.TryGetValue(cacheKey, out IModel model))
{
// Make sure OnModelCreating really only gets called once, since it may not be thread safe.
lock (_syncObject)
{
if (!cache.TryGetValue(cacheKey, out model))
{
model = CreateModel(context, conventionSetBuilder, modelDependencies);
model = cache.Set(cacheKey, model, new MemoryCacheEntryOptions {
Size = 100, Priority = CacheItemPriority.High
});
}
}
}
return(model);
}
/// <summary>
/// Creates the model. This method is called when the model was not found in the cache.
/// </summary>
/// <param name="context"> The context the model is being produced for. </param>
/// <param name="conventionSetBuilder"> The convention set to use when creating the model. </param>
/// <param name="validator"> The validator to verify the model can be successfully used with the context. </param>
/// <returns> The model to be used. </returns>
protected virtual IModel CreateModel(
[NotNull] DbContext context,
[CanBeNull] IConventionSetBuilder conventionSetBuilder,
[NotNull] IModelValidator validator)
{
Check.NotNull(context, nameof(context));
Check.NotNull(validator, nameof(validator));
var conventionSet = CreateConventionSet(conventionSetBuilder);
var modelBuilder = new ModelBuilder(conventionSet);
var internalModelBuilder = ((IInfrastructure <InternalModelBuilder>)modelBuilder).Instance;
internalModelBuilder.Metadata.SetProductVersion(ProductInfo.GetVersion());
FindSets(modelBuilder, context);
ModelCustomizer.Customize(modelBuilder, context);
internalModelBuilder.Validate();
validator.Validate(modelBuilder.Model);
return(modelBuilder.Model);
}
protected override IModel CreateModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
{
var model = base.CreateModel(context, conventionSetBuilder, validator) as Model;
model["AllYourModelAreBelongTo"] = "Us!";
return model;
}
protected override IModel CreateModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
{
var model = base.CreateModel(context, conventionSetBuilder, validator) as Model;
model["AllYourModelAreBelongTo"] = "Us!";
return(model);
}
/// <summary>
/// Creates the convention set to be used for the model. Uses the <see cref="CoreConventionSetBuilder" />
/// if <paramref name="conventionSetBuilder" /> is null.
/// </summary>
/// <param name="conventionSetBuilder"> The convention set builder to be used. </param>
/// <returns> The convention set to be used. </returns>
protected virtual ConventionSet CreateConventionSet([CanBeNull] IConventionSetBuilder conventionSetBuilder)
{
var conventionSet = CoreConventionSetBuilder.CreateConventionSet();
return(conventionSetBuilder == null
? conventionSet
: conventionSetBuilder.AddConventions(conventionSet));
}
protected IModel CreateModel(
DbContext context,
IConventionSetBuilder conventionSetBuilder)
{
var modelBuilder = new ModelBuilder(conventionSetBuilder.CreateConventionSet());
_dependencies.ModelCustomizer.Customize(modelBuilder, context);
return(modelBuilder.Model);
}
/// <summary>
/// Returns the model from the cache, or creates a model if it is not present in the cache.
/// </summary>
/// <param name="context"> The context the model is being produced for. </param>
/// <param name="conventionSetBuilder"> The convention set to use when creating the model. </param>
/// <returns> The model to be used. </returns>
public virtual IModel GetModel(
DbContext context,
IConventionSetBuilder conventionSetBuilder)
{
var modelBuilder = new ModelBuilder(conventionSetBuilder.CreateConventionSet());
Dependencies.ModelCustomizer.Customize(modelBuilder, context);
return(modelBuilder.FinalizeModel());
}
/// <summary>
/// Clones this dependency parameter object with one service replaced.
/// </summary>
/// <param name="conventionSetBuilder"> The convention set to use when creating the model. </param>
/// <returns> A new parameter object with the given service replaced. </returns>
public HistoryRepositoryDependencies With([NotNull] IConventionSetBuilder conventionSetBuilder)
=> new HistoryRepositoryDependencies(
DatabaseCreator,
RawSqlCommandBuilder,
Connection,
Options,
ModelDiffer,
MigrationsSqlGenerator,
SqlGenerationHelper,
CoreConventionSetBuilder,
conventionSetBuilder);
protected override IModel CreateModel(
DbContext context, IConventionSetBuilder conventionSetBuilder, ModelDependencies modelDependencies)
{
var modelBuilder = new ModelBuilder(conventionSetBuilder.CreateConventionSet(), modelDependencies);
Dependencies.ModelCustomizer.Customize(modelBuilder, context);
_onModelCreating(modelBuilder, context);
return(modelBuilder.FinalizeModel());
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public SnapshotModelProcessor(
[NotNull] IOperationReporter operationReporter,
[NotNull] IConventionSetBuilder conventionSetBuilder)
{
_operationReporter = operationReporter;
_relationalNames = new HashSet <string>(
typeof(RelationalAnnotationNames)
.GetRuntimeFields()
.Where(p => p.Name != nameof(RelationalAnnotationNames.Prefix))
.Select(p => ((string)p.GetValue(null)).Substring(RelationalAnnotationNames.Prefix.Length - 1)));
_conventionSetBuilder = conventionSetBuilder;
}
/// <summary>
/// Creates the model. This method is called when the model was not found in the cache.
/// </summary>
/// <param name="context"> The context the model is being produced for. </param>
/// <param name="conventionSetBuilder"> The convention set to use when creating the model. </param>
/// <returns> The model to be used. </returns>
protected virtual IModel CreateModel(
[NotNull] DbContext context,
[NotNull] IConventionSetBuilder conventionSetBuilder)
{
Check.NotNull(context, nameof(context));
var modelBuilder = new ModelBuilder(conventionSetBuilder.CreateConventionSet());
Dependencies.ModelCustomizer.Customize(modelBuilder, context);
return(modelBuilder.FinalizeModel());
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public ModelCreationDependencies(
[NotNull] IModelSource modelSource,
[NotNull] IConventionSetBuilder conventionSetBuilder,
[NotNull] ModelDependencies modelDependencies)
{
Check.NotNull(modelSource, nameof(modelSource));
Check.NotNull(conventionSetBuilder, nameof(conventionSetBuilder));
Check.NotNull(modelDependencies, nameof(modelDependencies));
ModelSource = modelSource;
ConventionSetBuilder = conventionSetBuilder;
ModelDependencies = modelDependencies;
}
/// <summary>
/// Clones this dependency parameter object with one service replaced.
/// </summary>
/// <param name="conventionSetBuilder"> The core convention set to use when creating the model. </param>
/// <returns> A new parameter object with the given service replaced. </returns>
public HistoryRepositoryDependencies With([NotNull] IConventionSetBuilder conventionSetBuilder)
=> new HistoryRepositoryDependencies(
DatabaseCreator,
RawSqlCommandBuilder,
Connection,
Options,
ModelDiffer,
MigrationsSqlGenerator,
SqlGenerationHelper,
conventionSetBuilder,
TypeMappingSource,
CurrentContext,
ModelLogger,
CommandLogger);
protected override IModel CreateModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
{
var conventionSet = CreateConventionSet(conventionSetBuilder);
conventionSet.ModelBuiltConventions.Add(new ValidatingConvention(validator));
var modelBuilder = new ModelBuilder(conventionSet);
Dependencies.ModelCustomizer.Customize(modelBuilder, context);
_onModelCreating(modelBuilder, context);
return(modelBuilder.FinalizeModel());
}
protected override IModel CreateModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
{
var conventionSet = CreateConventionSet(conventionSetBuilder);
var model = new Model();
var modelBuilder = new ModelBuilder(conventionSet, model);
FindSets(modelBuilder, context);
_onModelCreating(modelBuilder);
validator.Validate(model);
return model;
}
protected override IModel CreateModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
{
var conventionSet = CreateConventionSet(conventionSetBuilder);
var model = new Model();
var modelBuilder = new ModelBuilder(conventionSet, model);
FindSets(modelBuilder, context);
_onModelCreating(modelBuilder);
validator.Validate(model);
return(model);
}
protected override IModel CreateModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
{
var conventionSet = CreateConventionSet(conventionSetBuilder);
var modelBuilder = new ModelBuilder(conventionSet);
var model = (Model)modelBuilder.Model;
model.SetProductVersion(ProductInfo.GetVersion());
FindSets(modelBuilder, context);
_onModelCreating(modelBuilder);
model.Validate();
validator.Validate(model);
return model;
}
protected override IModel CreateModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
{
var conventionSet = CreateConventionSet(conventionSetBuilder);
var modelBuilder = new ModelBuilder(conventionSet);
var model = (Model)modelBuilder.Model;
model.SetProductVersion(ProductInfo.GetVersion());
FindSets(modelBuilder, context);
_onModelCreating(modelBuilder);
model.Validate();
validator.Validate(model);
return(model);
}
protected override IModel CreateModel(
DbContext context,
IConventionSetBuilder conventionSetBuilder,
IModelValidator validator,
IDiagnosticsLogger <DbLoggerCategory.Model.Validation> validationLogger)
{
var conventionSet = conventionSetBuilder.CreateConventionSet();
conventionSet.ModelFinalizedConventions.Add(new ValidatingConvention(validator, validationLogger));
var modelBuilder = new ModelBuilder(conventionSet);
Dependencies.ModelCustomizer.Customize(modelBuilder, context);
_onModelCreating(modelBuilder, context);
return(modelBuilder.FinalizeModel());
}
/// <summary>
/// Creates the model. This method is called when the model was not found in the cache.
/// </summary>
/// <param name="context"> The context the model is being produced for. </param>
/// <param name="conventionSetBuilder"> The convention set to use when creating the model. </param>
/// <param name="validator"> The validator to verify the model can be successfully used with the context. </param>
/// <returns> The model to be used. </returns>
protected virtual IModel CreateModel(
[NotNull] DbContext context,
[NotNull] IConventionSetBuilder conventionSetBuilder,
[NotNull] IModelValidator validator)
{
Check.NotNull(context, nameof(context));
Check.NotNull(validator, nameof(validator));
var conventionSet = CreateConventionSet(conventionSetBuilder);
conventionSet.ModelBuiltConventions.Add(new ValidatingConvention(validator));
var modelBuilder = new ModelBuilder(conventionSet);
Dependencies.ModelCustomizer.Customize(modelBuilder, context);
return(modelBuilder.FinalizeModel());
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public Migrator(
[NotNull] IMigrationsAssembly migrationsAssembly,
[NotNull] IHistoryRepository historyRepository,
[NotNull] IDatabaseCreator databaseCreator,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] IMigrationCommandExecutor migrationCommandExecutor,
[NotNull] IRelationalConnection connection,
[NotNull] ISqlGenerationHelper sqlGenerationHelper,
[NotNull] ICurrentDbContext currentContext,
[NotNull] IConventionSetBuilder conventionSetBuilder,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Migrations> logger,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Database.Command> commandLogger,
[NotNull] IDatabaseProvider databaseProvider)
{
Check.NotNull(migrationsAssembly, nameof(migrationsAssembly));
Check.NotNull(historyRepository, nameof(historyRepository));
Check.NotNull(databaseCreator, nameof(databaseCreator));
Check.NotNull(migrationsSqlGenerator, nameof(migrationsSqlGenerator));
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
Check.NotNull(migrationCommandExecutor, nameof(migrationCommandExecutor));
Check.NotNull(connection, nameof(connection));
Check.NotNull(sqlGenerationHelper, nameof(sqlGenerationHelper));
Check.NotNull(currentContext, nameof(currentContext));
Check.NotNull(conventionSetBuilder, nameof(conventionSetBuilder));
Check.NotNull(logger, nameof(logger));
Check.NotNull(commandLogger, nameof(commandLogger));
Check.NotNull(databaseProvider, nameof(databaseProvider));
_migrationsAssembly = migrationsAssembly;
_historyRepository = historyRepository;
_databaseCreator = (IRelationalDatabaseCreator)databaseCreator;
_migrationsSqlGenerator = migrationsSqlGenerator;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_migrationCommandExecutor = migrationCommandExecutor;
_connection = connection;
_sqlGenerationHelper = sqlGenerationHelper;
_currentContext = currentContext;
_conventionSetBuilder = conventionSetBuilder;
_logger = logger;
_commandLogger = commandLogger;
_activeProvider = databaseProvider.Name;
}
protected override IModel CreateModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
{
var conventionSet = CreateConventionSet(conventionSetBuilder);
var modelBuilder = new ModelBuilder(conventionSet);
var model = modelBuilder.GetInfrastructure().Metadata;
model.SetProductVersion(ProductInfo.GetVersion());
Dependencies.ModelCustomizer.Customize(modelBuilder, context);
_onModelCreating(modelBuilder, context);
model.Validate();
validator.Validate(model);
return(model);
}
public TemporalTableMigrator(
IMigrationsAssembly migrationsAssembly,
IHistoryRepository historyRepository,
IDatabaseCreator databaseCreator,
IEnumerable <IMigrationsSqlGenerator> migrationsSqlGenerators,
IRawSqlCommandBuilder rawSqlCommandBuilder,
IMigrationCommandExecutor migrationCommandExecutor,
IRelationalConnection connection,
ISqlGenerationHelper sqlGenerationHelper,
ICurrentDbContext currentDbContext,
IConventionSetBuilder conventionSetBuilder,
IDiagnosticsLogger <DbLoggerCategory.Migrations> logger,
IDiagnosticsLogger <DbLoggerCategory.Database.Command> commandLogger,
IDatabaseProvider databaseProvider,
ITemporalTableSqlExecutor <TContext> temporalTableSqlExecutor)
: base(migrationsAssembly, historyRepository, databaseCreator, resolveMigrationsSqlGenerator(migrationsSqlGenerators), rawSqlCommandBuilder, migrationCommandExecutor, connection, sqlGenerationHelper, currentDbContext, conventionSetBuilder, logger, commandLogger, databaseProvider)
{
this.temporalTableSqlExecutor = temporalTableSqlExecutor;
}
protected override IModel CreateModel(
[NotNull] DbContext context,
[NotNull] IConventionSetBuilder conventionSetBuilder,
[NotNull] IModelValidator validator)
{
var conventionSet = CreateConventionSet(conventionSetBuilder);
var modelBuilder = new BorlandModelBuilder(conventionSet, context);
var model = modelBuilder.GetInfrastructure().Metadata;
model[CoreAnnotationNames.ProductVersionAnnotation] = ProductInfo.GetVersion();
Dependencies.ModelCustomizer.Customize(modelBuilder, context);
model.Validate();
validator.Validate(model);
return(model);
}
/// <summary>
/// Creates the model. This method is called when the model was not found in the cache.
/// </summary>
/// <param name="context"> The context the model is being produced for. </param>
/// <param name="conventionSetBuilder"> The convention set to use when creating the model. </param>
/// <param name="validator"> The validator to verify the model can be successfully used with the context. </param>
/// <param name="validationLogger"> The validation loggers to use. </param>
/// <returns> The model to be used. </returns>
protected virtual IModel CreateModel(
[NotNull] DbContext context,
[NotNull] IConventionSetBuilder conventionSetBuilder,
[NotNull] IModelValidator validator,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Model.Validation> validationLogger)
{
Check.NotNull(context, nameof(context));
Check.NotNull(validator, nameof(validator));
Check.NotNull(validationLogger, nameof(validationLogger));
var conventionSet = conventionSetBuilder.CreateConventionSet();
conventionSet.ModelFinalizedConventions.Add(new ValidatingConvention(validator, validationLogger));
var modelBuilder = new ModelBuilder(conventionSet);
Dependencies.ModelCustomizer.Customize(modelBuilder, context);
return(modelBuilder.FinalizeModel());
}
/// <summary>
/// Initializes a new instance of the <see cref="PluginHistoryRepositoryDependencies"/> class.
/// </summary>
/// <param name="rawSqlCommandBuilder">The raw SQL command builder.</param>
/// <param name="connection">The connection.</param>
/// <param name="currentContext">The current context.</param>
/// <param name="conventionSetBuilder">The convention set builder.</param>
/// <param name="modelDiffer">The model differ.</param>
/// <param name="migrationsSqlGenerator">The migrations SQL generator.</param>
/// <param name="sqlGenerationHelper">The SQL generation helper.</param>
/// <param name="typeMappingSource">The type mapping source.</param>
/// <param name="commandLogger">The command logger.</param>
public PluginHistoryRepositoryDependencies(
IRawSqlCommandBuilder rawSqlCommandBuilder,
IRelationalConnection connection,
ICurrentDbContext currentContext,
IConventionSetBuilder conventionSetBuilder,
IMigrationsModelDiffer modelDiffer,
IMigrationsSqlGenerator migrationsSqlGenerator,
ISqlGenerationHelper sqlGenerationHelper,
IRelationalTypeMappingSource typeMappingSource,
IDiagnosticsLogger <DbLoggerCategory.Database.Command> commandLogger)
{
RawSqlCommandBuilder = rawSqlCommandBuilder;
Connection = connection;
CurrentContext = currentContext;
ConventionSetBuilder = conventionSetBuilder;
ModelDiffer = modelDiffer;
MigrationsSqlGenerator = migrationsSqlGenerator;
SqlGenerationHelper = sqlGenerationHelper;
TypeMappingSource = typeMappingSource;
CommandLogger = commandLogger;
}
protected override IModel CreateModel(
DbContext context,
IConventionSetBuilder conventionSetBuilder,
IModelValidator validator)
{
var conventionSet = CreateConventionSet(conventionSetBuilder);
var modelBuilder = new MaterializingModelBuilder(conventionSet);
var internalModelBuilder = ((IInfrastructure<InternalModelBuilder>)modelBuilder).Instance;
internalModelBuilder.Metadata.SetProductVersion(ProductInfo.GetVersion());
FindSets(modelBuilder, context);
ModelCustomizer.Customize(modelBuilder, context);
internalModelBuilder.Validate();
validator.Validate(modelBuilder.Model);
return modelBuilder.Model;
}
/// <summary>
/// Creates the model. This method is called when the model was not found in the cache.
/// </summary>
/// <param name="context"> The context the model is being produced for. </param>
/// <param name="conventionSetBuilder"> The convention set to use when creating the model. </param>
/// <param name="validator"> The validator to verify the model can be successfully used with the context. </param>
/// <returns> The model to be used. </returns>
protected virtual IModel CreateModel(
[NotNull] DbContext context,
[NotNull] IConventionSetBuilder conventionSetBuilder,
[NotNull] IModelValidator validator)
{
Check.NotNull(context, nameof(context));
Check.NotNull(validator, nameof(validator));
var conventionSet = CreateConventionSet(conventionSetBuilder);
var modelBuilder = new ModelBuilder(conventionSet);
var model = modelBuilder.GetInfrastructure().Metadata;
model.SetProductVersion(ProductInfo.GetVersion());
Dependencies.ModelCustomizer.Customize(modelBuilder, context);
model.Validate();
validator.Validate(model);
return(model);
}
/// <summary>
/// Returns the model from the cache, or creates a model if it is not present in the cache.
/// </summary>
/// <param name="context"> The context the model is being produced for. </param>
/// <param name="conventionSetBuilder"> The convention set to use when creating the model. </param>
/// <param name="validator"> The validator to verify the model can be successfully used with the context. </param>
/// <returns> The model to be used. </returns>
public virtual IModel GetModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
=> _models.GetOrAdd(ModelCacheKeyFactory.Create(context), k => CreateModel(context, conventionSetBuilder, validator));
public virtual IModel GetModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator = null)
{
return null;
}
public virtual IModel GetModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
=> _models.GetOrAdd(context.GetType(), k => CreateModel(context, conventionSetBuilder, validator));
public override IModel GetModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
=> _testModelSource.GetModel(context, conventionSetBuilder, validator);
