internal DbRelatedEntityRef AsCqt(DbExpression row)
{
return(DbExpressionBuilder.CreateRelatedEntityRef(
m_fromEnd,
m_toEnd,
m_toEndEntitySet.CreateRef(m_toEndEntityType, m_toEndEntityKeyMemberPaths.Select(keyMember => row.Property(keyMember.CqlFieldAlias)))));
}
private static DbRelatedEntityRef RelatedEntityRefFromAssociationSetEnd(
EntityType constructedEntityType,
DbNewInstanceExpression entityConstructor,
AssociationSetEnd principalSetEnd,
ReferentialConstraint fkConstraint)
{
EntityType elementType = (EntityType)TypeHelpers.GetEdmType <RefType>(fkConstraint.FromRole.TypeUsage).ElementType;
IEnumerable <Tuple <string, DbExpression> > source = constructedEntityType.Properties.Select <EdmProperty, Tuple <EdmProperty, DbExpression> >((Func <EdmProperty, int, Tuple <EdmProperty, DbExpression> >)((p, idx) => Tuple.Create <EdmProperty, DbExpression>(p, entityConstructor.Arguments[idx]))).Join <Tuple <EdmProperty, DbExpression>, Tuple <EdmProperty, EdmProperty>, EdmProperty, Tuple <string, DbExpression> >(fkConstraint.FromProperties.Select <EdmProperty, Tuple <EdmProperty, EdmProperty> >((Func <EdmProperty, int, Tuple <EdmProperty, EdmProperty> >)((fp, idx) => Tuple.Create <EdmProperty, EdmProperty>(fp, fkConstraint.ToProperties[idx]))), (Func <Tuple <EdmProperty, DbExpression>, EdmProperty>)(pv => pv.Item1), (Func <Tuple <EdmProperty, EdmProperty>, EdmProperty>)(ft => ft.Item2), (Func <Tuple <EdmProperty, DbExpression>, Tuple <EdmProperty, EdmProperty>, Tuple <string, DbExpression> >)((pv, ft) => Tuple.Create <string, DbExpression>(ft.Item1.Name, pv.Item2)));
IList <DbExpression> dbExpressionList;
if (fkConstraint.FromProperties.Count == 1)
{
dbExpressionList = (IList <DbExpression>) new DbExpression[1]
{
source.Single <Tuple <string, DbExpression> >().Item2
};
}
else
{
Dictionary <string, DbExpression> keyValueMap = source.ToDictionary <Tuple <string, DbExpression>, string, DbExpression>((Func <Tuple <string, DbExpression>, string>)(pav => pav.Item1), (Func <Tuple <string, DbExpression>, DbExpression>)(pav => pav.Item2), (IEqualityComparer <string>)StringComparer.Ordinal);
dbExpressionList = (IList <DbExpression>)((IEnumerable <string>)elementType.KeyMemberNames).Select <string, DbExpression>((Func <string, DbExpression>)(memberName => keyValueMap[memberName])).ToList <DbExpression>();
}
DbRefExpression dbRefExpression = principalSetEnd.EntitySet.CreateRef(elementType, (IEnumerable <DbExpression>)dbExpressionList);
return(DbExpressionBuilder.CreateRelatedEntityRef(fkConstraint.ToRole, fkConstraint.FromRole, (DbExpression)dbRefExpression));
}
private static DbRelatedEntityRef RelatedEntityRefFromAssociationSetEnd(
EntityType constructedEntityType, DbNewInstanceExpression entityConstructor, AssociationSetEnd principalSetEnd,
ReferentialConstraint fkConstraint)
{
var principalEntityType = (EntityType)TypeHelpers.GetEdmType <RefType>(fkConstraint.FromRole.TypeUsage).ElementType;
IList <DbExpression> principalKeyValues = null;
// Create Entity Property/DbExpression value pairs from the entity constructor DbExpression,
// then join these with the principal/dependent property pairs from the FK constraint
// to produce principal property name/DbExpression value pairs from which to create the principal ref.
//
// Ideally the code would be as below, but anonymous types break asmmeta:
//var keyPropAndValue =
// from pv in constructedEntityType.Properties.Select((p, idx) => new { DependentProperty = p, Value = entityConstructor.Arguments[idx] })
// join ft in fkConstraint.FromProperties.Select((fp, idx) => new { PrincipalProperty = fp, DependentProperty = fkConstraint.ToProperties[idx] })
// on pv.DependentProperty equals ft.DependentProperty
// select new { PrincipalProperty = ft.PrincipalProperty.Name, Value = pv.Value };
//
var keyPropAndValue =
from pv in constructedEntityType.Properties.Select((p, idx) => Tuple.Create(p, entityConstructor.Arguments[idx]))
// new { DependentProperty = p, Value = entityConstructor.Arguments[idx] })
join ft in fkConstraint.FromProperties.Select((fp, idx) => Tuple.Create(fp, fkConstraint.ToProperties[idx]))
//new { PrincipalProperty = fp, DependentProperty = fkConstraint.ToProperties[idx] })
on pv.Item1 equals ft.Item2
//pv.DependentProperty equals ft.DependentProperty
select Tuple.Create(ft.Item1.Name, pv.Item2); // new { PrincipalProperty = ft.PrincipalProperty.Name, Value = pv.Value };
// If there is only a single property in the principal's key, then there is no ordering concern.
// Otherwise, create a dictionary of principal key property name to DbExpression value so that
// when used as the arguments to the ref expression, the dependent property values - used here
// as principal key property values - are in the correct order, which is the same order as the
// key members themselves.
//
if (fkConstraint.FromProperties.Count == 1)
{
var singleKeyNameAndValue = keyPropAndValue.Single();
Debug.Assert(singleKeyNameAndValue.Item1 == fkConstraint.FromProperties[0].Name, "Unexpected single key property name");
principalKeyValues = new[] { singleKeyNameAndValue.Item2 };
}
else
{
var keyValueMap = keyPropAndValue.ToDictionary(pav => pav.Item1, pav => pav.Item2, StringComparer.Ordinal);
principalKeyValues = principalEntityType.KeyMemberNames.Select(memberName => keyValueMap[memberName]).ToList();
}
// Create the ref to the principal entity based on the (now correctly ordered) key value expressions.
//
var principalRef = principalSetEnd.EntitySet.CreateRef(principalEntityType, principalKeyValues);
var result = DbExpressionBuilder.CreateRelatedEntityRef(fkConstraint.ToRole, fkConstraint.FromRole, principalRef);
return(result);
}
internal DbRelatedEntityRef AsCqt(DbExpression row)
{
return(DbExpressionBuilder.CreateRelatedEntityRef(this.m_fromEnd, this.m_toEnd, (DbExpression)this.m_toEndEntitySet.CreateRef(this.m_toEndEntityType, (IEnumerable <DbExpression>) this.m_toEndEntityKeyMemberPaths.Select <MemberPath, DbPropertyExpression>((Func <MemberPath, DbPropertyExpression>)(keyMember => row.Property(keyMember.CqlFieldAlias))))));
}