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 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); }
public override void Visit(DbRefExpression expression) { this.VisitUnaryExpression((DbUnaryExpression)expression); }
public override void Visit(DbRefExpression expression) { }
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 <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 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)); }