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 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 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 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);
}
}
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}\";");
}
}
