public override DB.DatabaseItem createAsNewItem(DB.DatabaseItem owner, bool save = true)
{
Table newTable = owner as Table;
Database existingDatabase = owner as Database;
if (newTable == null)
{
//look for corresponding table in existingDatabase
newTable = (Table)existingDatabase.tables.FirstOrDefault(x => x.name == this.ownerTable.name);
}
if (newTable != null && newTable.primaryKey == null ) //only create it if htere is not already one
{
var newPrimaryKey = new PrimaryKey(newTable,this._involvedColumns);
newPrimaryKey.name = name;
//newPrimaryKey.isOverridden = this.isOverridden;
newPrimaryKey.derivedFromItem = this;
if (save) newPrimaryKey.save();
return newPrimaryKey;
}
return null;
}
public void loadComparison(DB.Compare.DatabaseComparer comparer)
{
this._comparer = comparer;
this.clear();
string tableName = string.Empty;
foreach (var comparedItem in comparer.comparedItems)
{
if (comparedItem.newDatabaseItem is DB.Table)
{
tableName = comparedItem.newDatabaseItem.name;
} else if (comparedItem.existingDatabaseItem is DB.Table)
{
tableName = comparedItem.existingDatabaseItem.name;
}
var newItem = addListViewItem(comparedItem,tableName);
this.setStatusColor(newItem);
this.compareDBListView.Items.Add(newItem);
}
enableDisable();
}
public DB.DatabaseItem createAsNewItem(DB.DatabaseItem owner,bool save = true)
{
//do nothing. deleting or adding of base datatypes should happen manually in the EA GUI
return null;
}
public override DB.Transformation.DatabaseItemTransformer getCorrespondingTransformer(DB.DatabaseItem item)
{
//check if the item is our new database
if (item == this.newDatabase) return this;
//go deeper
DB.Transformation.DatabaseItemTransformer correspondingTransformer = null;
foreach (var tableTransformer in this.tableTransformers)
{
correspondingTransformer = tableTransformer.getCorrespondingTransformer(item);
if (correspondingTransformer != null) break;
}
return correspondingTransformer;
}
protected override void updateDetails(DB.DatabaseItem newDatabaseItem)
{
var newColumn = (Column)newDatabaseItem;
this._isNotNullable = newColumn.isNotNullable;
this._logicalAttribute = newColumn.logicalAttribute;
this._type = newColumn._type;
this.isOverridden = newColumn.isOverridden;
this.isRenamed = newColumn.isRenamed;
this.position = newColumn.position;
}
public override DB.Transformation.DatabaseItemTransformer getCorrespondingTransformer(DB.DatabaseItem item)
{
if (item == this.column) return this;
return null;
}
private string getLogicalName(DB.DatabaseItem databaseItem)
{
string logicalName = string.Empty;
if (databaseItem.logicalElements != null)
{
var logicalElement = databaseItem.logicalElements.FirstOrDefault();
if (logicalElement != null)
{
logicalName = logicalElement.name;
}
}
return logicalName;
}
private ListViewItem addListViewItem(DB.Compare.DatabaseItemComparison comparison,string tableName)
{
var listViewItem = new ListViewItem(comparison.comparisonStatusName);
listViewItem.SubItems.Add(comparison.itemType);
listViewItem.SubItems.Add(tableName);
listViewItem.SubItems.Add(getLogicalName(comparison));
addDatabaseItemSpecifics(listViewItem,comparison.newDatabaseItem );
addDatabaseItemSpecifics(listViewItem,comparison.existingDatabaseItem);
listViewItem.Tag = comparison;
return listViewItem;
}
public void removeTable(DB.Table table)
{
this._tables.Remove((Table)table);
}
public DB.Table getCorrespondingTable(DB.Table externalTable)
{
var _externalTable = (Table) externalTable;
//first check for exact match
var correspondingTable = this.tables.FirstOrDefault(x => x.name == externalTable.name);
if (correspondingTable == null)
{
//if no exact match found then get the one that is derived from the same logical classes
foreach (Table table in this.tables)
{
bool match = false;
//each logical class of the external table should be equal to the logical class of this table
foreach (var logicalClass in table.logicalClasses)
{
if (_externalTable.logicalClasses.Any(x => x.Equals(logicalClass)))
{
match = true;
}
else
{
match = false;
}
}
if (match)
{
//found it;
correspondingTable = table;
break;
}
}
}
return correspondingTable;
}
public override DB.DatabaseItem createAsNewItem(DB.DatabaseItem owner, bool save = true)
{
//TODO: figure out how to handle creation of new databases
return null;
}
public void addTable(DB.Table table)
{
//initialize
int nbrOfTable = this.tables.Count;
this._tables.Add(table as Table);
}
protected override void updateDetails(DB.DatabaseItem newDatabaseItem)
{
base.updateDetails(newDatabaseItem);
ForeignKey newForeignKey = (ForeignKey)newDatabaseItem;
//update the association
this._foreignTable = newForeignKey._foreignTable;
//set logical association
this.logicalAssociation = newForeignKey.logicalAssociation;
}
public override DB.DatabaseItem createAsNewItem(DB.DatabaseItem owner, bool save = true)
{
Table newTable = owner as Table;
Database existingDatabase = owner as Database;
if (newTable != null)
{
existingDatabase = newTable.databaseOwner as Database;
}
if (newTable == null)
{
//look for corresponding table in existingDatabase
newTable = (Table)existingDatabase.tables.FirstOrDefault(x => x.name == this.ownerTable.name);
}
var newForeignTable = existingDatabase.tables.FirstOrDefault(x => x.name == this.foreignTable.name);
if (newTable != null && newForeignTable != null)
{
var newForeignKey = new ForeignKey(newTable,this._involvedColumns);
newForeignKey.name = name;
newForeignKey._foreignTable = (Table)newForeignTable;
newForeignKey._logicalAssociation = _logicalAssociation;
newForeignKey.isOverridden = isOverridden;
newForeignKey.derivedFromItem = this;
if (save) newForeignKey.save();
return newForeignKey;
}
return null;
}
public DB.DatabaseItem createAsNewItem(DB.DatabaseItem owner, bool save = true)
{
throw new NotImplementedException();
}
public void update(DB.DatabaseItem newDatabaseItem, bool save = true)
{
//don't think we need it here
throw new NotImplementedException();
}
public void addColumn(DB.Column column)
{
//initialise columns
if (this.columns != null) this._columns.Add((Column) column);
}
private string getLogicalName(DB.Compare.DatabaseItemComparison comparison)
{
string logicalname = string.Empty;
if (comparison.newDatabaseItem != null)
{
logicalname = getLogicalName(comparison.newDatabaseItem);
}
if (logicalname == string.Empty && comparison.existingDatabaseItem != null)
{
logicalname = getLogicalName(comparison.existingDatabaseItem);
}
return logicalname;
}
public void addConstraint(DB.Constraint constraint)
{
if (this.constraints != null) this._constraints.Add((Constraint) constraint);
}
private void addDatabaseItemSpecifics(ListViewItem listViewItem,DB.DatabaseItem databaseItem )
{
if (databaseItem != null)
{
listViewItem.SubItems.Add(databaseItem.name);
listViewItem.SubItems.Add(databaseItem.properties);
}
else
{
listViewItem.SubItems.Add(string.Empty);
listViewItem.SubItems.Add(string.Empty);
}
}
public override DB.DatabaseItem createAsNewItem(DB.DatabaseItem owner, bool save = true)
{
Database existingDatabase = owner as Database;
var newTable = new Table((Database)existingDatabase,this.name);
newTable._logicalClasses = new List<Class>(logicalClasses);
newTable.derivedFromItem = this;
if (save) newTable.save();
return newTable;
}
private List<Column> getCorrespondingColumn(List<DB.Column> originalColumns, DB.Table newTable)
{
var newColumns = new List<Column>();
foreach (Column originalcolumn in originalColumns)
{
Column newColumn = newTable.columns.FirstOrDefault(x => x.name == originalcolumn.name) as Column;
if (newColumn != null) newColumns.Add(newColumn);
}
return newColumns;
}
public void removeColumn(DB.Column column)
{
if (this.columns != null)this._columns.Remove((Column)column);
}
public override DB.DatabaseItem createAsNewItem(DB.DatabaseItem owner, bool save = true)
{
Table newTable = owner as Table;
Database existingDatabase = owner as Database;
if (newTable == null)
{
//look for corresponding table in existingDatabase
newTable = (Table)existingDatabase.tables.FirstOrDefault(x => x.name == this.ownerTable.name);
}
if (newTable != null)
{
var newColumn = new Column(newTable,this.name);
newColumn.isNotNullable = _isNotNullable;
newColumn.type = _type;
newColumn.logicalAttribute = _logicalAttribute;
newColumn.isOverridden = isOverridden;
newColumn.isRenamed = isRenamed;
newColumn.position = _position;
newColumn.derivedFromItem = this;
if (save) newColumn.save();
return newColumn;
}
return null;
}
public void removeConstraint(DB.Constraint constraint)
{
if (this.constraints != null) this._constraints.Remove((Constraint) constraint);
}
public override DB.Transformation.DatabaseItemTransformer getCorrespondingTransformer(DB.DatabaseItem item)
{
//check if the item is our table
if (item == this.table) return this;
//check columntransformers
DB.Transformation.DatabaseItemTransformer correspondingTransformer = null;
foreach (var columnTransformer in this.columnTransformers)
{
correspondingTransformer = columnTransformer.getCorrespondingTransformer(item);
if (correspondingTransformer != null) return correspondingTransformer;
}
//check foreignKey transformers
foreach (var foreignKeyTransformer in this.foreignKeyTransformers)
{
correspondingTransformer = foreignKeyTransformer.getCorrespondingTransformer(item);
if (correspondingTransformer != null) return correspondingTransformer;
}
//check primary key transformer
if (this.primaryKeyTransformer != null) return primaryKeyTransformer.getCorrespondingTransformer(item);
//not found
return correspondingTransformer;
}
protected override void updateDetails(DB.DatabaseItem newDatabaseItem)
{
//nothing extra to do there
}
public void renameItem(DB.DatabaseItem item, string newName)
{
//get corresponding transformer
var transformer = getCorrespondingTransformer(item);
if (transformer != null) transformer.rename(newName);
}
public abstract DB.Transformation.DatabaseItemTransformer getCorrespondingTransformer(DB.DatabaseItem item);