public void SqlBetweenScalarExpressionTest()
        {
            SqlBetweenScalarExpression threeBetweenFourAndFive = SqlBetweenScalarExpression.Create(
                SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(4)),
                SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(3)),
                SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(5)),
                not: false);

            AssertEvaluation(CosmosBoolean.Create(true), threeBetweenFourAndFive);

            SqlBetweenScalarExpression threeNotBetweenFourAndFive = SqlBetweenScalarExpression.Create(
                SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(4)),
                SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(3)),
                SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(5)),
                not: true);

            AssertEvaluation(CosmosBoolean.Create(false), threeNotBetweenFourAndFive);

            SqlBetweenScalarExpression trueBetweenTrueAndTrueNested = SqlBetweenScalarExpression.Create(
                SqlLiteralScalarExpression.Create(SqlBooleanLiteral.Create(true)),
                threeBetweenFourAndFive,
                threeBetweenFourAndFive,
                not: false);

            AssertEvaluation(CosmosBoolean.Create(true), trueBetweenTrueAndTrueNested);
        }
示例#2
0
        public override CosmosElement Visit(
            SqlBetweenScalarExpression scalarExpression,
            CosmosElement document)
        {
            // expression <not> BETWEEN left AND right === <not>(expression >= left && expression <= right);
            SqlBinaryScalarExpression expressionGTELeft = SqlBinaryScalarExpression.Create(
                SqlBinaryScalarOperatorKind.GreaterThanOrEqual,
                scalarExpression.Expression,
                scalarExpression.StartInclusive);

            SqlBinaryScalarExpression expressionLTERight = SqlBinaryScalarExpression.Create(
                SqlBinaryScalarOperatorKind.LessThanOrEqual,
                scalarExpression.Expression,
                scalarExpression.EndInclusive);

            SqlScalarExpression logicalBetween = SqlBinaryScalarExpression.Create(
                SqlBinaryScalarOperatorKind.And,
                expressionGTELeft,
                expressionLTERight);

            if (scalarExpression.Not)
            {
                logicalBetween = SqlUnaryScalarExpression.Create(SqlUnaryScalarOperatorKind.Not, logicalBetween);
            }

            return(logicalBetween.Accept(this, document));
        }
        public override bool Visit(SqlBetweenScalarExpression first, SqlObject secondAsObject)
        {
            if (!(secondAsObject is SqlBetweenScalarExpression second))
            {
                return(false);
            }

            if (!Equals(first.Expression, second.Expression))
            {
                return(false);
            }

            if (first.Not != second.Not)
            {
                return(false);
            }

            if (!Equals(first.StartInclusive, second.StartInclusive))
            {
                return(false);
            }

            if (!Equals(first.EndInclusive, second.EndInclusive))
            {
                return(false);
            }

            return(true);
        }
示例#4
0
 public override SqlObject Visit(SqlBetweenScalarExpression sqlBetweenScalarExpression)
 {
     return(SqlBetweenScalarExpression.Create(
                sqlBetweenScalarExpression.Expression.Accept(this) as SqlScalarExpression,
                sqlBetweenScalarExpression.LeftExpression.Accept(this) as SqlScalarExpression,
                sqlBetweenScalarExpression.RightExpression.Accept(this) as SqlScalarExpression,
                sqlBetweenScalarExpression.IsNot));
 }
 public override SqlObject Visit(SqlBetweenScalarExpression sqlBetweenScalarExpression)
 {
     return(SqlBetweenScalarExpression.Create(
                sqlBetweenScalarExpression.Expression.Accept(this) as SqlScalarExpression,
                sqlBetweenScalarExpression.StartInclusive.Accept(this) as SqlScalarExpression,
                sqlBetweenScalarExpression.EndInclusive.Accept(this) as SqlScalarExpression,
                sqlBetweenScalarExpression.Not));
 }
        public override SqlObject VisitBetweenScalarExpression([NotNull] sqlParser.BetweenScalarExpressionContext context)
        {
            Contract.Requires(context != null);
            // scalar_expression K_NOT? K_BETWEEN scalar_expression K_AND scalar_expression

            SqlScalarExpression needle = (SqlScalarExpression)this.Visit(context.binary_scalar_expression(0));
            bool not = context.K_NOT() != null;
            SqlScalarExpression start = (SqlScalarExpression)this.Visit(context.binary_scalar_expression(1));
            SqlScalarExpression end   = (SqlScalarExpression)this.Visit(context.binary_scalar_expression(2));

            return(SqlBetweenScalarExpression.Create(needle, start, end, not));
        }
        public override int Visit(SqlBetweenScalarExpression sqlBetweenScalarExpression)
        {
            int hashCode = SqlBetweenScalarExpressionHashCode;

            hashCode = CombineHashes(hashCode, sqlBetweenScalarExpression.Expression.Accept(this));
            if (sqlBetweenScalarExpression.Not)
            {
                hashCode = SqlObjectHasher.CombineHashes(hashCode, SqlBetweenScalarExpressionNotHashCode);
            }

            hashCode = CombineHashes(hashCode, sqlBetweenScalarExpression.StartInclusive.Accept(this));
            hashCode = CombineHashes(hashCode, sqlBetweenScalarExpression.EndInclusive.Accept(this));
            return(hashCode);
        }
