private void LookForUnusedColumns(IReadOnlyList <CompareLog> firstStageLogs, CompareLog log)
{
var logger = new CompareLogger(CompareType.Column, null, _logs, _ignoreList, () => _hasErrors = true);
var tableDict = _databaseModel.Tables.ToDictionary(x => x.FormSchemaTable(_databaseModel.DefaultSchema), _caseComparer);
//because of table splitting and TPH we need to groups properties by table name to correctly say what columns are missed
var entityColsGrouped = firstStageLogs.SelectMany(p => p.SubLogs)
.Where(x => x.State == CompareState.Ok && x.Type == CompareType.Entity)
.GroupBy(x => x.Expected, y => y.SubLogs
.Where(x => x.State == CompareState.Ok && x.Type == CompareType.Property)
.Select(p => p.Expected));
var entityColsByTableDict = entityColsGrouped.ToDictionary(x => x.Key, y => y.SelectMany(x => x.ToList()), _caseComparer);
foreach (var entityLog in firstStageLogs.SelectMany(p => p.SubLogs)
.Where(x => x.State == CompareState.Ok && x.Type == CompareType.Entity))
{
if (tableDict.ContainsKey(entityLog.Expected))
{
var dbColNames = tableDict[entityLog.Expected].Columns.Select(x => x.Name);
var colsNotUsed = dbColNames.Where(p => !entityColsByTableDict[entityLog.Expected].Contains(p, _caseComparer));
foreach (var colName in colsNotUsed)
{
logger.ExtraInDatabase(colName, CompareAttributes.ColumnName, entityLog.Expected);
}
}
}
}
private void CompareColumns(CompareLog log, IEntityType entityType, DatabaseTable table)
{
var columnDict = table.Columns.ToDictionary(x => x.Name, _caseComparer);
var primaryKeyDict = table.PrimaryKey?.Columns.ToDictionary(x => x.Name, _caseComparer)
?? new Dictionary <string, DatabaseColumn>();
var efPKeyConstraintName = entityType.FindPrimaryKey().Relational().Name;
bool pKeyError = false;
var pKeyLogger = new CompareLogger(CompareType.PrimaryKey, efPKeyConstraintName, log.SubLogs, _ignoreList,
() =>
{
pKeyError = true; //extra set of pKeyError
_hasErrors = true;
});
pKeyLogger.CheckDifferent(efPKeyConstraintName, table.PrimaryKey?.Name ?? NoPrimaryKey,
CompareAttributes.ConstraintName, _caseComparison);
foreach (var property in entityType.GetProperties())
{
var pRel = property.Relational();
var colLogger = new CompareLogger(CompareType.Property, property.Name, log.SubLogs, _ignoreList, () => _hasErrors = true);
if (columnDict.ContainsKey(pRel.ColumnName))
{
if (!IgnorePrimaryKeyFoundInOwnedTypes(entityType.DefiningEntityType, table, property, entityType.FindPrimaryKey()))
{
var error = ComparePropertyToColumn(colLogger, property, columnDict[pRel.ColumnName]);
//check for primary key
if (property.IsPrimaryKey() != primaryKeyDict.ContainsKey(pRel.ColumnName))
{
if (!primaryKeyDict.ContainsKey(pRel.ColumnName))
{
pKeyLogger.NotInDatabase(pRel.ColumnName, CompareAttributes.ColumnName);
error = true;
}
else
{
pKeyLogger.ExtraInDatabase(pRel.ColumnName, CompareAttributes.ColumnName,
table.PrimaryKey.Name);
}
}
if (!error)
{
//There were no errors noted, so we mark it as OK
colLogger.MarkAsOk(pRel.ColumnName);
}
}
}
else
{
colLogger.NotInDatabase(pRel.ColumnName, CompareAttributes.ColumnName);
}
}
if (!pKeyError)
{
pKeyLogger.MarkAsOk(efPKeyConstraintName);
}
}
private void LookForUnusedTables(IReadOnlyList <CompareLog> firstStageLogs, CompareLog log)
{
var logger = new CompareLogger(CompareType.Table, null, log.SubLogs, _ignoreList, () => _hasErrors = true);
var databaseTableNames = _databaseModel.Tables.Select(x => x.FormSchemaTable(_databaseModel.DefaultSchema));
var allEntityTableNames = firstStageLogs.SelectMany(p => p.SubLogs)
.Where(x => x.State == CompareState.Ok && x.Type == CompareType.Entity)
.Select(p => p.Expected).OrderBy(p => p).Distinct().ToList();
var tablesNotUsed = databaseTableNames.Where(p => !allEntityTableNames.Contains(p, _caseComparer));
foreach (var tableName in tablesNotUsed)
{
logger.ExtraInDatabase(null, CompareAttributes.NotSet, tableName);
}
}
private void LookForUnusedIndexes(IReadOnlyList <CompareLog> firstStageLogs, CompareLog log)
{
var logger = new CompareLogger(CompareType.Index, null, _logs, _ignoreList, () => _hasErrors = true);
var tableDict = _databaseModel.Tables.ToDictionary(x => x.FormSchemaTable(_databaseModel.DefaultSchema), _caseComparer);
foreach (var entityLog in firstStageLogs.SelectMany(p => p.SubLogs)
.Where(x => x.State == CompareState.Ok && x.Type == CompareType.Entity))
{
if (tableDict.ContainsKey(entityLog.Expected))
{
var indexCol = tableDict[entityLog.Expected].Indexes.Select(x => x.Name);
var allEfIndexNames = entityLog.SubLogs
.Where(x => x.State == CompareState.Ok && x.Type == CompareType.Index)
.Select(p => p.Expected).OrderBy(p => p).Distinct().ToList();
var indexesNotUsed = indexCol.Where(p => !allEfIndexNames.Contains(p, _caseComparer));
foreach (var indexName in indexesNotUsed)
{
logger.ExtraInDatabase(indexName, CompareAttributes.IndexConstraintName, entityLog.Expected);
}
}
}
}
