Package org.apache.qpid.server.query.engine.parsing.factory

Class ComparisonExpressionFactory

  • public final class ComparisonExpressionFactory
extends Object
    Factory creating comparison expressions

    • Method Detail

      • equalExpression

        public static <T,​R> Predicate<T> equalExpression​(ExpressionNode<T,​R> left,
                                                       ExpressionNode<T,​R> right)
        Creates EQUAL expression
        Type Parameters:
        T - Input parameter type
        R - Return parameter type
        Parameters:
        left - Left expression
        right - Right expression
        Returns:
        EqualExpression instance

      • notEqualExpression

        public static <T,​R> Predicate<T> notEqualExpression​(ExpressionNode<T,​R> left,
                                                          ExpressionNode<T,​R> right)
        Creates NOT EQUAL expression
        Type Parameters:
        T - Input parameter type
        R - Return parameter type
        Parameters:
        left - Left expression
        right - Right expression
        Returns:
        NotExpression instance

      • isNullExpression

        public static <T,​R> Predicate<T> isNullExpression​(ExpressionNode<T,​R> left)
        Creates IS NULL expression
        Type Parameters:
        T - Input parameter type
        R - Return parameter type
        Parameters:
        left - Left expression
        Returns:
        IsNullExpression instance

      • isNotNullExpression

        public static <T,​R> Predicate<T> isNotNullExpression​(ExpressionNode<T,​R> left)
        Creates IS NOT NULL expression
        Type Parameters:
        T - Input parameter type
        R - Return parameter type
        Parameters:
        left - Left expression
        Returns:
        NotExpression instance

      • likeExpression

        public static <T,​R> LikeExpression<T,​R> likeExpression​(ExpressionNode<T,​R> left,
                                                                   String source,
                                                                   String escape)
        Creates LIKE expression
        Type Parameters:
        T - Input parameter type
        R - Return parameter type
        Parameters:
        left - Left expression
        source - String source
        escape - Escape characters
        Returns:
        LikeExpression instance

      • betweenExpression

        public static <T,​R> BetweenExpression<T,​R> betweenExpression​(String alias,
                                                                         ExpressionNode<T,​R> left,
                                                                         ExpressionNode<T,​R> low,
                                                                         ExpressionNode<T,​R> high)
        Creates BETWEEN expression
        Type Parameters:
        T - Input parameter type
        R - Return parameter type
        Parameters:
        alias - Expression alias
        left - Left expression
        low - Low Expression
        high - High expression
        Returns:
        BetweenExpression

      • greaterThanExpression

        public static <T,​R> GreaterThanExpression<T,​R> greaterThanExpression​(ExpressionNode<T,​R> left,
                                                                                 ExpressionNode<T,​R> right)
        Creates GREATER THAN expression
        Type Parameters:
        T - Input parameter type
        R - Return parameter type
        Parameters:
        left - Left expression
        right - Right expression
        Returns:
        GreaterThanExpression instance

      • greaterThanOrEqualExpression

        public static <T,​R> Predicate<T> greaterThanOrEqualExpression​(ExpressionNode<T,​R> left,
                                                                    ExpressionNode<T,​R> right)
        Creates GREATER THAN OR EQUAL expression
        Type Parameters:
        T - Input parameter type
        R - Return parameter type
        Parameters:
        left - Left expression
        right - Right expression
        Returns:
        GreaterThanOrEqualExpression instance

      • lessThanExpression

        public static <T,​R> Predicate<T> lessThanExpression​(ExpressionNode<T,​R> left,
                                                          ExpressionNode<T,​R> right)
        Creates LESS THAN expression
        Type Parameters:
        T - Input parameter type
        R - Return parameter type
        Parameters:
        left - Left expression
        right - Right expression
        Returns:
        LessThanExpression instance

      • lessThanOrEqualExpression

        public static <T,​R> Predicate<T> lessThanOrEqualExpression​(ExpressionNode<T,​R> left,
                                                                 ExpressionNode<T,​R> right)
        Creates LESS THAN OR EQUAL expression
        Type Parameters:
        T - Input parameter type
        R - Return parameter type
        Parameters:
        left - Left expression
        right - Right expression
        Returns:
        LessThanOrEqualExpression instance

      • inExpression

        public static <T,​R> InExpression<T,​R> inExpression​(ExpressionNode<T,​R> left,
                                                               List<ExpressionNode<T,​R>> right)
        Creates IN expression
        Type Parameters:
        T - Input parameter type
        R - Return parameter type
        Parameters:
        left - Left expression
        right - List of expressions
        Returns:
        InExpression instance

      • inExpression

        public static <T,​R> InExpression<T,​R> inExpression​(ExpressionNode<T,​R> left,
                                                               SelectExpression<T,​R> right)
        Creates IN expression
        Type Parameters:
        T - Input parameter type
        R - Return parameter type
        Parameters:
        left - Left expression
        right - Select expression containing subquery
        Returns:
        InExpression instance