// effects: Given the fact that rightKeyConstraint is not implied by a
// leftSide key constraint, return a useful error message -- some S
// was not implied by the C key constraints
internal static ErrorLog.Record GetErrorRecord(ViewKeyConstraint rightKeyConstraint)
{
var keySlots = new List <ViewCellSlot>(rightKeyConstraint.KeySlots);
var table = keySlots[0].SSlot.MemberPath.Extent;
var cSet = keySlots[0].CSlot.MemberPath.Extent;
var tablePrefix = new MemberPath(table);
var cSetPrefix = new MemberPath(cSet);
var tableKey = ExtentKey.GetPrimaryKeyForEntityType(tablePrefix, (EntityType)table.ElementType);
ExtentKey cSetKey = null;
if (cSet is EntitySet)
{
cSetKey = ExtentKey.GetPrimaryKeyForEntityType(cSetPrefix, (EntityType)cSet.ElementType);
}
else
{
cSetKey = ExtentKey.GetKeyForRelationType(cSetPrefix, (AssociationType)cSet.ElementType);
}
var message = Strings.ViewGen_KeyConstraint_Violation(
table.Name,
ViewCellSlot.SlotsToUserString(rightKeyConstraint.KeySlots, false /*isFromCside*/),
tableKey.ToUserString(),
cSet.Name,
ViewCellSlot.SlotsToUserString(rightKeyConstraint.KeySlots, true /*isFromCside*/),
cSetKey.ToUserString());
var debugMessage = StringUtil.FormatInvariant("PROBLEM: Not implied {0}", rightKeyConstraint);
return(new ErrorLog.Record(ViewGenErrorCode.KeyConstraintViolation, message, rightKeyConstraint.CellRelation.Cell, debugMessage));
}
// effects: Given the fact that none of the rightKeyConstraint are not implied by a
// leftSide key constraint, return a useful error message (used for
// the Update requirement
internal static ErrorLog.Record GetErrorRecord(IEnumerable <ViewKeyConstraint> rightKeyConstraints)
{
ViewKeyConstraint rightKeyConstraint = null;
var keyBuilder = new StringBuilder();
var isFirst = true;
foreach (var rightConstraint in rightKeyConstraints)
{
var keyMsg = ViewCellSlot.SlotsToUserString(rightConstraint.KeySlots, true /*isFromCside*/);
if (isFirst == false)
{
keyBuilder.Append("; ");
}
isFirst = false;
keyBuilder.Append(keyMsg);
rightKeyConstraint = rightConstraint;
}
var keySlots = new List <ViewCellSlot>(rightKeyConstraint.KeySlots);
var table = keySlots[0].SSlot.MemberPath.Extent;
var cSet = keySlots[0].CSlot.MemberPath.Extent;
var tablePrefix = new MemberPath(table);
var tableKey = ExtentKey.GetPrimaryKeyForEntityType(tablePrefix, (EntityType)table.ElementType);
string message;
if (cSet is EntitySet)
{
message = Strings.ViewGen_KeyConstraint_Update_Violation_EntitySet(
keyBuilder.ToString(), cSet.Name,
tableKey.ToUserString(), table.Name);
}
else
{
//For a 1:* or 0..1:* association, the * side has to be mapped to the
//key properties of the table. Fior this specific case, we give out a specific message
//that is specific for this case.
var associationSet = (AssociationSet)cSet;
var endMember = Helper.GetEndThatShouldBeMappedToKey(associationSet.ElementType);
if (endMember != null)
{
message = Strings.ViewGen_AssociationEndShouldBeMappedToKey(
endMember.Name,
table.Name);
}
else
{
message = Strings.ViewGen_KeyConstraint_Update_Violation_AssociationSet(
cSet.Name,
tableKey.ToUserString(), table.Name);
}
}
var debugMessage = StringUtil.FormatInvariant("PROBLEM: Not implied {0}", rightKeyConstraint);
return(new ErrorLog.Record(
ViewGenErrorCode.KeyConstraintUpdateViolation, message, rightKeyConstraint.CellRelation.Cell, debugMessage));
}
internal bool Implies(ViewKeyConstraint second)
{
if (false == ReferenceEquals(CellRelation, second.CellRelation))
{
return(false);
}
// Check if the slots in this key are a subset of slots in
// second. If it is a key in this e.g., <A.pid> then <A.pid,
// A.foo> is certainly a key as well
if (KeySlots.IsSubsetOf(second.KeySlots))
{
return(true);
}
// Now check for subsetting taking referential constraints into account
// Check that each slot in KeySlots can be found in second.KeySlots if we take
// slot equivalence into account
var secondKeySlots = new Set <ViewCellSlot>(second.KeySlots);
foreach (var firstSlot in KeySlots)
{
var found = false; // Need to find a match for firstSlot
foreach (var secondSlot in secondKeySlots)
{
if (ProjectedSlot.EqualityComparer.Equals(firstSlot.SSlot, secondSlot.SSlot))
{
// S-side is the same. Check if C-side is the same as well. If so, remove it
// from secondKeySlots
// We have to check for C-side equivalence in terms of actual equality
// and equivalence via ref constraints. The former is needed since the
// S-side key slots would typically be mapped to the same C-side slot.
// The latter is needed since the same S-side key slot could be mapped
// into two slots on the C-side that are connected via a ref constraint
var path1 = firstSlot.CSlot.MemberPath;
var path2 = secondSlot.CSlot.MemberPath;
if (MemberPath.EqualityComparer.Equals(path1, path2) ||
path1.IsEquivalentViaRefConstraint(path2))
{
secondKeySlots.Remove(secondSlot);
found = true;
break;
}
}
}
if (found == false)
{
return(false);
}
}
// The subsetting holds when referential constraints are taken into account
return(true);
}
internal static ErrorLog.Record GetErrorRecord(ViewKeyConstraint rightKeyConstraint)
{
List <ViewCellSlot> viewCellSlotList = new List <ViewCellSlot>((IEnumerable <ViewCellSlot>)rightKeyConstraint.KeySlots);
EntitySetBase extent1 = viewCellSlotList[0].SSlot.MemberPath.Extent;
EntitySetBase extent2 = viewCellSlotList[0].CSlot.MemberPath.Extent;
MemberPath prefix1 = new MemberPath(extent1);
MemberPath prefix2 = new MemberPath(extent2);
ExtentKey keyForEntityType = ExtentKey.GetPrimaryKeyForEntityType(prefix1, (EntityType)extent1.ElementType);
ExtentKey extentKey = !(extent2 is EntitySet) ? ExtentKey.GetKeyForRelationType(prefix2, (AssociationType)extent2.ElementType) : ExtentKey.GetPrimaryKeyForEntityType(prefix2, (EntityType)extent2.ElementType);
string message = Strings.ViewGen_KeyConstraint_Violation((object)extent1.Name, (object)ViewCellSlot.SlotsToUserString((IEnumerable <ViewCellSlot>)rightKeyConstraint.KeySlots, false), (object)keyForEntityType.ToUserString(), (object)extent2.Name, (object)ViewCellSlot.SlotsToUserString((IEnumerable <ViewCellSlot>)rightKeyConstraint.KeySlots, true), (object)extentKey.ToUserString());
string debugMessage = StringUtil.FormatInvariant("PROBLEM: Not implied {0}", (object)rightKeyConstraint);
return(new ErrorLog.Record(ViewGenErrorCode.KeyConstraintViolation, message, rightKeyConstraint.CellRelation.Cell, debugMessage));
}
// effects: Propagates this constraint from the basic cell relation
// to the corresponding view cell relation and returns the new constraint
// If all the key slots are not being projected, returns null
internal ViewKeyConstraint Propagate()
{
var viewCellRelation = CellRelation.ViewCellRelation;
// If all slots appear in the projection, propagate key constraint
var viewSlots = new List <ViewCellSlot>();
foreach (var keySlot in KeySlots)
{
var viewCellSlot = viewCellRelation.LookupViewSlot(keySlot);
if (viewCellSlot == null)
{
// Slot is missing -- no key constraint on the view relation
return(null);
}
viewSlots.Add(viewCellSlot);
}
// Create a key on view relation
var viewKeyConstraint = new ViewKeyConstraint(viewCellRelation, viewSlots);
return(viewKeyConstraint);
}
internal static ErrorLog.Record GetErrorRecord(
IEnumerable <ViewKeyConstraint> rightKeyConstraints)
{
ViewKeyConstraint viewKeyConstraint = (ViewKeyConstraint)null;
StringBuilder stringBuilder = new StringBuilder();
bool flag = true;
foreach (ViewKeyConstraint rightKeyConstraint in rightKeyConstraints)
{
string userString = ViewCellSlot.SlotsToUserString((IEnumerable <ViewCellSlot>)rightKeyConstraint.KeySlots, true);
if (!flag)
{
stringBuilder.Append("; ");
}
flag = false;
stringBuilder.Append(userString);
viewKeyConstraint = rightKeyConstraint;
}
List <ViewCellSlot> viewCellSlotList = new List <ViewCellSlot>((IEnumerable <ViewCellSlot>)viewKeyConstraint.KeySlots);
EntitySetBase extent1 = viewCellSlotList[0].SSlot.MemberPath.Extent;
EntitySetBase extent2 = viewCellSlotList[0].CSlot.MemberPath.Extent;
ExtentKey keyForEntityType = ExtentKey.GetPrimaryKeyForEntityType(new MemberPath(extent1), (EntityType)extent1.ElementType);
string message;
if (extent2 is EntitySet)
{
message = Strings.ViewGen_KeyConstraint_Update_Violation_EntitySet((object)stringBuilder.ToString(), (object)extent2.Name, (object)keyForEntityType.ToUserString(), (object)extent1.Name);
}
else
{
AssociationEndMember shouldBeMappedToKey = Helper.GetEndThatShouldBeMappedToKey(((AssociationSet)extent2).ElementType);
message = shouldBeMappedToKey == null?Strings.ViewGen_KeyConstraint_Update_Violation_AssociationSet((object)extent2.Name, (object)keyForEntityType.ToUserString(), (object)extent1.Name) : Strings.ViewGen_AssociationEndShouldBeMappedToKey((object)shouldBeMappedToKey.Name, (object)extent1.Name);
}
string debugMessage = StringUtil.FormatInvariant("PROBLEM: Not implied {0}", (object)viewKeyConstraint);
return(new ErrorLog.Record(ViewGenErrorCode.KeyConstraintUpdateViolation, message, viewKeyConstraint.CellRelation.Cell, debugMessage));
}
internal bool Implies(ViewKeyConstraint second)
{
if (!object.ReferenceEquals((object)this.CellRelation, (object)second.CellRelation))
{
return(false);
}
if (this.KeySlots.IsSubsetOf(second.KeySlots))
{
return(true);
}
Set <ViewCellSlot> set = new Set <ViewCellSlot>(second.KeySlots);
foreach (ViewCellSlot keySlot in this.KeySlots)
{
bool flag = false;
foreach (ViewCellSlot element in set)
{
if (ProjectedSlot.EqualityComparer.Equals((ProjectedSlot)keySlot.SSlot, (ProjectedSlot)element.SSlot))
{
MemberPath memberPath1 = keySlot.CSlot.MemberPath;
MemberPath memberPath2 = element.CSlot.MemberPath;
if (MemberPath.EqualityComparer.Equals(memberPath1, memberPath2) || memberPath1.IsEquivalentViaRefConstraint(memberPath2))
{
set.Remove(element);
flag = true;
break;
}
}
}
if (!flag)
{
return(false);
}
}
return(true);
}
