public void rebuilds_if_it_does_not_exist_in_the_schema_if_auto_create_is_create_or_update() { var schema = Substitute.For <IDocumentSchema>(); schema.StoreOptions.Returns(new StoreOptions()); var dbobjects = Substitute.For <IDbObjects>(); schema.DbObjects.Returns(dbobjects); var func = TransformFunction.ForFile(new StoreOptions { AutoCreateSchemaObjects = AutoCreate.CreateOrUpdate }, _getFullnameJs); dbobjects.SchemaFunctionNames().Returns(Enumerable.Empty <FunctionName>()); var patch = new SchemaPatch(new DdlRules()); func.GenerateSchemaObjectsIfNecessary(AutoCreate.CreateOrUpdate, schema, patch); var generated = func.GenerateFunction(); patch.UpdateDDL.ShouldContain(generated); patch.RollbackDDL.ShouldContain("DROP FUNCTION IF EXISTS public.mt_transform_get_fullname(JSONB)"); }
public SchemaPatchDifference CreatePatch(DbDataReader reader, SchemaPatch patch, AutoCreate autoCreate) { var diff = fetchDelta(reader, patch.Rules); if (diff == null) { Write(patch.Rules, patch.UpWriter); WriteDropStatement(patch.Rules, patch.DownWriter); return(SchemaPatchDifference.Create); } if (diff.AllNew) { Write(patch.Rules, patch.UpWriter); WriteDropStatement(patch.Rules, patch.DownWriter); return(SchemaPatchDifference.Create); } if (diff.HasChanged) { diff.WritePatch(patch); return(SchemaPatchDifference.Update); } return(SchemaPatchDifference.None); }
/// <summary> /// Called when [execute]. /// </summary> /// <returns>System.Int32.</returns> public int OnExecute() { try { _store.Schema.AssertDatabaseMatchesConfiguration(); _logger.LogInformation( "No differences were detected between the Marten configuration and the database" ); return(0); } catch (SchemaValidationException) { var patch = _store.Schema.ToPatch(Schema, AutoCreateAll); _logger.LogInformation("Wrote a patch file to {FileName}", FileName); patch.WriteUpdateFile(FileName, TransactionalScript); var dropFile = Drop ?? SchemaPatch.ToDropFileName(FileName); _logger.LogInformation("Wrote the drop file to {DropFile}", dropFile); patch.WriteRollbackFile(dropFile, TransactionalScript); return(0); } }
private void writeTable() { var table = new DocumentTable(theMapping); var patch = new SchemaPatch(new DdlRules()); var cmd = _conn.CreateCommand(); var builder = new CommandBuilder(cmd); table.ConfigureQueryCommand(builder); cmd.CommandText = builder.ToString(); try { using (var reader = cmd.ExecuteReader()) { table.CreatePatch(reader, patch, AutoCreate.All); } _conn.CreateCommand(patch.UpdateDDL).ExecuteNonQuery(); } catch (Exception) { Console.WriteLine(builder.ToString()); throw; } }
private void generateOrUpdateFeature(Type featureType, IFeatureSchema feature) { lock (_updateLock) { using (var conn = _factory.Create()) { conn.Open(); var patch = new SchemaPatch(_options.DdlRules); patch.Apply(conn, _options.AutoCreateSchemaObjects, feature.Objects); patch.AssertPatchingIsValid(_options.AutoCreateSchemaObjects); var ddl = patch.UpdateDDL; if (patch.Difference != SchemaPatchDifference.None && ddl.IsNotEmpty()) { var cmd = conn.CreateCommand(ddl); try { cmd.ExecuteNonQuery(); _options.Logger().SchemaChange(ddl); RegisterCheck(featureType, feature); } catch (Exception e) { throw new MartenCommandException(cmd, e); } } else if (patch.Difference == SchemaPatchDifference.None) { RegisterCheck(featureType, feature); } } } }
public void WritePatchByType(string directory) { var system = new FileSystem(); system.DeleteDirectory(directory); system.CreateDirectory(directory); var features = _features.AllActiveFeatures(_tenant).ToArray(); writeDatabaseSchemaGenerationScript(directory, system, features); using (var conn = _tenant.CreateConnection()) { conn.Open(); foreach (var feature in features) { var patch = new SchemaPatch(StoreOptions.DdlRules); patch.Apply(conn, AutoCreate.CreateOrUpdate, feature.Objects); if (patch.UpdateDDL.IsNotEmpty()) { var file = directory.AppendPath(feature.Identifier + ".sql"); patch.WriteUpdateFile(file); } } } }
public void rebuilds_if_it_does_not_exist_in_the_schema_if_auto_create_is_all() { var schema = Substitute.For <IDocumentSchema>(); schema.StoreOptions.Returns(new StoreOptions()); var dbobjects = Substitute.For <IDbObjects>(); schema.DbObjects.Returns(dbobjects); var func = TransformFunction.ForFile(new StoreOptions { AutoCreateSchemaObjects = AutoCreate.All }, _getFullnameJs); dbobjects.SchemaFunctionNames().Returns(Enumerable.Empty <FunctionName>()); var patch = new SchemaPatch(new DdlRules()); func.GenerateSchemaObjectsIfNecessary(AutoCreate.All, schema, patch); var generated = func.GenerateFunction(); patch.UpdateDDL.ShouldContain(generated); }
protected override bool execute(IDocumentStore store, PatchInput input) { try { store.Schema.AssertDatabaseMatchesConfiguration(); input.WriteLine(ConsoleColor.Green, "No differences were detected between the Marten configuration and the database"); return(true); } catch (SchemaValidationException) { var patch = store.Schema.ToPatch(input.SchemaFlag); input.WriteLine(ConsoleColor.Green, "Wrote a patch file to " + input.FileName); patch.WriteUpdateFile(input.FileName); var dropFile = input.DropFlag ?? SchemaPatch.ToDropFileName(input.FileName); input.WriteLine(ConsoleColor.Green, "Wrote the drop file to " + dropFile); patch.WriteRollbackFile(dropFile); return(true); } }
public void determine_that_it_is_missing() { var patch = new SchemaPatch(new DdlRules()); patch.Apply(_conn, AutoCreate.All, theSequence); patch.Difference.ShouldBe(SchemaPatchDifference.Create); }
private void writeAndApplyPatch(AutoCreate autoCreate, DocumentTable table) { var patch = new SchemaPatch(new DdlRules()); patch.Apply(_conn, autoCreate, new ISchemaObject[] { table }); _conn.CreateCommand(patch.UpdateDDL).ExecuteNonQuery(); }
public void WritePatch(IDocumentSchema schema, SchemaPatch patch) { var diff = functionDiff(schema); if (diff.AllNew || !diff.Actual.Body.Contains(Body)) { diff.WritePatch(schema.StoreOptions, patch); } }
public void patch_if_it_does_not_exist() { var patch = new SchemaPatch(); theStore.Advanced.Options.Transforms.For("get_fullname") .WritePatch(theStore.Schema, patch); patch.UpdateDDL.ShouldContain("CREATE OR REPLACE FUNCTION public.mt_transform_get_fullname(doc JSONB) RETURNS JSONB AS $$"); }
public void should_not_throw_exception_on_assertion(SchemaPatchDifference difference, AutoCreate autoCreate) { var patch = new SchemaPatch(new DdlRules()); var table1 = new Table(new DbObjectName("public", "sometable1")); patch.Log(table1, difference); patch.AssertPatchingIsValid(autoCreate); }
public void WritePatch(IDocumentSchema schema, SchemaPatch patch) { var diff = functionDiff(schema); if (diff.AllNew || diff.HasChanged) { diff.WritePatch(schema.StoreOptions, patch); } }
public void WritePatch(IDocumentSchema schema, SchemaPatch patch) { if (!schema.DbObjects.TableExists(Table)) { var sqlScript = SchemaBuilder.GetSqlScript(Table.Schema, "mt_hilo"); patch.Updates.Apply(this, sqlScript); patch.Rollbacks.Drop(this, Table); } }
public void determine_that_it_is_already_there() { can_create_sequence_without_blowing_up(); var patch = new SchemaPatch(new DdlRules()); patch.Apply(_conn, AutoCreate.All, theSequence); patch.Difference.ShouldBe(SchemaPatchDifference.None); }
public SchemaPatchDifference CreatePatch(DbDataReader reader, SchemaPatch patch, AutoCreate autoCreate) { if (!reader.Read() || reader.GetInt32(0) == 0) { Write(patch.Rules, patch.UpWriter); return(SchemaPatchDifference.Create); } return(SchemaPatchDifference.None); }
private void writeOwnership(IDocumentSchema schema, SchemaPatch patch) { if (schema.StoreOptions.OwnerName.IsNotEmpty()) { patch.Updates.Apply(this, $"ALTER TABLE {schema.StoreOptions.DatabaseSchemaName}.mt_hilo OWNER TO \"{schema.StoreOptions.OwnerName}\";"); patch.Updates.Apply(this, $"ALTER FUNCTION {schema.StoreOptions.DatabaseSchemaName}.mt_get_next_hi(varchar) OWNER TO \"{schema.StoreOptions.OwnerName}\";"); } }
public void WriteSchemaObjects(IDocumentSchema schema, StringWriter writer) { var patch = new SchemaPatch(schema.StoreOptions.DdlRules, writer); var sqlScript = SchemaBuilder.GetSqlScript(Table.Schema, "mt_hilo"); writer.WriteLine(sqlScript); writer.WriteLine(""); writer.WriteLine(""); }
public SchemaPatchDifference CreatePatch(DbDataReader reader, SchemaPatch patch, AutoCreate autoCreate) { var existing = readExistingTable(reader); if (existing == null) { Write(patch.Rules, patch.UpWriter); patch.Rollbacks.Drop(this, Identifier); return(SchemaPatchDifference.Create); } var delta = new TableDelta(this, existing); if (delta.Matches) { return(SchemaPatchDifference.None); } if (delta.Extras.Any() || delta.Different.Any()) { if (autoCreate == AutoCreate.All) { delta.ForeignKeyMissing.Each(x => patch.Updates.Apply(this, x)); delta.ForeignKeyRollbacks.Each(x => patch.Rollbacks.Apply(this, x)); delta.ForeignKeyMissingRollbacks.Each(x => patch.Rollbacks.Apply(this, x)); Write(patch.Rules, patch.UpWriter); return(SchemaPatchDifference.Create); } return(SchemaPatchDifference.Invalid); } if (!delta.Missing.All(x => x.CanAdd)) { return(SchemaPatchDifference.Invalid); } foreach (var missing in delta.Missing) { patch.Updates.Apply(this, missing.AddColumnSql(this)); patch.Rollbacks.RemoveColumn(this, Identifier, missing.Name); } delta.IndexChanges.Each(x => patch.Updates.Apply(this, x)); delta.IndexRollbacks.Each(x => patch.Rollbacks.Apply(this, x)); delta.ForeignKeyChanges.Each(x => patch.Updates.Apply(this, x)); delta.ForeignKeyRollbacks.Each(x => patch.Rollbacks.Apply(this, x)); delta.ForeignKeyMissingRollbacks.Each(x => patch.Rollbacks.Apply(this, x)); return(SchemaPatchDifference.Update); }
private void writeOwnership(StoreOptions options, SchemaPatch patch) { if (options.OwnerName.IsEmpty()) { return; } var toOwnershipDdl = createOwnershipDDL(options); patch.Updates.Apply(this, toOwnershipDdl); }
public void should_throw_exception_on_assertion(SchemaPatchDifference difference, AutoCreate autoCreate) { var patch = new SchemaPatch(new DdlRules()); var table1 = new Table(new DbObjectName("public", "sometable1")); patch.Log(table1, difference); Exception <InvalidOperationException> .ShouldBeThrownBy(() => { patch.AssertPatchingIsValid(autoCreate); }); }
private void writeAndApplyPatch(AutoCreate autoCreate, DocumentTable table) { var patch = new SchemaPatch(new DdlRules()); patch.Apply(_conn, autoCreate, new ISchemaObject[] { table }); var updateDDL = patch.UpdateDDL; if (!string.IsNullOrEmpty(updateDDL)) { _conn.CreateCommand(updateDDL).ExecuteNonQuery(); } }
public void invalid_wins_over_all_else() { var patch = new SchemaPatch(new DdlRules()); var table1 = new Table(new DbObjectName("public", "sometable1")); var table2 = new Table(new DbObjectName("public", "sometable2")); var table3 = new Table(new DbObjectName("public", "sometable3")); var table4 = new Table(new DbObjectName("public", "sometable4")); patch.Log(table1, SchemaPatchDifference.Invalid); patch.Log(table2, SchemaPatchDifference.Create); patch.Log(table3, SchemaPatchDifference.None); patch.Log(table4, SchemaPatchDifference.Update); patch.Difference.ShouldBe(SchemaPatchDifference.Invalid); }
public SchemaPatch ToPatch(Type documentType) { var mapping = _features.MappingFor(documentType); var patch = new SchemaPatch(StoreOptions.DdlRules); using (var conn = _tenant.CreateConnection()) { conn.Open(); patch.Apply(conn, AutoCreate.CreateOrUpdate, mapping.As <IFeatureSchema>().Objects); } return(patch); }
public void WritePatch(string filename, bool withSchemas = true) { if (!Path.IsPathRooted(filename)) { filename = AppContext.BaseDirectory.AppendPath(filename); } var patch = ToPatch(withSchemas); patch.WriteUpdateFile(filename); var dropFile = SchemaPatch.ToDropFileName(filename); patch.WriteRollbackFile(dropFile); }
public void WritePatch(string filename, bool withSchemas = true, bool transactionalScript = true) { if (!Path.IsPathRooted(filename)) { filename = AppContext.BaseDirectory.AppendPath(filename); } var patch = ToPatch(withSchemas, withAutoCreateAll: true); patch.WriteUpdateFile(filename, transactionalScript); var dropFile = SchemaPatch.ToDropFileName(filename); patch.WriteRollbackFile(dropFile, transactionalScript); }
public void return_none_if_no_changes_detected() { var patch = new SchemaPatch(new DdlRules()); var table1 = new Table(new DbObjectName("public", "sometable1")); var table2 = new Table(new DbObjectName("public", "sometable2")); var table3 = new Table(new DbObjectName("public", "sometable3")); var table4 = new Table(new DbObjectName("public", "sometable4")); patch.Log(table1, SchemaPatchDifference.None); patch.Log(table2, SchemaPatchDifference.None); patch.Log(table3, SchemaPatchDifference.None); patch.Log(table4, SchemaPatchDifference.None); patch.Difference.ShouldBe(SchemaPatchDifference.None); }
public void update_is_second_in_priority() { var patch = new SchemaPatch(new DdlRules()); var table1 = new Table(new DbObjectName("public", "sometable1")); var table2 = new Table(new DbObjectName("public", "sometable2")); var table3 = new Table(new DbObjectName("public", "sometable3")); var table4 = new Table(new DbObjectName("public", "sometable4")); //patch.Log(table1, SchemaPatchDifference.Invalid); patch.Log(table2, SchemaPatchDifference.Create); patch.Log(table3, SchemaPatchDifference.None); patch.Log(table4, SchemaPatchDifference.Update); patch.Difference.ShouldBe(SchemaPatchDifference.Update); }
public void create_takes_precedence_over_none() { var patch = new SchemaPatch(new DdlRules()); var table1 = new Table(new DbObjectName("public", "sometable1")); var table2 = new Table(new DbObjectName("public", "sometable2")); var table3 = new Table(new DbObjectName("public", "sometable3")); var table4 = new Table(new DbObjectName("public", "sometable4")); //patch.Log(table1, SchemaPatchDifference.Invalid); patch.Log(table2, SchemaPatchDifference.Create); patch.Log(table3, SchemaPatchDifference.None); //patch.Log(table4, SchemaPatchDifference.Update); patch.Difference.ShouldBe(SchemaPatchDifference.Create); }
public void GenerateSchemaObjectsIfNecessary(AutoCreate autoCreateSchemaObjectsMode, IDocumentSchema schema, SchemaPatch patch) { if (_checked) return; _checked = true; if (!schema.DbObjects.TableExists(Table)) { if (_options.AutoCreateSchemaObjects == AutoCreate.None) { throw new InvalidOperationException($"Hilo table is missing, but {nameof(StoreOptions.AutoCreateSchemaObjects)} is {_options.AutoCreateSchemaObjects}"); } WritePatch(schema, patch); } }