Example #1
0
        public override void Visit(DbOrExpression e)
        {
            Check.NotNull(e, "e");

            BeginBinary(e);
            End(e);
        }
Example #2
0
        public override object Visit(DbOrExpression expression)
        {
            this.Visit(expression.Left);
            this.Visit(expression.Right);

            return(null);
        }
Example #3
0
        public override LegacyCommandTrees.DbExpression Visit(DbOrExpression expression)
        {
            Debug.Assert(expression != null, "expression != null");

            return
                (expression.Left.Accept(this).Or(expression.Right.Accept(this)));
        }
 public override Expression Visit(DbOrExpression expression)
 {
     return
         (Expression.OrElse(
              this.Visit(expression.Left),
              this.Visit(expression.Right)));
 }
Example #5
0
        public override DbExpression Visit(DbOrExpression exp)
        {
            Stack<DbExpression> operands = GatherBinaryExpressionOperand(exp);
            this.ConcatOperands(operands, " OR ");

            return exp;
        }
Example #6
0
 public override Expression Visit(DbOrExpression expression)
 {
     return
         Expression.OrElse(
             this.Visit(expression.Left),
             this.Visit(expression.Right));
 }
Example #7
0
 public override void Visit(DbOrExpression expression)
 {
     Write(expression);
     _depth++;
     Write("Left", expression.Left);
     Write("Right", expression.Right);
     _depth--;
 }
Example #8
0
        /// <summary>
        /// Implements the visitor pattern for <see cref="T:System.Data.Common.CommandTrees.DbOrExpression"/>.
        /// </summary>
        /// <param name="expression">The <see cref="T:System.Data.Common.CommandTrees.DbOrExpression"/> that is visited.</param>
        public override void Visit(DbOrExpression expression)
        {
            if (expression == null)
            {
                throw new ArgumentNullException("expression");
            }

            expression.Left.Accept(this);
            expression.Right.Accept(this);
        }
Example #9
0
 internal static IEnumerable <DbExpression> FlattenOr(
     DbExpression expression)
 {
     return(Helpers.GetLeafNodes <DbExpression>(expression, (Func <DbExpression, bool>)(exp => exp.ExpressionKind != DbExpressionKind.Or), (Func <DbExpression, IEnumerable <DbExpression> >)(exp =>
     {
         DbOrExpression dbOrExpression = (DbOrExpression)exp;
         return (IEnumerable <DbExpression>) new DbExpression[2]
         {
             dbOrExpression.Left,
             dbOrExpression.Right
         };
     })));
 }
Example #10
0
        public void Process(DbMethodCallExpression exp, SqlGenerator generator)
        {
            DbExpression e = exp.Arguments.First();
            DbEqualExpression equalNullExpression = DbExpression.Equal(e, DbExpression.Constant(null, UtilConstants.TypeOfString));
            DbEqualExpression equalEmptyExpression = DbExpression.Equal(e, DbExpression.Constant(string.Empty));

            DbOrExpression orExpression = DbExpression.Or(equalNullExpression, equalEmptyExpression);

            DbCaseWhenExpression.WhenThenExpressionPair whenThenPair = new DbCaseWhenExpression.WhenThenExpressionPair(orExpression, DbConstantExpression.One);

            List<DbCaseWhenExpression.WhenThenExpressionPair> whenThenExps = new List<DbCaseWhenExpression.WhenThenExpressionPair>(1);
            whenThenExps.Add(whenThenPair);

            DbCaseWhenExpression caseWhenExpression = DbExpression.CaseWhen(whenThenExps, DbConstantExpression.Zero, UtilConstants.TypeOfBoolean);

            var eqExp = DbExpression.Equal(caseWhenExpression, DbConstantExpression.One);
            eqExp.Accept(generator);
        }
            /// <summary>
            /// Evaluates an 'or' expression given results of evaluating its children.
            /// </summary>
            /// <param name="predicate">'Or' predicate</param>
            /// <returns>True if either child predicate is satisfied; false otherwise.</returns>
            public override PropagatorResult Visit(DbOrExpression predicate)
            {
                EntityUtil.CheckArgumentNull(predicate, "predicate");

                PropagatorResult left        = Visit(predicate.Left);
                PropagatorResult right       = Visit(predicate.Right);
                bool?            leftResult  = ConvertResultToBool(left);
                bool?            rightResult = ConvertResultToBool(right);
                bool?            result;

                // Optimization: if either argument is true, preserved and known, return a
                // result that is true, preserved and known.
                if ((leftResult.HasValue && leftResult.Value && PreservedAndKnown(left)) ||
                    (rightResult.HasValue && rightResult.Value && PreservedAndKnown(right)))
                {
                    return(CreatePerservedAndKnownResult(true));
                }

                result = EntityUtil.ThreeValuedOr(leftResult, rightResult);

                return(ConvertBoolToResult(result, left, right));
            }
Example #12
0
 /// <summary>
 ///     Visitor pattern method for DbOrExpression.
 /// </summary>
 /// <param name="expression"> The DbOrExpression that is being visited. </param>
 public abstract void Visit(DbOrExpression expression);