示例#8
0
        public override int Visit(SqlBetweenScalarExpression sqlBetweenScalarExpression)
        {
            int hashCode = SqlBetweenScalarExpressionHashCode;

            hashCode = CombineHashes(hashCode, sqlBetweenScalarExpression.Expression.Accept(this));
            if (sqlBetweenScalarExpression.IsNot)
            {
                hashCode = SqlObjectHasher.CombineHashes(hashCode, SqlBetweenScalarExpressionNotHashCode);
            }

            hashCode = CombineHashes(hashCode, sqlBetweenScalarExpression.LeftExpression.Accept(this));
            hashCode = CombineHashes(hashCode, sqlBetweenScalarExpression.RightExpression.Accept(this));
            return(hashCode);
        }
示例#9
0
        public override void Visit(SqlBetweenScalarExpression sqlBetweenScalarExpression)
        {
            this.writer.Write("(");
            sqlBetweenScalarExpression.Expression.Accept(this);

            if (sqlBetweenScalarExpression.IsNot)
            {
                this.writer.Write(" NOT");
            }

            this.writer.Write(" BETWEEN ");
            sqlBetweenScalarExpression.LeftExpression.Accept(this);
            this.writer.Write(" AND ");
            sqlBetweenScalarExpression.RightExpression.Accept(this);
            this.writer.Write(")");
        }
        public override void Visit(SqlBetweenScalarExpression sqlBetweenScalarExpression)
        {
            this.writer.Write("(");
            sqlBetweenScalarExpression.Expression.Accept(this);

            if (sqlBetweenScalarExpression.Not)
            {
                this.writer.Write(" NOT");
            }

            this.writer.Write(" BETWEEN ");
            sqlBetweenScalarExpression.StartInclusive.Accept(this);
            this.writer.Write(" AND ");
            sqlBetweenScalarExpression.EndInclusive.Accept(this);
            this.writer.Write(")");
        }
示例#11
0
                public override bool Visit(SqlBetweenScalarExpression scalarExpression)
                {
                    if (this.MatchesGroupByExpression(scalarExpression))
                    {
                        return(true);
                    }

                    if (!scalarExpression.Expression.Accept(this))
                    {
                        return(false);
                    }

                    if (!scalarExpression.StartInclusive.Accept(this))
                    {
                        return(false);
                    }

                    if (!scalarExpression.EndInclusive.Accept(this))
                    {
                        return(false);
                    }

                    return(true);
                }
示例#12
0
 public abstract void Visit(SqlBetweenScalarExpression sqlObject);
示例#13
0
 public abstract TOutput Visit(SqlBetweenScalarExpression sqlObject, TArg input);
示例#14
0
 public abstract TResult Visit(SqlBetweenScalarExpression sqlObject);
 public abstract void Visit(SqlBetweenScalarExpression scalarExpression);
示例#16
0
 public abstract TResult Visit(SqlBetweenScalarExpression scalarExpression);
示例#17
0
 public override bool Visit(SqlBetweenScalarExpression sqlBetweenScalarExpression)
 {
     return(sqlBetweenScalarExpression.Expression.Accept(this) ||
            sqlBetweenScalarExpression.StartInclusive.Accept(this) ||
            sqlBetweenScalarExpression.EndInclusive.Accept(this));
 }