System.Data.Common.CommandTrees.Internal.ExpressionPrinter.PrinterVisitor.Visit(string, params System.Data.Common.CommandTrees.DbExpression[])

Here are the examples of the csharp api class System.Data.Common.CommandTrees.Internal.ExpressionPrinter.PrinterVisitor.Visit(string, params System.Data.Common.CommandTrees.DbExpression[]) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

public override TreeNode Visit(DbLikeExpression e)
            {
                return this.Visit("Like", e.Argument, e.Pattern, e.Escape);
            }

public override TreeNode Visit(DbLimitExpression e)
            {
                return this.Visit((e.WithTies ? "LimitWithTies" : "Limit"), e.Argument, e.Limit);
            }

public override TreeNode Visit(DbCaseExpression e)
            {
                TreeNode retInfo = new TreeNode("Case");
                for (int idx = 0; idx < e.When.Count; idx++)
                {
                    retInfo.Children.Add(this.Visit("When", e.When[idx]));
                    retInfo.Children.Add(this.Visit("Then", e.Then[idx]));
                }

                retInfo.Children.Add(this.Visit("Else", e.Else));

                return retInfo;
            }

private TreeNode VisitSortOrder(IList<DbSortClause> sortOrder)
            {
                TreeNode keyInfo = new TreeNode("SortOrder");
                foreach (DbSortClause clause in sortOrder)
                {
                    TreeNode key = this.Visit((clause.Ascending ? "Asc" : "Desc"), clause.Expression);
                    if (!string.IsNullOrEmpty(clause.Collation))
                    {
                        key.Text.Append(" : ");
                        key.Text.Append(clause.Collation);
                    }

                    keyInfo.Children.Add(key);
                }

                return keyInfo;
            }

private TreeNode VisitInfix(DbExpression root, DbExpression left, string name, DbExpression right)
            {
                if (_infix)
                {
                    TreeNode nullOp = new TreeNode("");
                    nullOp.Children.Add(this.VisitExpression(left));
                    nullOp.Children.Add(new TreeNode(name));
                    nullOp.Children.Add(this.VisitExpression(right));

                    return nullOp;
                }
                else
                {
                    return Visit(name, left, right);
                }
            }

public override TreeNode Visit(DbArithmeticExpression e)
            {
                if (DbExpressionKind.UnaryMinus == e.ExpressionKind)
                {
                    return this.Visit(_opMap[e.ExpressionKind], e.Arguments[0]);
                }
                else
                {
                    return this.VisitInfix(e, e.Arguments[0], _opMap[e.ExpressionKind], e.Arguments[1]);
                }
            }

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

public override TreeNode Visit(DbFilterExpression e)
            {
                TreeNode retInfo = NodeFromExpression(e);
                retInfo.Children.Add(this.VisitBinding("Input", e.Input));
                retInfo.Children.Add(this.Visit("Predicate", e.Predicate));
                return retInfo;
            }

public override TreeNode Visit(DbProjectExpression e)
            {
                TreeNode retInfo = NodeFromExpression(e);
                retInfo.Children.Add(this.VisitBinding("Input", e.Input));
                retInfo.Children.Add(this.Visit("Projection", e.Projection));
                return retInfo;
            }

public override TreeNode Visit(DbJoinExpression e)
            {
                TreeNode retInfo = NodeFromExpression(e);
                retInfo.Children.Add(this.VisitBinding("Left", e.Left));
                retInfo.Children.Add(this.VisitBinding("Right", e.Right));
                retInfo.Children.Add(this.Visit("JoinCondition", e.JoinCondition));
                
                return retInfo;
            }

public override TreeNode Visit(DbQuantifierExpression e)
            {
                TreeNode retInfo = NodeFromExpression(e);
                retInfo.Children.Add(this.VisitBinding("Input", e.Input));
                retInfo.Children.Add(this.Visit("Predicate", e.Predicate));
                return retInfo;
            }

public override TreeNode Visit(DbLambdaExpression expression)
            {
                TreeNode lambdaInfo = new TreeNode();
                lambdaInfo.Text.Append("Lambda");

                AppendParameters(lambdaInfo, expression.Lambda.Variables.Select(v => new KeyValuePair<string, TypeUsage>(v.VariableName, v.ResultType)));
                AppendArguments(lambdaInfo, expression.Lambda.Variables.Select(v => v.VariableName).ToArray(), expression.Arguments);
                lambdaInfo.Children.Add(this.Visit("Body", expression.Lambda.Body));

                return lambdaInfo;
            }

public override TreeNode Visit(DbRelationshipNavigationExpression e)
            {
                TreeNode retInfo = NodeFromExpression(e);
                retInfo.Children.Add(CreateRelationshipNode(e.Relationship));
                retInfo.Children.Add(CreateNavigationNode(e.NavigateFrom, e.NavigateTo));
                retInfo.Children.Add(this.Visit("Source", e.NavigationSource));

                return retInfo;
            }

public override TreeNode Visit(DbSkipExpression e)
            {
                TreeNode retInfo = NodeFromExpression(e);
                retInfo.Children.Add(this.VisitBinding("Input", e.Input));
                retInfo.Children.Add(this.VisitSortOrder(e.SortOrder));
                retInfo.Children.Add(this.Visit("Count", e.Count));
                return retInfo;
            }

public override TreeNode Visit(DbGroupByExpression e)
            {
                List<TreeNode/n ..... /n //View Source file for more details /n }