// effects: Ensures that there is a relationship mapped into the C-space for some cell in m_cellGroup. Else
// adds an error to errorLog
private void GuaranteeMappedRelationshipForForeignKey(
QueryRewriter childRewriter, QueryRewriter parentRewriter,
IEnumerable <Cell> cells,
ErrorLog errorLog, ConfigViewGenerator config)
{
var childContext = childRewriter.ViewgenContext;
var parentContext = parentRewriter.ViewgenContext;
// Find a cell where this foreign key is mapped as a relationship
var prefix = new MemberPath(ChildTable);
var primaryKey = ExtentKey.GetPrimaryKeyForEntityType(prefix, ChildTable.ElementType);
var primaryKeyFields = primaryKey.KeyFields;
var foundCell = false;
var foundValidParentColumnsForForeignKey = false; //we need to find only one, don't error on any one check being false
List <ErrorLog.Record> errorListForInvalidParentColumnsForForeignKey = null;
foreach (var cell in cells)
{
if (cell.SQuery.Extent.Equals(ChildTable) == false)
{
continue;
}
// The childtable is mapped to a relationship in the C-space in cell
// Check that all the columns of the foreign key and the primary key in the child table are mapped to some
// property in the C-space
var parentEnd = GetRelationEndForColumns(cell, ChildColumns);
if (parentEnd != null &&
CheckParentColumnsForForeignKey(cell, cells, parentEnd, ref errorListForInvalidParentColumnsForForeignKey) == false)
{
// Not an error unless we find no valid case
continue;
}
else
{
foundValidParentColumnsForForeignKey = true;
}
var childEnd = GetRelationEndForColumns(cell, primaryKeyFields);
Debug.Assert(
childEnd == null || parentEnd != childEnd,
"Ends are same => PKey and child columns are same - code should gone to other method");
// Note: If both of them are not-null, they are mapped to the
// same association set -- since we checked that particular cell
if (childEnd != null &&
parentEnd != null &&
FindEntitySetForColumnsMappedToEntityKeys(cells, primaryKeyFields).Count > 0)
{
foundCell = true;
CheckConstraintWhenParentChildMapped(cell, errorLog, parentEnd, config);
break; // Done processing for the foreign key - either it was mapped correctly or it was not
}
else if (parentEnd != null)
{
// At this point, we know cell corresponds to an association set
var assocSet = (AssociationSet)cell.CQuery.Extent;
foundCell = CheckConstraintWhenOnlyParentMapped(assocSet, parentEnd, childRewriter, parentRewriter);
if (foundCell)
{
break;
}
}
}
//CheckParentColumnsForForeignKey has returned no matches, Error.
if (!foundValidParentColumnsForForeignKey)
{
Debug.Assert(
errorListForInvalidParentColumnsForForeignKey != null && errorListForInvalidParentColumnsForForeignKey.Count > 0);
foreach (var errorRecord in errorListForInvalidParentColumnsForForeignKey)
{
errorLog.AddEntry(errorRecord);
}
return;
}
if (foundCell == false)
{
// No cell found -- Declare error
var message = Strings.ViewGen_Foreign_Key_Missing_Relationship_Mapping(ToUserString());
IEnumerable <LeftCellWrapper> parentWrappers = GetWrappersFromContext(parentContext, ParentTable);
IEnumerable <LeftCellWrapper> childWrappers = GetWrappersFromContext(childContext, ChildTable);
var bothExtentWrappers =
new Set <LeftCellWrapper>(parentWrappers);
bothExtentWrappers.AddRange(childWrappers);
var record = new ErrorLog.Record(
ViewGenErrorCode.ForeignKeyMissingRelationshipMapping, message, bothExtentWrappers, String.Empty);
errorLog.AddEntry(record);
}
}
// requires: all columns in constraint.ParentColumns and
// constraint.ChildColumns must have been mapped in some cell in m_cellGroup
// effects: Given the foreign key constraint, checks if the
// constraint.ChildColumns are mapped to the constraint.ParentColumns
// in m_cellGroup in the right oder. If not, adds an error to m_errorLog and returns
// false. Else returns true
private bool CheckForeignKeyColumnOrder(Set <Cell> cells, ErrorLog errorLog)
{
// Go through every cell and find the cells that are relevant to
// parent and those that are relevant to child
// Then for each cell pair (parent, child) make sure that the
// projected foreign keys columns in C-space are aligned
var parentCells = new List <Cell>();
var childCells = new List <Cell>();
foreach (var cell in cells)
{
if (cell.SQuery.Extent.Equals(ChildTable))
{
childCells.Add(cell);
}
if (cell.SQuery.Extent.Equals(ParentTable))
{
parentCells.Add(cell);
}
}
// Make sure that all child cells and parent cells align on
// the columns, i.e., for each DISTINCT pair C and P, get the columns
// on the S-side. Then get the corresponding fields on the
// C-side. The fields on the C-side should match
var foundParentCell = false;
var foundChildCell = false;
foreach (var childCell in childCells)
{
var allChildSlotNums = GetSlotNumsForColumns(childCell, ChildColumns);
if (allChildSlotNums.Count == 0)
{
// slots in present in S-side, ignore
continue;
}
List <MemberPath> childPaths = null;
List <MemberPath> parentPaths = null;
Cell errorParentCell = null;
foreach (var childSlotNums in allChildSlotNums)
{
foundChildCell = true;
// Get the fields on the C-side
childPaths = new List <MemberPath>(childSlotNums.Count);
foreach (var childSlotNum in childSlotNums)
{
// Initial slots only have JoinTreeSlots
var childSlot = (MemberProjectedSlot)childCell.CQuery.ProjectedSlotAt(childSlotNum);
Debug.Assert(childSlot != null);
childPaths.Add(childSlot.MemberPath);
}
foreach (var parentCell in parentCells)
{
var allParentSlotNums = GetSlotNumsForColumns(parentCell, ParentColumns);
if (allParentSlotNums.Count == 0)
{
// * Parent and child cell are the same - we do not
// need to check since we want to check the foreign
// key constraint mapping across cells
// * Some slots not in present in S-side, ignore
continue;
}
foreach (var parentSlotNums in allParentSlotNums)
{
foundParentCell = true;
parentPaths = new List <MemberPath>(parentSlotNums.Count);
foreach (var parentSlotNum in parentSlotNums)
{
var parentSlot = (MemberProjectedSlot)parentCell.CQuery.ProjectedSlotAt(parentSlotNum);
Debug.Assert(parentSlot != null);
parentPaths.Add(parentSlot.MemberPath);
}
// Make sure that the last member of each of these is the same
// or the paths are essentially equivalent via referential constraints
// We need to check that the last member is essentially the same because it could
// be a regular scenario where aid is mapped to PersonAddress and Address - there
// is no ref constraint. So when projected into C-Space, we will get Address.aid
// and PersonAddress.Address.aid
if (childPaths.Count
== parentPaths.Count)
{
var notAllPathsMatched = false;
for (var i = 0; i < childPaths.Count && !notAllPathsMatched; i++)
{
var parentPath = parentPaths[i];
var childPath = childPaths[i];
if (!parentPath.LeafEdmMember.Equals(childPath.LeafEdmMember)) //Child path did not match
{
if (parentPath.IsEquivalentViaRefConstraint(childPath))
{
//Specifying the referential constraint once in the C space should be enough.
//This is the only way possible today.
//We might be able to derive more knowledge by using boolean logic
return(true);
}
else
{
notAllPathsMatched = true;
}
}
}
if (!notAllPathsMatched)
{
return(true); //all childPaths matched parentPaths
}
else
{
//If not this one, some other Parent Cell may match.
errorParentCell = parentCell;
}
}
}
} //foreach parentCell
}
//If execution is at this point, no parent cell's end has matched (otherwise it would have returned true)
Debug.Assert(childPaths != null, "child paths should be set");
Debug.Assert(parentPaths != null, "parent paths should be set");
Debug.Assert(errorParentCell != null, "errorParentCell should be set");
var message = Strings.ViewGen_Foreign_Key_ColumnOrder_Incorrect(
ToUserString(),
MemberPath.PropertiesToUserString(ChildColumns, false),
ChildTable.Name,
MemberPath.PropertiesToUserString(childPaths, false),
childCell.CQuery.Extent.Name,
MemberPath.PropertiesToUserString(ParentColumns, false),
ParentTable.Name,
MemberPath.PropertiesToUserString(parentPaths, false),
errorParentCell.CQuery.Extent.Name);
var record = new ErrorLog.Record(
ViewGenErrorCode.ForeignKeyColumnOrderIncorrect, message, new[] { errorParentCell, childCell }, String.Empty);
errorLog.AddEntry(record);
return(false);
}
Debug.Assert(foundParentCell, "Some cell that mapped the parent's key must be present!");
Debug.Assert(
foundChildCell == true, "Some cell that mapped the child's foreign key must be present according to the requires clause!");
return(true);
}
// effects: Checks that this foreign key constraints for all the
// tables are being ensured on the C-side as well. If not, adds
// errors to the errorLog
internal void CheckConstraint(
Set <Cell> cells, QueryRewriter childRewriter, QueryRewriter parentRewriter,
ErrorLog errorLog, ConfigViewGenerator config)
{
if (IsConstraintRelevantForCells(cells) == false)
{
// if the constraint does not deal with any cell in this group, ignore it
return;
}
if (config.IsNormalTracing)
{
Trace.WriteLine(String.Empty);
Trace.WriteLine(String.Empty);
Trace.Write("Checking: ");
Trace.WriteLine(this);
}
if (childRewriter == null &&
parentRewriter == null)
{
// Neither table is mapped - so we are fine
return;
}
// If the child table has not been mapped, we used to say that we
// are fine. However, if we have SPerson(pid) and SAddress(aid,
// pid), where pid is an FK into SPerson, we are in trouble if
// SAddress is not mapped - SPerson could get deleted. So we
// check for it as well
// if the parent table is not mapped, we also have a problem
if (childRewriter == null)
{
var message = Strings.ViewGen_Foreign_Key_Missing_Table_Mapping(
ToUserString(), ChildTable.Name);
// Get the cells from the parent table
var record = new ErrorLog.Record(
ViewGenErrorCode.ForeignKeyMissingTableMapping, message, parentRewriter.UsedCells, String.Empty);
errorLog.AddEntry(record);
return;
}
if (parentRewriter == null)
{
var message = Strings.ViewGen_Foreign_Key_Missing_Table_Mapping(
ToUserString(), ParentTable.Name);
// Get the cells from the child table
var record = new ErrorLog.Record(
ViewGenErrorCode.ForeignKeyMissingTableMapping, message, childRewriter.UsedCells, String.Empty);
errorLog.AddEntry(record);
return;
}
// Note: we do not check if the parent columns correspond to the
// table's keys - metadata checks for that
//First check if the FK is covered by Foreign Key Association
//If we find this, we don't need to check for independent associations. If user maps the Fk to both FK and independent associations,
//the regular round tripping validation will catch the error.
if (CheckIfConstraintMappedToForeignKeyAssociation(childRewriter, cells))
{
return;
}
// Check if the foreign key in the child table corresponds to the primary key, i.e., if
// the foreign key (e.g., pid, pid2) is a superset of the actual key members (e.g., pid), it means
// that the foreign key is also the primary key for this table -- so we can propagate the queries up to C-Space
// rather than doing the cell check
var initialErrorLogSize = errorLog.Count;
if (IsForeignKeySuperSetOfPrimaryKeyInChildTable())
{
GuaranteeForeignKeyConstraintInCSpace(childRewriter, parentRewriter, errorLog);
}
else
{
GuaranteeMappedRelationshipForForeignKey(childRewriter, parentRewriter, cells, errorLog, config);
}
if (initialErrorLogSize == errorLog.Count)
{
// Check if the order of columns in foreign key corresponds to the
// mappings in m_cellGroup, e.g., if <pid1, pid2> in SAddress is
// a foreign key into <pid1, pid2> of the SPerson table, make
// sure that this order is preserved through the mappings in m_cellGroup
CheckForeignKeyColumnOrder(cells, errorLog);
}
}
// effects: Given a container, ensures that all entity/association
// sets in container on the C-side have been mapped
private static ErrorLog EnsureAllCSpaceContainerSetsAreMapped(
IEnumerable <Cell> cells,
EntityContainerMapping containerMapping)
{
var mappedExtents = new Set <EntitySetBase>();
EntityContainer container = null;
// Determine the container and name of the file while determining
// the set of mapped extents in the cells
foreach (var cell in cells)
{
mappedExtents.Add(cell.CQuery.Extent);
// All cells are from the same container
container = cell.CQuery.Extent.EntityContainer;
}
Debug.Assert(container != null);
var missingExtents = new List <EntitySetBase>();
// Go through all the extents in the container and determine
// extents that are missing
foreach (var extent in container.BaseEntitySets)
{
if (mappedExtents.Contains(extent) == false &&
!(containerMapping.HasQueryViewForSetMap(extent.Name)))
{
var associationSet = extent as AssociationSet;
if (associationSet == null ||
!associationSet.ElementType.IsForeignKey)
{
missingExtents.Add(extent);
}
}
}
var errorLog = new ErrorLog();
// If any extent is not mapped, add an error
if (missingExtents.Count > 0)
{
var extentBuilder = new StringBuilder();
var isFirst = true;
foreach (var extent in missingExtents)
{
if (isFirst == false)
{
extentBuilder.Append(", ");
}
isFirst = false;
extentBuilder.Append(extent.Name);
}
var message = Strings.ViewGen_Missing_Set_Mapping(extentBuilder);
// Find the cell with smallest line number - so that we can
// point to the beginning of the file
var lowestLineNum = -1;
Cell smallestCell = null;
foreach (var cell in cells)
{
if (lowestLineNum == -1 ||
cell.CellLabel.StartLineNumber < lowestLineNum)
{
smallestCell = cell;
lowestLineNum = cell.CellLabel.StartLineNumber;
}
}
Debug.Assert(smallestCell != null && lowestLineNum >= 0);
var edmSchemaError = new EdmSchemaError(
message, (int)ViewGenErrorCode.MissingExtentMapping,
EdmSchemaErrorSeverity.Error, containerMapping.SourceLocation, containerMapping.StartLineNumber,
containerMapping.StartLinePosition, null);
var record = new ErrorLog.Record(edmSchemaError);
errorLog.AddEntry(record);
}
return(errorLog);
}
private bool CheckForeignKeyColumnOrder(Set <Cell> cells, ErrorLog errorLog)
{
List <Cell> cellList1 = new List <Cell>();
List <Cell> cellList2 = new List <Cell>();
foreach (Cell cell in cells)
{
if (cell.SQuery.Extent.Equals((object)this.ChildTable))
{
cellList2.Add(cell);
}
if (cell.SQuery.Extent.Equals((object)this.ParentTable))
{
cellList1.Add(cell);
}
}
foreach (Cell cell1 in cellList2)
{
List <List <int> > slotNumsForColumns1 = ForeignConstraint.GetSlotNumsForColumns(cell1, this.ChildColumns);
if (slotNumsForColumns1.Count != 0)
{
List <MemberPath> memberPathList1 = (List <MemberPath>)null;
List <MemberPath> memberPathList2 = (List <MemberPath>)null;
Cell cell2 = (Cell)null;
foreach (List <int> intList1 in slotNumsForColumns1)
{
memberPathList1 = new List <MemberPath>(intList1.Count);
foreach (int slotNum in intList1)
{
MemberProjectedSlot memberProjectedSlot = (MemberProjectedSlot)cell1.CQuery.ProjectedSlotAt(slotNum);
memberPathList1.Add(memberProjectedSlot.MemberPath);
}
foreach (Cell cell3 in cellList1)
{
List <List <int> > slotNumsForColumns2 = ForeignConstraint.GetSlotNumsForColumns(cell3, this.ParentColumns);
if (slotNumsForColumns2.Count != 0)
{
foreach (List <int> intList2 in slotNumsForColumns2)
{
memberPathList2 = new List <MemberPath>(intList2.Count);
foreach (int slotNum in intList2)
{
MemberProjectedSlot memberProjectedSlot = (MemberProjectedSlot)cell3.CQuery.ProjectedSlotAt(slotNum);
memberPathList2.Add(memberProjectedSlot.MemberPath);
}
if (memberPathList1.Count == memberPathList2.Count)
{
bool flag = false;
for (int index = 0; index < memberPathList1.Count && !flag; ++index)
{
MemberPath memberPath = memberPathList2[index];
MemberPath path1 = memberPathList1[index];
if (!memberPath.LeafEdmMember.Equals((object)path1.LeafEdmMember))
{
if (memberPath.IsEquivalentViaRefConstraint(path1))
{
return(true);
}
flag = true;
}
}
if (!flag)
{
return(true);
}
cell2 = cell3;
}
}
}
}
}
ErrorLog.Record record = new ErrorLog.Record(ViewGenErrorCode.ForeignKeyColumnOrderIncorrect, Strings.ViewGen_Foreign_Key_ColumnOrder_Incorrect((object)this.ToUserString(), (object)MemberPath.PropertiesToUserString(this.ChildColumns, false), (object)this.ChildTable.Name, (object)MemberPath.PropertiesToUserString((IEnumerable <MemberPath>)memberPathList1, false), (object)cell1.CQuery.Extent.Name, (object)MemberPath.PropertiesToUserString(this.ParentColumns, false), (object)this.ParentTable.Name, (object)MemberPath.PropertiesToUserString((IEnumerable <MemberPath>)memberPathList2, false), (object)cell2.CQuery.Extent.Name), (IEnumerable <Cell>) new Cell[2]
{
cell2,
cell1
}, string.Empty);
errorLog.AddEntry(record);
return(false);
}
}
return(true);
}
private void GuaranteeMappedRelationshipForForeignKey(
QueryRewriter childRewriter,
QueryRewriter parentRewriter,
IEnumerable <Cell> cells,
ErrorLog errorLog,
ConfigViewGenerator config)
{
ViewgenContext viewgenContext1 = childRewriter.ViewgenContext;
ViewgenContext viewgenContext2 = parentRewriter.ViewgenContext;
IEnumerable <MemberPath> keyFields = ExtentKey.GetPrimaryKeyForEntityType(new MemberPath((EntitySetBase)this.ChildTable), this.ChildTable.ElementType).KeyFields;
bool flag1 = false;
bool flag2 = false;
List <ErrorLog.Record> errorList = (List <ErrorLog.Record>)null;
foreach (Cell cell in cells)
{
if (cell.SQuery.Extent.Equals((object)this.ChildTable))
{
AssociationEndMember relationEndForColumns = ForeignConstraint.GetRelationEndForColumns(cell, this.ChildColumns);
if (relationEndForColumns == null || this.CheckParentColumnsForForeignKey(cell, cells, relationEndForColumns, ref errorList))
{
flag2 = true;
if (ForeignConstraint.GetRelationEndForColumns(cell, keyFields) != null && relationEndForColumns != null && ForeignConstraint.FindEntitySetForColumnsMappedToEntityKeys(cells, keyFields).Count > 0)
{
flag1 = true;
this.CheckConstraintWhenParentChildMapped(cell, errorLog, relationEndForColumns, config);
break;
}
if (relationEndForColumns != null)
{
AssociationSet extent = (AssociationSet)cell.CQuery.Extent;
MetadataHelper.GetEntitySetAtEnd(extent, relationEndForColumns);
flag1 = ForeignConstraint.CheckConstraintWhenOnlyParentMapped(extent, relationEndForColumns, childRewriter, parentRewriter);
if (flag1)
{
break;
}
}
}
}
}
if (!flag2)
{
foreach (ErrorLog.Record record in errorList)
{
errorLog.AddEntry(record);
}
}
else
{
if (flag1)
{
return;
}
string message = Strings.ViewGen_Foreign_Key_Missing_Relationship_Mapping((object)this.ToUserString());
IEnumerable <LeftCellWrapper> wrappersFromContext1 = (IEnumerable <LeftCellWrapper>)ForeignConstraint.GetWrappersFromContext(viewgenContext2, (EntitySetBase)this.ParentTable);
IEnumerable <LeftCellWrapper> wrappersFromContext2 = (IEnumerable <LeftCellWrapper>)ForeignConstraint.GetWrappersFromContext(viewgenContext1, (EntitySetBase)this.ChildTable);
Set <LeftCellWrapper> set = new Set <LeftCellWrapper>(wrappersFromContext1);
set.AddRange(wrappersFromContext2);
ErrorLog.Record record = new ErrorLog.Record(ViewGenErrorCode.ForeignKeyMissingRelationshipMapping, message, (IEnumerable <LeftCellWrapper>)set, string.Empty);
errorLog.AddEntry(record);
}
}
private void EnsureConfigurationIsFullyMapped(
MemberPath currentPath,
BoolExpression currentWhereClause,
HashSet <FragmentQuery> outputUsedViews,
ErrorLog errorLog)
{
foreach (Constant domainValue in this.GetDomain(currentPath))
{
if (domainValue != Constant.Undefined)
{
BoolExpression memberCondition = this.CreateMemberCondition(currentPath, domainValue);
BoolExpression and = BoolExpression.CreateAnd(currentWhereClause, memberCondition);
Tile <FragmentQuery> rewriting;
if (!this.FindRewritingAndUsedViews((IEnumerable <MemberPath>) this._keyAttributes, and, outputUsedViews, out rewriting))
{
if (!ErrorPatternMatcher.FindMappingErrors(this._context, this._domainMap, this._errorLog))
{
StringBuilder builder = new StringBuilder();
string str = StringUtil.FormatInvariant("{0}", (object)this._extentPath);
BoolExpression condition = rewriting.Query.Condition;
condition.ExpensiveSimplify();
if (condition.RepresentsAllTypeConditions)
{
string viewGenExtent = Strings.ViewGen_Extent;
builder.AppendLine(Strings.ViewGen_Cannot_Recover_Types((object)viewGenExtent, (object)str));
}
else
{
string viewGenEntities = Strings.ViewGen_Entities;
builder.AppendLine(Strings.ViewGen_Cannot_Disambiguate_MultiConstant((object)viewGenEntities, (object)str));
}
RewritingValidator.EntityConfigurationToUserString(condition, builder);
ErrorLog.Record record = new ErrorLog.Record(ViewGenErrorCode.AmbiguousMultiConstants, builder.ToString(), (IEnumerable <LeftCellWrapper>) this._context.AllWrappersForExtent, string.Empty);
errorLog.AddEntry(record);
}
}
else
{
TypeConstant typeConstant = domainValue as TypeConstant;
if (typeConstant != null)
{
EdmType edmType = typeConstant.EdmType;
List <MemberPath> list = QueryRewriter.GetNonConditionalScalarMembers(edmType, currentPath, this._domainMap).Union <MemberPath>(QueryRewriter.GetNonConditionalComplexMembers(edmType, currentPath, this._domainMap)).ToList <MemberPath>();
IEnumerable <MemberPath> notCoveredAttributes;
if (list.Count > 0 && !this.FindRewritingAndUsedViews((IEnumerable <MemberPath>)list, and, outputUsedViews, out rewriting, out notCoveredAttributes))
{
List <MemberPath> memberPathList = new List <MemberPath>(list.Where <MemberPath>((Func <MemberPath, bool>)(a => !a.IsPartOfKey)));
this.AddUnrecoverableAttributesError(notCoveredAttributes, memberCondition, errorLog);
}
else
{
foreach (MemberPath conditionalComplexMember in QueryRewriter.GetConditionalComplexMembers(edmType, currentPath, this._domainMap))
{
this.EnsureConfigurationIsFullyMapped(conditionalComplexMember, and, outputUsedViews, errorLog);
}
foreach (MemberPath conditionalScalarMember in QueryRewriter.GetConditionalScalarMembers(edmType, currentPath, this._domainMap))
{
this.EnsureConfigurationIsFullyMapped(conditionalScalarMember, and, outputUsedViews, errorLog);
}
}
}
}
}
}
}
