Class JDOQLParser

  • All Implemented Interfaces:
    Parser

    public class JDOQLParser
    extends AbstractParser
    Implementation of a parser for JDOQL query language. Generates Node tree(s) by use of the various parseXXX() methods.
    • Field Detail

      • jdoqlMethodNames

        private static java.lang.String[] jdoqlMethodNames
      • explicitParams

        private boolean explicitParams
      • paramPrefixes

        private static java.lang.String paramPrefixes
        Characters that parameters can be prefixed by.
      • allowSingleEquals

        private boolean allowSingleEquals
      • parameterNameList

        private java.util.List<java.lang.Object> parameterNameList
    • Constructor Detail

      • JDOQLParser

        public JDOQLParser()
        Constructor for a JDOQL Parser.
    • Method Detail

      • allowSingleEquals

        public void allowSingleEquals​(boolean flag)
        Method to set whether "=" is allowed. It is valid in an UPDATE clause, but not in a WHERE clause, for example.
        Parameters:
        flag - Whether to allow it
      • parse

        public Node parse​(java.lang.String expression)
      • parseVariable

        public Node parseVariable​(java.lang.String expression)
      • parseFrom

        public Node[] parseFrom​(java.lang.String expression)
      • processFromExpression

        private Node[] processFromExpression()
        The FROM expression in JDOQL (subquery) is a "candidate alias" expression, like
        • mydomain.MyClass [AS] alias"
        Returns:
        Node tree(s) for the FROM expression
      • parseUpdate

        public Node[] parseUpdate​(java.lang.String expression)
      • parseOrder

        public Node[] parseOrder​(java.lang.String expression)
      • parseResult

        public Node[] parseResult​(java.lang.String expression)
        The RESULT expression in JDOQL can include aggregates, fields, as well as aliases
        • myfield [AS] alias, myfield2"
        The Node tree for this would be
        [
         [IDENTIFIER : myfield.
              [NAME : alias]],
         [IDENTIFIER : myfield2]
         ]
        Returns:
        Node tree(s) for the RESULT expression
      • parseTuple

        public Node[] parseTuple​(java.lang.String expression)
      • parseVariables

        public Node[][] parseVariables​(java.lang.String expression)
      • parseParameters

        public Node[][] parseParameters​(java.lang.String expression)
      • processOrderExpression

        private Node[] processOrderExpression()
      • processExpression

        private Node processExpression()
      • processConditionalOrExpression

        private void processConditionalOrExpression()
        This method deals with the OR condition. A condition specifies a combination of one or more expressions and logical (Boolean) operators and returns a value of TRUE, FALSE, or unknown
      • processConditionalAndExpression

        private void processConditionalAndExpression()
        This method deals with the AND condition. A condition specifies a combination of one or more expressions and logical (Boolean) operators and returns a value of TRUE, FALSE, or unknown
      • processInclusiveOrExpression

        private void processInclusiveOrExpression()
      • processExclusiveOrExpression

        private void processExclusiveOrExpression()
      • processAndExpression

        private void processAndExpression()
      • processRelationalExpression

        private void processRelationalExpression()
        Parse of an expression that is a relation between expressions.
      • processAdditiveExpression

        protected void processAdditiveExpression()
      • processMultiplicativeExpression

        protected void processMultiplicativeExpression()
      • processUnaryExpression

        protected void processUnaryExpression()
      • processPrimary

        protected void processPrimary()
        Parses the primary. First look for a literal (e.g. "text"), then an identifier(e.g. variable) In the next step, call a function, if executing a function, on the literal or the identifier found.
      • processIfElseExpression

        private void processIfElseExpression()
        Method to parse the query syntax for an "IF ... ELSE ..." expression. Creates a Node of type "CASE" with children in the order
        ifNode, ifActionNode [, ifNode, ifActionNode]*, elseActionNode
      • processCast

        private boolean processCast()
        Parse any cast expression. If a cast is found will create a Node of type CAST with the value being the class to cast to.
        Returns:
        Whether a cast was processed
      • processCreator

        private boolean processCreator()
        Method to parse "new a.b.c(param1[,param2], ...)" and create a Node of type CREATOR. The Node at the top of the stack after this call will have any arguments defined in its "properties".
        Returns:
        whether method syntax was found.
      • processMethod

        private boolean processMethod()
        Method to parse "methodName(param1[,param2], ...)" and create a Node of type INVOKE. The Node at the top of the stack after this call will have any arguments defined in its "properties".
        Returns:
        whether method syntax was found.
      • processArray

        private boolean processArray()
        Method to parse an array expression ("{a,b,c}"), creating an ARRAY node with the node value being a List of the elements. Also handles processing of subsequent "length" 'method' which is special case for arrays and not caught by processMethod() since it doesn't have "()".
        Returns:
        Whether an array was parsed from the current position
      • processLiteral

        protected boolean processLiteral()
        A literal is one value of any type. Supported literals are of types String, Floating Point, Integer, Character, Boolean and null e.g. 'J', "String", 1, 1.8, true, false, null.
        Returns:
        The parsed literal
      • processIdentifier

        private boolean processIdentifier()
        An identifier always designates a reference to a single value. A single value can be one collection, one field.
        Returns:
        The parsed identifier
      • getPositionFromParameterName

        private int getPositionFromParameterName​(java.lang.Object name)