public override void Visit(DbRefExpression e)
{
Check.NotNull(e, "e");
BeginUnary(e);
End(e);
}
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));
}
public override Expression Visit(DbRefExpression expression)
{
throw new NotImplementedException(
string.Format(
ExceptionMessages.DbExpressionTransformationNotImplemented,
typeof(DbRefExpression).Name));
}
public override Expression Visit(DbRefExpression expression)
{
throw new NotImplementedException(
string.Format(
ExceptionMessages.DbExpressionTransformationNotImplemented,
typeof(DbRefExpression).Name));
}
public override void Visit(DbRefExpression expression)
{
Write(expression);
_depth++;
Write("Argument", expression.Argument);
Write("EntitySet", expression.EntitySet);
_depth--;
}
/// <summary>
/// Implements the visitor pattern for <see cref="T:System.Data.Common.CommandTrees.DbRefExpression"/>.
/// </summary>
/// <param name="expression">The <see cref="T:System.Data.Common.CommandTrees.DbRefExpression"/> that is visited.</param>
public override void Visit(DbRefExpression expression)
{
if (expression == null)
{
throw new ArgumentNullException("expression");
}
expression.Argument.Accept(this);
}
/// <summary>
/// Utility method determining whether two expressions appearing within the same scope
/// are equivalent. May return false negatives, but no false positives. In other words,
///
/// x != y --> !ExpressionsCompatible(x, y)
///
/// but does not guarantee
///
/// x == y --> ExpressionsCompatible(x, y)
/// </summary>
private static bool ExpressionsCompatible(DbExpression x, DbExpression y)
{
if (x.ExpressionKind != y.ExpressionKind)
{
return(false);
}
switch (x.ExpressionKind)
{
case DbExpressionKind.Property:
{
var prop1 = (DbPropertyExpression)x;
var prop2 = (DbPropertyExpression)y;
return(prop1.Property == prop2.Property &&
ExpressionsCompatible(prop1.Instance, prop2.Instance));
}
case DbExpressionKind.VariableReference:
return(((DbVariableReferenceExpression)x).VariableName ==
((DbVariableReferenceExpression)y).VariableName);
case DbExpressionKind.NewInstance:
{
var newX = (DbNewInstanceExpression)x;
var newY = (DbNewInstanceExpression)y;
if (!newX.ResultType.EdmType.EdmEquals(newY.ResultType.EdmType))
{
return(false);
}
for (int i = 0; i < newX.Arguments.Count; i++)
{
if (!ExpressionsCompatible(newX.Arguments[i], newY.Arguments[i]))
{
return(false);
}
}
return(true);
}
case DbExpressionKind.Ref:
{
DbRefExpression refX = (DbRefExpression)x;
DbRefExpression refY = (DbRefExpression)y;
return(refX.EntitySet.EdmEquals(refY.EntitySet) &&
ExpressionsCompatible(refX.Argument, refY.Argument));
}
default:
// here come the false negatives...
return(false);
}
}
public override void Visit(DbRefExpression e)
{
//
VisitExprKind(e.ExpressionKind);
_key.Append("(ESET(");
_key.Append(e.EntitySet.EntityContainer.Name);
_key.Append('.');
_key.Append(e.EntitySet.Name);
_key.Append(")T(");
_key.Append(TypeHelpers.GetEdmType <RefType>(e.ResultType).ElementType.FullName);
_key.Append(")(");
e.Argument.Accept(this);
_key.Append(')');
}
public override void Visit(DbRefExpression e)
{
Check.NotNull <DbRefExpression>(e, nameof(e));
this.VisitExprKind(e.ExpressionKind);
this._key.Append("(ESET(");
this._key.Append(e.EntitySet.EntityContainer.Name);
this._key.Append('.');
this._key.Append(e.EntitySet.Name);
this._key.Append(")T(");
this._key.Append(TypeHelpers.GetEdmType <RefType>(e.ResultType).ElementType.FullName);
this._key.Append(")(");
e.Argument.Accept((DbExpressionVisitor)this);
this._key.Append(')');
}
private static bool ExpressionsCompatible(DbExpression x, DbExpression y)
{
if (x.ExpressionKind != y.ExpressionKind)
{
return(false);
}
switch (x.ExpressionKind)
{
case DbExpressionKind.NewInstance:
DbNewInstanceExpression instanceExpression1 = (DbNewInstanceExpression)x;
DbNewInstanceExpression instanceExpression2 = (DbNewInstanceExpression)y;
if (!instanceExpression1.ResultType.EdmType.EdmEquals((MetadataItem)instanceExpression2.ResultType.EdmType))
{
return(false);
}
for (int index = 0; index < instanceExpression1.Arguments.Count; ++index)
{
if (!DiscriminatorMap.ExpressionsCompatible(instanceExpression1.Arguments[index], instanceExpression2.Arguments[index]))
{
return(false);
}
}
return(true);
case DbExpressionKind.Property:
DbPropertyExpression propertyExpression1 = (DbPropertyExpression)x;
DbPropertyExpression propertyExpression2 = (DbPropertyExpression)y;
if (propertyExpression1.Property == propertyExpression2.Property)
{
return(DiscriminatorMap.ExpressionsCompatible(propertyExpression1.Instance, propertyExpression2.Instance));
}
return(false);
case DbExpressionKind.Ref:
DbRefExpression dbRefExpression1 = (DbRefExpression)x;
DbRefExpression dbRefExpression2 = (DbRefExpression)y;
if (dbRefExpression1.EntitySet.EdmEquals((MetadataItem)dbRefExpression2.EntitySet))
{
return(DiscriminatorMap.ExpressionsCompatible(dbRefExpression1.Argument, dbRefExpression2.Argument));
}
return(false);
case DbExpressionKind.VariableReference:
return(((DbVariableReferenceExpression)x).VariableName == ((DbVariableReferenceExpression)y).VariableName);
default:
return(false);
}
}
private static DbRelatedEntityRef RelatedEntityRefFromAssociationSetEnd(EntityType constructedEntityType, DbNewInstanceExpression entityConstructor, AssociationSetEnd principalSetEnd, ReferentialConstraint fkConstraint)
{
EntityType 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.
//
DbRefExpression principalRef = principalSetEnd.EntitySet.CreateRef(principalEntityType, principalKeyValues);
DbRelatedEntityRef result = DbExpressionBuilder.CreateRelatedEntityRef(fkConstraint.ToRole, fkConstraint.FromRole, principalRef);
return(result);
}
public override TreeNode Visit(DbRefExpression e)
{
Check.NotNull <DbRefExpression>(e, nameof(e));
TreeNode treeNode1 = new TreeNode("Ref", new TreeNode[0]);
treeNode1.Text.Append("<");
ExpressionPrinter.PrinterVisitor.AppendFullName(treeNode1.Text, (EdmType)TypeHelpers.GetEdmType <RefType>(e.ResultType).ElementType);
treeNode1.Text.Append(">");
TreeNode treeNode2 = new TreeNode("EntitySet : ", new TreeNode[0]);
treeNode2.Text.Append(e.EntitySet.EntityContainer.Name);
treeNode2.Text.Append(".");
treeNode2.Text.Append(e.EntitySet.Name);
treeNode1.Children.Add(treeNode2);
treeNode1.Children.Add(this.Visit("Keys", e.Argument));
return(treeNode1);
}
public override TreeNode Visit(DbRefExpression e)
{
TreeNode retNode = new TreeNode("Ref");
retNode.Text.Append("<");
AppendFullName(retNode.Text, TypeHelpers.GetEdmType <RefType>(e.ResultType).ElementType);
retNode.Text.Append(">");
TreeNode setNode = new TreeNode("EntitySet : ");
setNode.Text.Append(e.EntitySet.EntityContainer.Name);
setNode.Text.Append(".");
setNode.Text.Append(e.EntitySet.Name);
retNode.Children.Add(setNode);
retNode.Children.Add(this.Visit("Keys", e.Argument));
return(retNode);
}
/// <summary> /// Visitor pattern method for DbRefExpression. /// </summary> /// <param name="expression"> The DbRefExpression that is being visited. </param> public abstract void Visit(DbRefExpression expression);
public override TReturn Visit(DbRefExpression expression)
{
throw ConstructNotSupportedException(expression);
}
public override void Visit(DbRefExpression e)
{
Check.NotNull(e, "e");
VisitExprKind(e.ExpressionKind);
_key.Append("(ESET(");
_key.Append(e.EntitySet.EntityContainer.Name);
_key.Append('.');
_key.Append(e.EntitySet.Name);
_key.Append(")T(");
_key.Append(TypeHelpers.GetEdmType<RefType>(e.ResultType).ElementType.FullName);
_key.Append(")(");
e.Argument.Accept(this);
_key.Append(')');
}
public override TReturn Visit(DbRefExpression expression)
{
Check.NotNull <DbRefExpression>(expression, nameof(expression));
throw this.ConstructNotSupportedException((DbExpression)expression);
}
public override void Visit(DbRefExpression expression)
{
throw new NotSupportedException("Visit(\"RefExpression\") is not supported.");
}
public override void Visit(DbRefExpression expression)
{
throw new NotSupportedException("Visit(\"DbRefExpression\") is not supported.");
}
public override DbExpression Visit(DbRefExpression expression)
{
System.Diagnostics.Debug.Print("Visit(DbRefExpression): {0}", expression);
return(base.Visit(expression));
}
/// <summary>
/// <see cref="VisitUnaryExpression" />
/// </summary>
/// <param name="expression"> The DbRefExpression that is being visited. </param>
/// <returns> </returns>
public override bool Visit(DbRefExpression expression)
{
Check.NotNull(expression, "expression");
return(VisitUnaryExpression(expression));
}
public override void Visit(DbRefExpression expression)
{
VisitUnaryExpression(expression);
}
/// <summary>
/// Implements the visitor pattern for <see cref="T:System.Data.Common.CommandTrees.DbRefExpression"/>.
/// </summary>
/// <param name="expression">The <see cref="T:System.Data.Common.CommandTrees.DbRefExpression"/> that is visited.</param>
public override void Visit(DbRefExpression expression)
{
if (expression == null)
{
throw new ArgumentNullException("expression");
}
expression.Argument.Accept(this);
}
public override void Visit(DbRefExpression expression)
{
this.VisitUnaryExpression((DbUnaryExpression)expression);
}
public override void Visit(DbRefExpression expression) { }
public override void Visit(DbRefExpression e)
{
Check.NotNull(e, "e");
BeginUnary(e);
End(e);
}
public override void Visit(DbRefExpression expression)
{
Contract.Requires(expression != null);
}
public override bool Visit(DbRefExpression expression)
{
Check.NotNull <DbRefExpression>(expression, nameof(expression));
return(this.VisitUnaryExpression((DbUnaryExpression)expression));
}
public override DbExpression Visit(DbRefExpression expression)
{
System.Diagnostics.Debug.Print("Visit(DbRefExpression): {0}", expression);
return base.Visit(expression);
}
public override object Visit(DbRefExpression expression)
{
this.Visit(expression.Argument);
return(null);
}
public override ViewValidator.DbExpressionEntitySetInfo Visit(
DbRefExpression expression)
{
Check.NotNull <DbRefExpression>(expression, nameof(expression));
return((ViewValidator.DbExpressionEntitySetInfo) new ViewValidator.DbExpressionSimpleTypeEntitySetInfo(expression.EntitySet));
}
public override LegacyCommandTrees.DbExpression Visit(DbRefExpression expression)
{
throw new NotImplementedException();
}
/// <summary> /// Visitor pattern method for DbRefExpression. /// </summary> /// <param name="expression"> The DbRefExpression that is being visited. </param> public abstract void Visit(DbRefExpression expression);
/// <summary>
/// Visitor pattern method for <see cref="DbRefExpression" />.
/// </summary>
/// <param name="expression"> The DbRefExpression that is being visited. </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="expression" />
/// is null
/// </exception>
public override void Visit(DbRefExpression expression)
{
Check.NotNull(expression, "expression");
VisitUnaryExpression(expression);
}
public override void Visit(DbRefExpression e)
{
BeginUnary(e);
End(e);
}
public override void Visit(DbRefExpression e)
{
//TODO (katicad): UniqueConstraints
VisitExprKind(e.ExpressionKind);
_key.Append("(ESET(");
_key.Append(e.EntitySet.EntityContainer.Name);
_key.Append('.');
_key.Append(e.EntitySet.Name);
_key.Append(")T(");
_key.Append(TypeHelpers.GetEdmType<RefType>(e.ResultType).ElementType.FullName);
_key.Append(")(");
e.Argument.Accept(this);
_key.Append(')');
}
public override ISqlFragment Visit(DbRefExpression e)
{
throw new NotSupportedException();
}
/// <summary> /// Typed visitor pattern method for DbRefExpression. /// </summary> /// <param name="expression"> The DbRefExpression that is being visited. </param> /// <returns> An instance of TResultType. </returns> public abstract TResultType Visit(DbRefExpression expression);
public override bool Visit(DbRefExpression expression)
{
return(VisitUnaryExpression(expression));
}
public override void Visit(DbRefExpression expression)
{
VisitUnaryExpression(expression);
}
public override VfpExpression Visit(DbRefExpression expression)
{
return(new VfpRefExpression(expression.ResultType, expression.EntitySet, expression.Argument.Accept(this)));
}
public override DbExpressionEntitySetInfo Visit(DbRefExpression expression)
{
return(new DbExpressionSimpleTypeEntitySetInfo(expression.EntitySet));
}
public override DbExpressionEntitySetInfo Visit(DbRefExpression expression)
{
Check.NotNull(expression, "expression");
return(new DbExpressionSimpleTypeEntitySetInfo(expression.EntitySet));
}
