public void GetAlterSql(ISqlDumper dmp)
{
VersionDef current = Version;
VersionDef prev = Version.GetVersion(-1);
var vardef = new VariantDef(VariantFile);
DatabaseStructure curstruct = current.LoadStructure(vardef);
DatabaseStructure prevstruct = prev.LoadStructure(vardef);
ISqlDialect dialect = curstruct.Dialect ?? Version.Db.Dialect;
DbDiffOptions opts = new DbDiffOptions();
//if (prev != null) dmp.TargetDb = new DbDefSource(DatabaseStructure.Load(prev.GetFile()), DbDefSource.ReadOnly.Flag);
opts.AllowRecreateTable = true;
if (prevstruct == null)
{
dmp.CreateDatabaseObjects(curstruct);
}
else
{
dmp.AlterDatabase(prevstruct, curstruct, opts, new Plugin.dbmodel.DbDefSource(prevstruct, Plugin.dbmodel.DbDefSource.ReadOnly.Flag), null);
}
current.SetVersionSql(dmp);
}
private void TestTableDiff(string tableName, Action <TableInfo> mangle)
{
var dbinfo = FullAnalyse();
var table = dbinfo.FindTableLike(tableName);
var alteredTableInfo = table.CloneTable();
mangle(alteredTableInfo);
var caps = DatabaseFactory.DumperCaps;
var opts = new DbDiffOptions();
AlterPlan plan = DbDiffTool.PlanAlterTable(table, alteredTableInfo, opts, dbinfo);
plan.AddLogicalDependencies(caps, opts);
plan.Transform(caps, opts);
string sql = GenerateScriptForPlan(plan);
_output.WriteLine(sql);
RunPlan(plan);
var newStructure = FullAnalyse();
var newTableInfo = newStructure.FindTableLike(tableName);
AssertEqual(alteredTableInfo, newTableInfo);
}
public void GetAlterSql(ISqlDumper dmp)
{
DumpSubFolder(dmp, "before");
VersionDef current = this;
VersionDef prev = current.GetVersion(-1);
VersionDb vdb = current.Db;
DatabaseStructure curstruct = DatabaseStructure.Load(current.GetFile());
DatabaseStructure prevstruct = null;
if (prev != null)
{
prevstruct = DatabaseStructure.Load(prev.GetFile());
}
ISqlDialect dialect = vdb.Dialect;
DbDiffOptions opts = new DbDiffOptions();
//if (prev != null) dmp.TargetDb = new DbDefSource(DatabaseStructure.Load(prev.GetFile()), DbDefSource.ReadOnly.Flag);
opts.AllowRecreateTable = true;
if (prevstruct == null)
{
dmp.CreateDatabaseObjects(curstruct);
}
else
{
dmp.AlterDatabase(prevstruct, curstruct, opts, new Plugin.dbmodel.DbDefSource(prevstruct, Plugin.dbmodel.DbDefSource.ReadOnly.Flag), AddSubFoldersToPlan);
}
DumpSubFolder(dmp, "after");
current.SetVersionSql(dmp);
}
public override void RunCommand()
{
IDatabaseSource srcDb = m_source.GetConnection();
IDatabaseSource dstDb = m_target.GetConnection();
Async.SafeOpen(srcDb.Connection); Async.SafeOpen(dstDb.Connection);
var src = srcDb.InvokeLoadStructure(DatabaseStructureMembers.FullStructure, null);
var dst = dstDb.InvokeLoadStructure(DatabaseStructureMembers.FullStructure, null);
var opts = new DbDiffOptions();
opts.IgnoreColumnOrder = true;
//var diff = new DatabaseDiff(src, dst, opts);
ISqlDialect dial;
if (Dialect != null)
{
dial = (ISqlDialect)DialectAddonType.Instance.FindHolder(Dialect).CreateInstance();
}
else
{
dial = new GenericDialect();
}
using (TextWriter fw = GetOutputStream())
{
SqlOutputStream so = new SqlOutputStream(dial, fw, new SqlFormatProperties());
ISqlDumper dmp = dial.CreateDumper(so, new SqlFormatProperties());
dmp.AlterDatabase(src, dst, opts, new DbDefSource(src, DbDefSource.ReadOnly.Flag));
//dmp.TargetDb = new DbDefSource(dst, DbDefSource.ReadOnly.Flag);
//diff.Actions.GenerateScript(dmp);
}
Async.SafeClose(srcDb.Connection); Async.SafeClose(dstDb.Connection);
}
//public ITableSource CreateTable(ITableStructure table)
//{
// Reload();
// ITableSource res = new TableDefSource(this, m_db.AddTable(MangleTable(table)));
// m_db.SortTables();
// SaveToFile();
// return res;
//}
public void AlterDatabase(IDatabaseStructure src, IDatabaseStructure dst, DbDiffOptions opts)
{
Reload();
if (!SupportsMultipleSchema())
{
var tmp = new DatabaseStructure(dst);
tmp.RunNameTransformation(new SetSchemaNameTransformation(null));
dst = tmp;
}
m_conn.DbStruct.AlterDatabase(src, dst, opts, this);
SaveToFile();
}
public DatabaseDiff(IDatabaseStructure src, IDatabaseStructure dst, DbDiffOptions options, ISqlDialect dialect)
{
m_dialect = dialect;
m_src = new DatabaseStructure(src);
m_dst = new DatabaseStructure(dst);
if (m_src.Dialect != null && m_src.Dialect.DialectName != dialect.DialectName)
{
dialect.MigrateDatabase(m_src, dialect.GetDefaultMigrationProfile(), null);
}
m_actions = new DbDiffAction(this);
//m_actions = new DiffActionDatabase(this, m_src, m_dst);
m_options = options;
RebuildGroupIdDictionary();
if (m_src.GroupId != m_dst.GroupId)
{
CreatePairing();
}
CreateActions();
}
private DbDiffOptions CreateDbDiffOptions()
{
var opts = new DbDiffOptions();
var log = new CachingLogger(LogLevel.All);
messageLogFrame1.Source = log;
opts.DiffLogger = log;
if (m_dstDb.Dialect != null)
{
opts.LeftImplicitSchema = m_dstDb.Dialect.DefaultSchema;
}
if (m_srcDb.Dialect != null)
{
opts.RightImplicitSchema = m_srcDb.Dialect.DefaultSchema;
}
if (!m_dstDb.DatabaseCaps.MultipleSchema)
{
opts.SchemaMode = DbDiffSchemaMode.Ignore;
}
if (!m_srcDb.DatabaseCaps.MultipleSchema)
{
opts.SchemaMode = DbDiffSchemaMode.Ignore;
}
if (m_settings.IgnoreSchema)
{
opts.SchemaMode = DbDiffSchemaMode.Ignore;
}
opts.IgnoreAllTableProperties = m_settings.IgnoreAllTableProperties;
opts.IgnoreColumnOrder = m_settings.IgnoreColumnOrder;
opts.IgnoreConstraintNames = m_settings.IgnoreConstraintNames;
opts.IgnoreTableProperties = m_settings.IgnoreTableProperties;
opts.IgnoreDataTypeProperties = m_settings.IgnoreDataTypeProperties;
opts.IgnoreColumnCharacterSet = m_settings.IgnoreColumnCharacterSet;
opts.IgnoreColumnCollation = m_settings.IgnoreColumnCollation;
opts.IgnoreCase = m_settings.IgnoreCase;
opts.AllowRecreateConstraint = true;
opts.AllowRecreateSpecificObject = true;
opts.AllowRecreateTable = true;
opts.AllowPairRenamedTables = m_settings.AllowPairRenamedTables;
return(opts);
}
public override bool Save()
{
var dialect = m_conn.Dialect ?? GenericDialect.Instance;
var plan = new AlterPlan();
var opts = new DbDiffOptions();
var log = new CachingLogger(LogLevel.Info);
opts.AlterLogger = log;
DbDiffTool.AlterDatabase(plan, new DbObjectPairing(m_origDb, m_db), opts);
string alterSql = dialect.GenerateScript(dmp => plan.CreateRunner().Run(dmp, opts));
if (!SqlConfirmForm.Run(alterSql, dialect, log))
{
return(false);
}
m_conn.AlterDatabase(plan, opts);
objectGridView1.Modified = false;
UpdateState();
LoadStructure();
return(true);
}
public override void GenerateSql(AppObject appobj, ISqlDumper dmp, ISqlDialect dialect)
{
var vdb = (VersionDbAppObject)appobj;
var fromv = vdb.GetVdb().FindVersion(FromVersion);
var tov = vdb.GetVdb().FindVersion(ToVersion);
DatabaseStructure fromstruct = null;
if (fromv != null)
{
fromstruct = DatabaseStructure.Load(fromv.GetFile());
}
DatabaseStructure tostruct = null;
if (tov != null)
{
tostruct = DatabaseStructure.Load(tov.GetFile());
}
if (tostruct == null)
{
return;
}
DbDiffOptions opts = new DbDiffOptions();
//if (prev != null) dmp.TargetDb = new DbDefSource(DatabaseStructure.Load(prev.GetFile()), DbDefSource.ReadOnly.Flag);
opts.AllowRecreateTable = true;
if (fromstruct == null)
{
dmp.CreateDatabaseObjects(tostruct);
}
else
{
dmp.AlterDatabase(fromstruct, tostruct, opts, new Plugin.dbmodel.DbDefSource(fromstruct, Plugin.dbmodel.DbDefSource.ReadOnly.Flag), null);
}
tov.SetVersionSql(dmp);
}
public void AlterDatabase(AlterPlan plan, DbDiffOptions opts)
{
Reload();
plan.CreateRunner().Run(m_conn.DbStruct, opts);
SaveToFile();
}
