Пример #1
0
        private IModel EnsureModel()
        {
            if (_model == null)
            {
                var conventionSet = Dependencies.ConventionSetBuilder.CreateConventionSet();

                // Use public API to remove the convention, issue #214
                ConventionSet.Remove(conventionSet.ModelInitializedConventions, typeof(DbSetFindingConvention));
                var modelBuilder = new ModelBuilder(conventionSet);
                modelBuilder.Entity <HistoryRow>(
                    x =>
                {
                    ConfigureTable(x);
                    x.ToTable(TableName, TableSchema);
                });

                _model = modelBuilder.FinalizeModel();
            }

            return(_model);
        }
Пример #2
0
        // ReSharper restore UnusedMember.Local

        private IModel BuildModel(Action <ModelBuilder> buildAction, bool useRegex)
        {
            var serviceProvider = SqlServerTestHelpers.Instance.CreateContextServices();

            var conventionSet = SqlServerTestHelpers.Instance.CreateConventionSetBuilder().CreateConventionSet();

            ConventionSet.Remove(conventionSet.ModelFinalizedConventions, typeof(ValidatingConvention));
            conventionSet.ModelFinalizingConventions.Add(
                new ValidationCheckConstraintConvention(
                    new ValidationCheckConstraintOptions()
            {
                UseRegex = useRegex
            },
                    serviceProvider.GetRequiredService <ISqlGenerationHelper>(),
                    serviceProvider.GetRequiredService <IRelationalTypeMappingSource>(),
                    serviceProvider.GetRequiredService <IDatabaseProvider>()));

            var builder = new ModelBuilder(conventionSet);

            buildAction(builder);
            return(builder.FinalizeModel());
        }
Пример #3
0
        private IModel EnsureModel()
        {
            if (_model == null)
            {
                var conventionSet = Dependencies.ConventionSetBuilder.CreateConventionSet();

                // Use public API to remove the convention, issue #214
                ConventionSet.Remove(conventionSet.ModelInitializedConventions, typeof(DbSetFindingConvention));
                ConventionSet.Remove(conventionSet.ModelInitializedConventions, typeof(RelationalDbFunctionAttributeConvention));

                var modelBuilder = new ModelBuilder(conventionSet);
                modelBuilder.Entity <HistoryRow>(
                    x =>
                {
                    ConfigureTable(x);
                    x.ToTable(TableName, TableSchema);
                });

                _model = Dependencies.ModelRuntimeInitializer.Initialize((IModel)modelBuilder.Model, designTime: true, validationLogger: null);
            }

            return(_model);
        }
        /// <summary>
        /// Ensures the model exists and returns it.
        /// </summary>
        /// <returns>The model that defines the structure of the history table.</returns>
        private IModel EnsureModel()
        {
            if (_model == null)
            {
                var conventionSet = Dependencies.ConventionSetBuilder.CreateConventionSet();
                ConventionSet.Remove(conventionSet.ModelInitializedConventions, typeof(DbSetFindingConvention));

                var modelBuilder = new ModelBuilder(conventionSet);
                modelBuilder.Entity <PluginHistoryRow>(
                    table =>
                {
                    table.ToTable(TableName);
                    table.HasKey(new[] { nameof(PluginHistoryRow.Plugin), nameof(PluginHistoryRow.MigrationId) });
                    table.Property(h => h.Plugin).HasMaxLength(150);
                    table.Property(h => h.MigrationId).HasMaxLength(150);
                    table.Property(h => h.ProductVersion).HasMaxLength(32).IsRequired();
                });

                _model = modelBuilder.FinalizeModel();
            }

            return(_model);
        }