internal ForeignKeyConstraint(RelationshipSet relationshipSet, ReferentialConstraint constraint)
{
var assocSet = relationshipSet as AssociationSet;
var fromEnd = constraint.FromRole as AssociationEndMember;
var toEnd = constraint.ToRole as AssociationEndMember;
// Currently only Associations are supported
if (null == assocSet || null == fromEnd
|| null == toEnd)
{
throw new NotSupportedException();
}
m_constraint = constraint;
var parent = MetadataHelper.GetEntitySetAtEnd(assocSet, fromEnd);
// relationshipSet.GetRelationshipEndExtent(constraint.FromRole);
var child = MetadataHelper.GetEntitySetAtEnd(assocSet, toEnd); // relationshipSet.GetRelationshipEndExtent(constraint.ToRole);
m_extentPair = new ExtentPair(parent, child);
m_childKeys = new List<string>();
foreach (var prop in constraint.ToProperties)
{
m_childKeys.Add(prop.Name);
}
m_parentKeys = new List<string>();
foreach (var prop in constraint.FromProperties)
{
m_parentKeys.Add(prop.Name);
}
PlanCompiler.Assert(
(RelationshipMultiplicity.ZeroOrOne == fromEnd.RelationshipMultiplicity
|| RelationshipMultiplicity.One == fromEnd.RelationshipMultiplicity),
"from-end of relationship constraint cannot have multiplicity greater than 1");
}
/// <summary>
/// Returns a <see cref="T:System.Data.Entity.Core.Metadata.Edm.RelationshipSet" /> object by using the specified name for the relationship set.
/// </summary>
/// <returns>true if there is a relationship set that matches the search criteria; otherwise, false. </returns>
/// <param name="name">The name of the relationship set that is searched for.</param>
/// <param name="ignoreCase">true to perform the case-insensitive search; otherwise, false.</param>
/// <param name="relationshipSet">
/// When this method returns, contains a <see cref="T:System.Data.Entity.Core.Metadata.Edm.RelationshipSet" /> object.
/// </param>
public bool TryGetRelationshipSetByName(string name, bool ignoreCase, out RelationshipSet relationshipSet)
{
Check.NotNull(name, "name");
EntitySetBase baseEntitySet = null;
relationshipSet = null;
if (BaseEntitySets.TryGetValue(name, ignoreCase, out baseEntitySet))
{
if (Helper.IsRelationshipSet(baseEntitySet))
{
relationshipSet = (RelationshipSet)baseEntitySet;
return(true);
}
}
return(false);
}
/// <summary>
/// Returns a <see cref="T:System.Data.Entity.Core.Metadata.Edm.RelationshipSet" /> object by using the specified name for the relationship set.
/// </summary>
/// <returns>true if there is a relationship set that matches the search criteria; otherwise, false. </returns>
/// <param name="name">The name of the relationship set that is searched for.</param>
/// <param name="ignoreCase">true to perform the case-insensitive search; otherwise, false.</param>
/// <param name="relationshipSet">
/// When this method returns, contains a <see cref="T:System.Data.Entity.Core.Metadata.Edm.RelationshipSet" /> object.
/// </param>
public bool TryGetRelationshipSetByName(
string name,
bool ignoreCase,
out RelationshipSet relationshipSet)
{
Check.NotNull <string>(name, nameof(name));
EntitySetBase entitySetBase = (EntitySetBase)null;
relationshipSet = (RelationshipSet)null;
if (!this.BaseEntitySets.TryGetValue(name, ignoreCase, out entitySetBase) || !Helper.IsRelationshipSet(entitySetBase))
{
return(false);
}
relationshipSet = (RelationshipSet)entitySetBase;
return(true);
}
/// <summary>
/// Builds up a join between the relationshipset and the entityset corresponding to its toEnd. In essence,
/// we produce
/// SELECT r, e
/// FROM RS as r, OFTYPE(ES, T) as e
/// WHERE r.ToEnd = Ref(e)
///
/// "T" is the entity type of the toEnd of the relationship.
/// </summary>
/// <param name="relSet">the relationshipset</param>
/// <param name="end">the toEnd of the relationship</param>
/// <param name="rsVar">the var representing the relationship instance ("r") in the output subquery</param>
/// <param name="esVar">the var representing the entity instance ("e") in the output subquery</param>
/// <returns>the join subquery described above</returns>
private Node BuildJoinForNavProperty(
RelationshipSet relSet, RelationshipEndMember end,
out Var rsVar, out Var esVar)
{
var entitySet = FindTargetEntitySet(relSet, end);
//
// Build out the ScanTable ops for the relationshipset and the entityset. Add the
//
var asTableNode = BuildOfTypeTable(relSet, null, out rsVar);
var esTableNode = BuildOfTypeTable(entitySet, TypeHelpers.GetElementTypeUsage(end.TypeUsage), out esVar);
//
// Build up a join between the entityset and the associationset; join on the to-end
//
var joinPredicate = m_command.BuildComparison(
OpType.EQ,
m_command.CreateNode(m_command.CreateGetEntityRefOp(end.TypeUsage), m_command.CreateNode(m_command.CreateVarRefOp(esVar))),
m_command.CreateNode(m_command.CreatePropertyOp(end), m_command.CreateNode(m_command.CreateVarRefOp(rsVar)))
);
var joinNode = m_command.CreateNode(
m_command.CreateInnerJoinOp(),
asTableNode, esTableNode, joinPredicate);
return joinNode;
}
private static EntitySetBase FindTargetEntitySet(RelationshipSet relationshipSet, RelationshipEndMember targetEnd)
{
EntitySetBase entitySet = null;
var associationSet = (AssociationSet)relationshipSet;
// find the corresponding entityset
entitySet = null;
foreach (var e in associationSet.AssociationSetEnds)
{
if (e.CorrespondingAssociationEndMember.EdmEquals(targetEnd))
{
entitySet = e.EntitySet;
break;
}
}
PlanCompiler.Assert(
entitySet != null, "Could not find entity set for relationship set " + relationshipSet + ";association end " + targetEnd);
return entitySet;
}
/// <summary>
/// Returns a <see cref="T:System.Data.Entity.Core.Metadata.Edm.RelationshipSet" /> object by using the specified name for the relationship set.
/// </summary>
/// <returns>true if there is a relationship set that matches the search criteria; otherwise, false. </returns>
/// <param name="name">The name of the relationship set that is searched for.</param>
/// <param name="ignoreCase">true to perform the case-insensitive search; otherwise, false.</param>
/// <param name="relationshipSet">
/// When this method returns, contains a <see cref="T:System.Data.Entity.Core.Metadata.Edm.RelationshipSet" /> object.
/// </param>
public bool TryGetRelationshipSetByName(string name, bool ignoreCase, out RelationshipSet relationshipSet)
{
Check.NotNull(name, "name");
EntitySetBase baseEntitySet = null;
relationshipSet = null;
if (BaseEntitySets.TryGetValue(name, ignoreCase, out baseEntitySet))
{
if (Helper.IsRelationshipSet(baseEntitySet))
{
relationshipSet = (RelationshipSet)baseEntitySet;
return true;
}
}
return false;
}
/// <summary>
/// Get the relationship set with the given name
/// </summary>
/// <param name="name">name of the relationship set to look up for</param>
/// <param name="ignoreCase">true if you want to do a case-insensitive lookup</param>
/// <param name="relationshipSet">out parameter that will have the result</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">if name argument is null</exception>
public bool TryGetRelationshipSetByName(string name, bool ignoreCase, out RelationshipSet relationshipSet)
{
Contract.Requires(name != null);
EntitySetBase baseEntitySet = null;
relationshipSet = null;
if (BaseEntitySets.TryGetValue(name, ignoreCase, out baseEntitySet))
{
if (Helper.IsRelationshipSet(baseEntitySet))
{
relationshipSet = (RelationshipSet)baseEntitySet;
return true;
}
}
return false;
}