Example #13
0
        /// <summary>
        /// Implements the visitor pattern for <see cref="T:System.Data.Common.CommandTrees.DbOrExpression"/>.
        /// </summary>
        /// <param name="expression">The <see cref="T:System.Data.Common.CommandTrees.DbOrExpression"/> that is visited.</param>
        public override void Visit(DbOrExpression expression)
        {
            if (expression == null)
            {
                throw new ArgumentNullException("expression");
            }

            expression.Left.Accept(this);
            expression.Right.Accept(this);
        }
Example #14
0
 public override ISqlFragment Visit(DbOrExpression e)
 {
     return(VisitBinaryExpression("or", e.Left, e.Right));
 }
            public override void Visit(DbOrExpression expression)
            {
                Check.NotNull(expression, "expression");

                VisitBinary(expression, " or ");
            }
 public override void Visit(DbOrExpression e)
 {
     VisitBinary(e);
 }
 public override void Visit(DbOrExpression expression)
 {
     VisitBinary(expression, " OR ");
 }
Example #18
0
 public override SqlFragment Visit(DbOrExpression expression)
 {
     return(VisitBinaryExpression(expression.Left, expression.Right, "OR"));
 }
Example #19
0
 public override bool Visit(DbOrExpression expression)
 {
     Check.NotNull <DbOrExpression>(expression, nameof(expression));
     return(this.VisitBinaryExpression((DbBinaryExpression)expression));
 }
 public override void Visit(DbOrExpression expression)
 {
     Contract.Requires(expression != null);
 }
 /// <summary>
 ///     Visitor pattern method for DbOrExpression.
 /// </summary>
 /// <param name="expression"> The DbOrExpression that is being visited. </param>
 public abstract void Visit(DbOrExpression expression);
Example #22
0
            public override TreeNode Visit(DbOrExpression e)
            {
                Check.NotNull(e, "e");

                return(VisitInfix(e.Left, "Or", e.Right));
            }
 public override TReturn Visit(DbOrExpression expression)
 {
     throw ConstructNotSupportedException(expression);
 }
        public override void Visit(DbOrExpression e)
        {
            Check.NotNull(e, "e");

            VisitBinary(e);
        }
 public override void Visit(DbOrExpression e)
 {
     BeginBinary(e);
     End(e);
 }
Example #26
0
 public override DbExpression Visit(DbOrExpression exp)
 {
     return(this.ConvertDbBooleanExpression(exp));
 }
 /// <summary>
 ///     Visitor pattern method for <see cref="DbOrExpression" />.
 /// </summary>
 /// <param name="expression"> The DbOrExpression that is being visited. </param>
 /// <exception cref="ArgumentNullException">
 ///     <paramref name="expression" />
 ///     is null
 /// </exception>
 public override void Visit(DbOrExpression expression)
 {
     VisitBinaryExpression(expression);
 }
Example #28
0
 public abstract T Visit(DbOrExpression exp);
Example #29
0
 public override TreeNode Visit(DbOrExpression e)
 {
     Check.NotNull <DbOrExpression>(e, nameof(e));
     return(this.VisitInfix(e.Left, "Or", e.Right));
 }
Example #30
0
 public override DbExpressionEntitySetInfo Visit(DbOrExpression expression)
 {
     return(null);
 }
            // Removes null parameter checks

            public override DbExpression Visit(DbOrExpression expression)
            {
                return(expression.Left.Accept(this));
            }
Example #32
0
 public override VfpExpression Visit(DbOrExpression expression)
 {
     return(new VfpOrExpression(expression.ResultType,
                                expression.Left.Accept(this),
                                expression.Right.Accept(this)));
 }
Example #33
0
 public override void Visit(DbOrExpression e)
 {
     VisitBinary(e);
 }
Example #34
0
 /// <summary>
 ///     Typed visitor pattern method for DbOrExpression.
 /// </summary>
 /// <param name="expression"> The DbOrExpression that is being visited. </param>
 /// <returns> An instance of TResultType. </returns>
 public abstract TResultType Visit(DbOrExpression expression);
 public override void Visit(DbOrExpression expression) { }
Example #36
0
 public override void Visit(DbOrExpression e)
 {
     Check.NotNull <DbOrExpression>(e, nameof(e));
     this.VisitBinary((DbBinaryExpression)e);
 }
Example #37
0
            public override void Visit(DbOrExpression expression)
            {
                Check.NotNull(expression, "expression");

                VisitBinary(expression, " or ");
            }
 public override void Visit(DbOrExpression expression)
 {
     this.VisitBinary((DbBinaryExpression)expression, " or ");
 }
Example #39
0
 public override bool Visit(DbOrExpression expression)
 {
     return(VisitBinaryExpression(expression));
 }
Example #40
0
            public override DbExpressionEntitySetInfo Visit(DbOrExpression expression)
            {
                Check.NotNull(expression, "expression");

                return(null);
            }
 public override void Visit(DbOrExpression expression)
 {
     VisitBinary(expression, " or ");
 }
            // Removes null parameter checks

            public override DbExpression Visit(DbOrExpression expression)
            {
                return expression.Left.Accept(this);
            }