public override void TransformToImplementedOps(AlterProcessorCaps caps, DbDiffOptions opts, List <AlterOperation> replacement, AlterPlan plan, IDatabaseSource targetDb)
{
if (!caps.PermuteColumns)
{
TransformToRecreateTable(replacement, plan, targetDb);
}
}
public override void TransformToImplementedOps(AlterProcessorCaps caps, DbDiffOptions opts, List <AlterOperation> replacement, AlterPlan plan, IDatabaseSource targetDb)
{
if (targetDb != null && !targetDb.Dialect.DialectCaps.UncheckedReferences)
{
replacement.Clear();
replacement.Add(this);
var table = (TableStructure)NewObject;
foreach (var cnt in new List <IConstraint>(table.Constraints))
{
var fk = cnt as ForeignKey;
if (fk == null)
{
continue;
}
table._Constraints.Remove(cnt);
fk.SetDummyTable(table.FullName);
replacement.Add(new AlterOperation_CreateConstraint
{
NewObject = fk
});
}
return;
}
base.TransformToImplementedOps(caps, opts, replacement, plan, targetDb);
}
public override void AddLogicalDependencies(AlterProcessorCaps caps, DbDiffOptions opts, List <AlterOperation> before, List <AlterOperation> after, AlterPlan plan, IDatabaseSource targetDb)
{
base.AddLogicalDependencies(caps, opts, before, after, plan, targetDb);
var pk = OldObject as IPrimaryKey;
if (pk != null)
{
ParentTable.LoadStructure(TableStructureMembers.ReferencedFrom, targetDb);
foreach (var col in pk.Columns)
{
foreach (ForeignKey fk in ParentTable.GetReferencedFrom())
{
bool fkdeleted = false;
for (int i = 0; i < fk.PrimaryKeyColumns.Count; i++)
{
if (fk.PrimaryKeyColumns[i].ColumnName == col.ColumnName)
{
fkdeleted = true;
break;
}
}
if (fkdeleted)
{
opts.AlterLogger.Warning(Texts.Get("s_dropped_reference$table$fk", "table", fk.Table.FullName, "fk", fk.Name));
before.Add(new AlterOperation_DropConstraint {
ParentTable = ParentTable, OldObject = fk
});
}
}
}
}
}
public override void TransformToImplementedOps(AlterProcessorCaps caps, DbDiffOptions opts, List <AlterOperation> replacement, AlterPlan plan, IDatabaseSource targetDb)
{
if (!caps[((ISpecificObjectStructure)OldObject).ObjectType].Change)
{
plan.RecreateObject(OldObject, NewObject);
replacement.Clear();
}
}
public override void TransformToImplementedOps(AlterProcessorCaps caps, DbDiffOptions opts, List <AlterOperation> replacement, AlterPlan plan, IDatabaseSource targetDb)
{
base.TransformToImplementedOps(caps, opts, replacement, plan, targetDb);
if (DbName == null)
{
DbName = targetDb.DatabaseName;
}
}
public override void TransformToImplementedOps(AlterProcessorCaps caps, DbDiffOptions opts, List <AlterOperation> replacement, AlterPlan plan, IDatabaseSource targetDb)
{
var c = GetConstraintCaps(caps, OldObject);
if (!c.Drop)
{
TransformToRecreateTable(replacement, plan, targetDb);
}
}
public override void TransformToImplementedOps(AlterProcessorCaps caps, DbDiffOptions opts, List <AlterOperation> replacement, AlterPlan plan, IDatabaseSource targetDb)
{
if (!caps.ChangeColumn)
{
TransformToRecreateTable(replacement, plan, targetDb);
return;
}
if (!caps.ChangeAutoIncrement && ((IColumnStructure)OldObject).DataType.IsAutoIncrement() != ((IColumnStructure)NewObject).DataType.IsAutoIncrement())
{
TransformToRecreateTable(replacement, plan, targetDb);
return;
}
}
//public void EndFixedOrder()
//{
// m_fixedOrderCounter++;
//}
//public void BeginFixedOrder()
//{
// m_fixedOrderCounter--;
//}
public void AddLogicalDependencies(AlterProcessorCaps caps, DbDiffOptions opts, IDatabaseSource targetDb)
{
for (int index = 0; index < Operations.Count; index++)
{
var before = new List <AlterOperation>();
var after = new List <AlterOperation>();
Operations[index].AddLogicalDependencies(caps, opts, before, after, this, targetDb);
Operations.InsertRange(index, before);
index += before.Count;
Operations.InsertRange(index + 1, after);
index += after.Count;
}
}
public override void TransformToImplementedOps(AlterProcessorCaps caps, DbDiffOptions opts, List <AlterOperation> replacement, AlterPlan plan, IDatabaseSource targetDb)
{
var c = GetConstraintCaps(caps, NewObject);
if (!c.Change)
{
if (c.Create && c.Drop)
{
plan.RecreateObject(OldObject, NewObject);
replacement.Clear();
}
else
{
TransformToRecreateTable(replacement, plan, targetDb);
}
}
}
public override bool AbsorbOperation(AlterProcessorCaps caps, AlterOperation op)
{
var cop = op as AlterOperation_Create;
if (cop != null)
{
var pk = cop.NewObject as PrimaryKey;
if (pk != null && pk.Columns.Count == 1 && pk.Columns[0].ColumnName == ((IColumnStructure)NewObject).ColumnName)
{
pk = new PrimaryKey(pk);
pk.SetDummyTable(ParentTable.FullName);
AdditionalConstraints.Add(pk);
return(true);
}
}
return(base.AbsorbOperation(caps, op));
}
public override void AddLogicalDependencies(AlterProcessorCaps caps, DbDiffOptions opts, List <AlterOperation> before, List <AlterOperation> after, AlterPlan plan, IDatabaseSource targetDb)
{
ParentTable.LoadStructure(TableStructureMembers.ReferencedFrom, targetDb);
var oldcol = OldObject as ColumnStructure;
var newcol = NewObject as ColumnStructure;
List <IForeignKey> recreateFks = new List <IForeignKey>();
var changeCols = new List <Tuple <IColumnStructure, IColumnStructure> >();
foreach (ForeignKey fk in ParentTable.GetReferencedFrom())
{
for (int i = 0; i < fk.PrimaryKeyColumns.Count; i++)
{
if (fk.PrimaryKeyColumns[i].ColumnName == oldcol.ColumnName)
{
//plan.RecreateObject(fk, null);
TableStructure table = (TableStructure)fk.Table;
table.LoadStructure(TableStructureMembers.Columns, targetDb);
ColumnStructure othercol = table.Columns[fk.Columns[i].ColumnName] as ColumnStructure;
// compare types with ignoring autoincrement flag
// HACK: ignore specific attributes
var opts2 = opts.Clone();
opts2.IgnoreSpecificData = true;
DbTypeBase dt1 = othercol.DataType.Clone(), dt2 = newcol.DataType.Clone();
dt1.SetAutoincrement(false);
dt2.SetAutoincrement(false);
if (!DbDiffTool.EqualTypes(dt1, dt2, opts2))
{
after.Add(new AlterOperation_ChangeColumn
{
ParentTable = table,
OldObject = othercol,
NewObject = new ColumnStructure(othercol)
{
DataType = dt2
}
});
}
opts.AlterLogger.Warning(Texts.Get("s_changed_referenced_column$table$column", "table", fk.Table.FullName, "column", othercol.ColumnName));
}
}
}
}
public override void AddPhysicalDependencies(AlterProcessorCaps caps, DbDiffOptions opts, List <AlterOperation> before, List <AlterOperation> after, AlterPlan plan, IDatabaseSource targetDb)
{
var oldcol = OldObject as ColumnStructure;
if (caps.DepCaps.ChangeColumn_Constraint || caps.DepCaps.ChangeColumn_Index)
{
ParentTable.LoadStructure(TableStructureMembers.Constraints, targetDb);
foreach (var cnt in ParentTable.Constraints)
{
var cc = cnt as ColumnsConstraint;
if (cc == null)
{
continue;
}
if (cc.Columns.Any(c => c.ColumnName == oldcol.ColumnName))
{
if (
(cc is IIndex && caps.DepCaps.ChangeColumn_Index) ||
(!(cc is IIndex) && caps.DepCaps.ChangeColumn_Constraint))
{
plan.RecreateObject(cc, null);
}
}
}
}
if (caps.DepCaps.ChangeColumn_Reference)
{
ParentTable.LoadStructure(TableStructureMembers.ReferencedFrom, targetDb);
foreach (ForeignKey fk in ParentTable.GetReferencedFrom())
{
for (int i = 0; i < fk.PrimaryKeyColumns.Count; i++)
{
if (fk.PrimaryKeyColumns[i].ColumnName == oldcol.ColumnName)
{
plan.RecreateObject(fk, null);
}
}
}
}
}
protected static ObjectOperationCaps GetConstraintCaps(AlterProcessorCaps caps, IAbstractObjectStructure obj)
{
if (obj is IIndex)
{
return(new ObjectOperationCaps
{
Create = caps.AddIndex,
Drop = caps.DropIndex,
Rename = caps.RenameIndex,
Change = caps.ChangeIndex,
});
}
else
{
return(new ObjectOperationCaps
{
Create = caps.AddConstraint,
Drop = caps.DropConstraint,
Rename = caps.RenameConstraint,
Change = caps.ChangeConstraint,
});
}
}
public virtual void TransformToImplementedOps(AlterProcessorCaps caps, DbDiffOptions opts, List <AlterOperation> replacement, AlterPlan plan, IDatabaseSource targetDb)
{
}
public virtual void AddLogicalDependencies(AlterProcessorCaps caps, DbDiffOptions opts, List <AlterOperation> before, List <AlterOperation> after, AlterPlan plan, IDatabaseSource targetDb)
{
}
public virtual bool MustRunAbsorbTest(AlterProcessorCaps caps)
{
return(false);
}
public virtual bool AbsorbOperation(AlterProcessorCaps caps, AlterOperation op)
{
return(false);
}
public override void AddPhysicalDependencies(AlterProcessorCaps caps, DbDiffOptions opts, List <AlterOperation> before, List <AlterOperation> after, AlterPlan alterPlan, IDatabaseSource targetDb)
{
base.AddPhysicalDependencies(caps, opts, before, after, alterPlan, targetDb);
ParentTable.LoadStructure(TableStructureMembers.Columns | TableStructureMembers.PrimaryKey, targetDb);
}
public void Transform(AlterProcessorCaps caps, DbDiffOptions opts, IDatabaseSource targetDb)
{
// transform operations
for (int index = 0; index < Operations.Count;)
{
var list = new List <AlterOperation>();
list.Add(Operations[index]);
Operations[index].TransformToImplementedOps(caps, opts, list, this, targetDb);
if (list.Count == 1)
{
Operations[index] = list[0];
index++;
}
else
{
Operations.RemoveAt(index);
Operations.InsertRange(index, list);
index += list.Count;
}
}
// add physical dependencies
for (int index = 0; index < Operations.Count; index++)
{
var before = new List <AlterOperation>();
var after = new List <AlterOperation>();
Operations[index].AddPhysicalDependencies(caps, opts, before, after, this, targetDb);
Operations.InsertRange(index, before);
index += before.Count;
Operations.InsertRange(index + 1, after);
index += after.Count;
}
// join recreate table operations
for (int index = 0; index < Operations.Count; index++)
{
var rop = Operations[index] as AlterOperation_RecreateTable;
if (rop != null)
{
for (int i = index - 1; i >= 0; i--)
{
if (Operations[i].ParentTable == rop.ParentTable)
{
rop.InsertOp(Operations[i]);
Operations.RemoveAt(i);
index--;
}
}
for (int i = index + 1; i < Operations.Count;)
{
if (Operations[i].ParentTable == rop.ParentTable)
{
rop.AppendOp(Operations[i]);
Operations.RemoveAt(i);
}
else
{
i++;
}
}
}
}
// absorb operatios
for (int index = 0; index < Operations.Count; index++)
{
if (Operations[index].MustRunAbsorbTest(caps))
{
for (int i = 0; i < Operations.Count; i++)
{
if (i == index)
{
continue;
}
if (Operations[index].AbsorbOperation(caps, Operations[i]))
{
Operations.RemoveAt(i);
if (i < index)
{
index--;
}
}
}
}
}
// remove recreates which are dropped
for (int index = 0; index < RecreatedItems.Count;)
{
bool remove = false;
foreach (var op in Operations)
{
if (op.GetDropObject() == RecreatedItems[index].RecreatedObject)
{
remove = true;
}
}
if (remove)
{
RecreatedItems.RemoveAt(index);
}
else
{
index++;
}
}
// transform recreations into regular operations so that they can be sorted
foreach (var dep in RecreatedItems)
{
opts.AlterLogger.Info(Texts.Get("s_recreated_object$object", "object", dep.RecreatedObject));
}
foreach (var cls in RecreatedItem.DropClassOrder)
{
foreach (var dep in RecreatedItems)
{
if (dep.ItemClass != cls)
{
continue;
}
dep.PlanDrop(this, opts);
}
}
foreach (var cls in RecreatedItem.DropClassOrder)
{
foreach (var dep in RecreatedItems)
{
if (dep.ItemClass != cls)
{
continue;
}
dep.PlanCreate(this, opts);
}
}
// reorder operations
// foreign key creation should be at last
// simulate stable order (List.Sort is not stable!!)
for (int i = 0; i < Operations.Count; i++)
{
Operations[i].m_tmpOrder = i;
}
Operations.Sort(OrderGroupCompare);
foreach (var op in Operations)
{
if (op.DenyTransaction())
{
DenyTransaction = true;
}
}
}
public override bool MustRunAbsorbTest(AlterProcessorCaps caps)
{
return(caps.ForceAbsorbPrimaryKey);
}
