// 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); }