Class MapContainsKeyMethod

  • All Implemented Interfaces:
    SQLMethod

    public class MapContainsKeyMethod
    extends Object
    implements SQLMethod
    Method for evaluating {mapExpr}.containsKey(keyExpr). Returns a BooleanExpression.
    • Constructor Detail

      • MapContainsKeyMethod

        public MapContainsKeyMethod()
    • Method Detail

      • getExpression

        public SQLExpression getExpression​(SQLStatement stmt,
                                           SQLExpression expr,
                                           List<SQLExpression> args)
        Description copied from interface: SQLMethod
        Return the expression for this SQL function.
        Specified by:
        getExpression in interface SQLMethod
        Parameters:
        stmt - SQLStatement that this expression is for
        expr - The expression that it is invoked on
        args - Arguments passed in
        Returns:
        The SQL expression using the SQL function
      • getNeedsSubquery

        protected boolean getNeedsSubquery​(SQLStatement stmt)
        Convenience method to decide if we handle the contains() by using a subquery, or otherwise via an inner join. If there is an OR or a NOT in the query then uses a subquery.
        Parameters:
        stmt - SQLStatement
        Returns:
        Whether to use a subquery
      • containsAsJoin

        protected SQLExpression containsAsJoin​(SQLStatement stmt,
                                               MapExpression mapExpr,
                                               SQLExpression keyExpr,
                                               SQLJoin.JoinType joinType)
        Method to return an expression for Map.containsKey using INNER JOIN to the element. This is only for use when there are no "!containsKey" and no "OR" operations. Creates SQL by adding INNER JOIN to the join table (where it exists), and also to the key table adding an AND condition on the element (with value of the keyExpr). Returns a BooleanExpression "TRUE" (since the INNER JOIN will guarantee if the key is contained of not).
        Parameters:
        stmt - SQLStatement
        mapExpr - Map expression
        keyExpr - Expression for the key
        joinType - Type of join
        Returns:
        Contains expression
      • containsAsSubquery

        protected SQLExpression containsAsSubquery​(SQLStatement stmt,
                                                   MapExpression mapExpr,
                                                   SQLExpression keyExpr)
        Method to return an expression for Map.containsKey using a subquery "EXISTS". This is for use when there are "!contains" or "OR" operations in the filter. Creates the following SQL,
        • Map using join table
           SELECT 1 FROM JOIN_TBL A0_SUB 
           WHERE A0_SUB.JOIN_OWN_ID = A0.ID AND A0_SUB.JOIN_KEY_ID = {keyExpr}
           
        • Map with key stored in value
           SELECT 1 FROM KEY_TABLE A0_SUB INNER JOIN VALUE_TBL B0 ON ... 
           WHERE B0.JOIN_OWN_ID = A0.ID AND A0_SUB.ID = {keyExpr}
           
        • Map of value stored in key
           SELECT 1 FROM KEY_TABLE A0_SUB
           WHERE A0_SUB.OWN_ID = A0.ID AND A0_SUB.ID = {keyExpr}
           
        and returns a BooleanSubqueryExpression ("EXISTS (subquery)")
        Parameters:
        stmt - SQLStatement
        mapExpr - Map expression
        keyExpr - Expression for the key
        Returns:
        Contains expression
      • keyTypeCompatible

        protected boolean keyTypeCompatible​(Class keyType,
                                            Class mapKeyType)