public IMetaManipulate MetaManipulate(ITransaction tx)
{
if (_metaManipulate == null)
{
_metaManipulate = CreateMetaManipulate();
_metaManipulate.Initialize(tx);
}
return(_metaManipulate);
}
public static ICollection <IMetaComparisonGroup> Compare(IMetaManipulate metaManipulate,
ICollection <IMetaItem> existing,
ICollection <IMetaItem> required)
{
var retGroups = new List <IMetaComparisonGroup>();
foreach (IMetaItem existingItem in existing)
{
bool found = false;
foreach (IMetaItem requiredItem in required)
{
if (metaManipulate.Equals(existingItem, requiredItem))
{
retGroups.Add(CreateGroupByType(metaManipulate, existingItem.ItemType, existingItem,
requiredItem));
found = true;
break;
}
}
if (!found)
{
retGroups.Add(CreateGroupByType(metaManipulate, existingItem.ItemType, existingItem, null));
}
}
foreach (IMetaItem requiredItem in required)
{
bool found = false;
foreach (IMetaItem existingItem in existing)
{
if (metaManipulate.Equals(requiredItem, existingItem))
{
found = true;
break;
}
}
if (!found)
{
retGroups.Add(CreateGroupByType(metaManipulate, requiredItem.ItemType, null, requiredItem));
}
}
return(retGroups);
}
private static IMetaComparisonGroup CreateGroupByType(IMetaManipulate metaManipulate, MetaItemType type,
IMetaItem existingItem, IMetaItem requiredItem)
{
switch (type)
{
case MetaItemType.Column:
return(new MetaComparisonColumnGroup(existingItem, requiredItem));
case MetaItemType.ForeignKey:
return(new MetaComparisonForeignKeyGroup(existingItem, requiredItem));
case MetaItemType.PrimaryKey:
return(new MetaComparisonPrimaryKeyGroup(existingItem, requiredItem));
case MetaItemType.Table:
var group = new MetaComparisonTableGroup(existingItem, requiredItem);
ProcessTableSubGroups(metaManipulate, group);
return(group);
default:
return(null);
}
}
private static void ProcessTableSubGroups(IMetaManipulate metaManipulate, MetaComparisonTableGroup tableGroup)
{
if (tableGroup.ShouldDeleteFromDb())
{
return;
}
//columns
if (tableGroup.ShouldAlterInDb())
{
var existingColumns = new List <IMetaItem>();
var requiredColumns = new List <IMetaItem>();
var comparedColumns = new List <MetaComparisonColumnGroup>();
existingColumns.AddRange(((MetaTable)tableGroup.ExistingItem).Columns.Cast <IMetaItem>());
requiredColumns.AddRange(((MetaTable)tableGroup.RequiredItem).Columns.Cast <IMetaItem>());
ICollection <IMetaComparisonGroup> compared = Compare(metaManipulate, existingColumns, requiredColumns);
foreach (IMetaComparisonGroup columnComparison in compared)
{
comparedColumns.Add((MetaComparisonColumnGroup)columnComparison);
}
tableGroup.Columns = comparedColumns;
}
//fkeys
{
var existingForeignKeys = new List <IMetaItem>();
var requiredForeignKeys = new List <IMetaItem>();
var comparedForeignKeys = new List <MetaComparisonForeignKeyGroup>();
if (tableGroup.ExistingItem != null)
{
existingForeignKeys.AddRange((((MetaTable)tableGroup.ExistingItem).ForeignKeys.Cast <IMetaItem>()));
}
requiredForeignKeys.AddRange(((MetaTable)tableGroup.RequiredItem).ForeignKeys.Cast <IMetaItem>());
ICollection <IMetaComparisonGroup> compared = Compare(metaManipulate, existingForeignKeys,
requiredForeignKeys);
foreach (IMetaComparisonGroup columnComparison in compared)
{
comparedForeignKeys.Add((MetaComparisonForeignKeyGroup)columnComparison);
}
tableGroup.ForeignKeys = comparedForeignKeys;
}
//pk
{
var existingPrimaryKey = new List <IMetaItem>();
var requiredPrimaryKey = new List <IMetaItem>();
var comparedPrimaryKey = new List <MetaComparisonPrimaryKeyGroup>();
if (tableGroup.ExistingItem != null &&
((MetaTable)tableGroup.ExistingItem).PrimaryKey != null)
{
existingPrimaryKey.Add(((MetaTable)tableGroup.ExistingItem).PrimaryKey);
}
if (tableGroup.RequiredItem != null &&
((MetaTable)tableGroup.RequiredItem).PrimaryKey != null)
{
requiredPrimaryKey.Add(((MetaTable)tableGroup.RequiredItem).PrimaryKey);
}
ICollection <IMetaComparisonGroup> compared = Compare(metaManipulate, existingPrimaryKey,
requiredPrimaryKey);
foreach (IMetaComparisonGroup columnComparison in compared)
{
comparedPrimaryKey.Add((MetaComparisonPrimaryKeyGroup)columnComparison);
}
if (comparedPrimaryKey.Count > 0)
{
tableGroup.PrimaryKey = comparedPrimaryKey[0];
}
}
}
public void PatchDataBase(ITransaction tx, ICollection <Type> entityTypes, bool dropAll)
{
try
{
foreach (Type entityType in entityTypes)
{
CacheManager.Register(entityType);
}
IMetaManipulate metaManipulate = _dbLayer.MetaManipulate(tx);
ICollection <IMetaItem> existingItems = metaManipulate.GetMetaData(tx);
ICollection <IMetaItem> requiredItems = CreateMetaItemsFromEntityTypes(entityTypes);
List <MetaQueryHolder> queryHolders = new List <MetaQueryHolder>();
if (dropAll)
{
ICollection <IMetaComparisonGroup> groupExisting = CompareUtility.Compare(metaManipulate, existingItems, new List <IMetaItem>());
ICollection <IMetaComparisonGroup> groupRequired = CompareUtility.Compare(metaManipulate, new List <IMetaItem>(), requiredItems);
List <MetaQueryHolder> queryHoldersExisting = new List <MetaQueryHolder>();
foreach (IMetaComparisonGroup comparisonGroup in groupExisting)
{
queryHoldersExisting.AddRange(_dbLayer.MetaManipulate(tx).CreateDbPathSql(comparisonGroup));
}
queryHoldersExisting.Sort();
List <MetaQueryHolder> queryHoldersRequired = new List <MetaQueryHolder>();
foreach (IMetaComparisonGroup comparisonGroup in groupRequired)
{
queryHoldersRequired.AddRange(_dbLayer.MetaManipulate(tx).CreateDbPathSql(comparisonGroup));
}
queryHoldersRequired.Sort();
queryHolders.AddRange(queryHoldersExisting);
queryHolders.AddRange(queryHoldersRequired);
}
else
{
ICollection <IMetaComparisonGroup> groups = CompareUtility.Compare(metaManipulate, existingItems, requiredItems);
foreach (IMetaComparisonGroup comparisonGroup in groups)
{
queryHolders.AddRange(_dbLayer.MetaManipulate(tx).CreateDbPathSql(comparisonGroup));
}
queryHolders.Sort();
}
foreach (MetaQueryHolder holder in queryHolders)
{
if (holder.QueryString == null)
{
continue;
}
Logger.GetLogger(_config.LoggerName).Debug(holder.QueryString);
IDbCommand cmd = tx.CreateCommand();
cmd.CommandText = holder.QueryString;
cmd.ExecuteNonQuery();
DbMgtUtility.Close(cmd);
if (_config.EnableStatistics)
{
_statistics.RegisterPatch();
}
}
}
catch (Exception e)
{
Logger.GetLogger(_config.LoggerName).Fatal(e.Message, e);
throw new MetaDataException(e.Message, e);
}
}
