Class JavaQueryCompiler

java.lang.Object
org.datanucleus.store.query.compiler.JavaQueryCompiler
All Implemented Interfaces:
SymbolResolver
Direct Known Subclasses:
JDOQLCompiler, JPQLCompiler
public abstract class JavaQueryCompiler extends Object implements SymbolResolver
Typical implementation of a compiler for a java-based query language. The constructor takes in the components of the query, and the method compile() compiles it returning the compiled query, for use elsewhere.

Each "Expression" is effectively a tree of Expressions. You can navigate through each expression based on their type. For example, a DyadicExpression has a "left" and "right" and an operator between them. The left could also be a DyadicExpression, so you would navigate to its left/right components etc etc.

  • Field Details

    • JOIN_INNER

      public static final String JOIN_INNER
      See Also:

    • JOIN_INNER_FETCH

      public static final String JOIN_INNER_FETCH
      See Also:

    • JOIN_OUTER

      public static final String JOIN_OUTER
      See Also:

    • JOIN_OUTER_FETCH

      public static final String JOIN_OUTER_FETCH
      See Also:

    • JOIN_OUTER_RIGHT

      public static final String JOIN_OUTER_RIGHT
      See Also:

    • JOIN_OUTER_FETCH_RIGHT

      public static final String JOIN_OUTER_FETCH_RIGHT
      See Also:

    • queryMgr

      protected QueryManager queryMgr

    • parentCompiler

      protected JavaQueryCompiler parentCompiler

    • parameterSubtitutionMap

      protected Map<Object,String> parameterSubtitutionMap

    • parameterSubstitutionNumber

      protected int parameterSubstitutionNumber

    • metaDataManager

      protected final MetaDataManager metaDataManager

    • clr

      protected final ClassLoaderResolver clr

    • caseSensitiveAliases

      protected boolean caseSensitiveAliases

    • candidateClass

      protected Class candidateClass
      Primary candidate class (if defined).

    • candidateAlias

      protected String candidateAlias
      Alias for the primary candidate. Default to "this" (JDOQL) but can be set.

    • candidateAliasOrig

      protected String candidateAliasOrig
      Default candidate alias in use (only set when in a subquery and the same as the outer query).

    • from

      protected String from

    • candidates

      protected Collection candidates

    • update

      protected String update

    • filter

      protected String filter

    • ordering

      protected String ordering

    • parameters

      protected String parameters

    • variables

      protected String variables

    • grouping

      protected String grouping

    • having

      protected String having

    • result

      protected String result

    • imports

      protected Imports imports

    • symtbl

      protected SymbolTable symtbl
      Compiled Symbol Table.

    • parser

      protected Parser parser
      Parser specific to the type of query being compiled.

    • options

      protected Map<String,Object> options

  • Constructor Details

  • Method Details

    • getLanguage

      public abstract String getLanguage()
      Accessor for the query language name.
      Returns:
      Name of the query language.

    • setOption

      public void setOption(String name, Object value)

    • setLinkToParentQuery

      public void setLinkToParentQuery(JavaQueryCompiler parentCompiler, Map<Object,String> paramSubstitutionMap)
      Method to set the linkage to the parent query.
      Parameters:
      parentCompiler - Compiler for the parent query
      paramSubstitutionMap - Map of parameters in this subquery and what they are in the parent query.

    • compile

      public abstract QueryCompilation compile(Map parameters, Map<String,Object> subqueryMap)
      Method to compile the query.
      Parameters:
      parameters - The parameter values keyed by name.
      subqueryMap - Map of subqueries keyed by the subquery name
      Returns:
      The query compilation

    • compileCandidatesParametersVariables

      public void compileCandidatesParametersVariables(Map parameters)
      Compile the candidates, variables and parameters.
      Parameters:
      parameters - Map of parameter values keyed by their name

    • compileFrom

      protected Expression[] compileFrom()
      Method to compile the "from" clause (if present for the query language).
      Returns:
      The compiled from expression(s)

    • getClassForSubqueryClassExpression

      private Class getClassForSubqueryClassExpression(String classExpr)
      Convenience method to find the class that a subquery class expression refers to. Allows for reference to the parent query candidate class, or to a class name.
      Parameters:
      classExpr - The class expression
      Returns:
      The class that it refers to

    • compileCandidates

      private void compileCandidates()

    • compileUpdate

      public Expression[] compileUpdate()

    • compileFilter

      public Expression compileFilter()
      Compile the filter and return the compiled expression.
      Returns:
      The compiled expression

    • swapCandidateAliasNodeName

      protected void swapCandidateAliasNodeName(Node node)
      Convenience method that takes the input node and if it is set to the original candidate alias then swaps the value to the candidate alias. This is for the situation where we have a subquery which had no alias defined so defaults to "this" (the same as the outer query), so we change the subquery alias from "this" to "sub_this".
      Parameters:
      node - The node to process

    • swapSubqueryParameters

      protected Node swapSubqueryParameters(Node node)
      Convenience method that takes the input node if it is a parameter node and swaps the node
      Parameters:
      node - The node to process
      Returns:
      The Node with the swap

    • compileResult

      public Expression[] compileResult()

    • compileGrouping

      public Expression[] compileGrouping()

    • compileHaving

      public Expression compileHaving()

    • compileVariables

      private void compileVariables()

    • compileParameters

      private void compileParameters()

    • compileOrdering

      public Expression[] compileOrdering()

    • getPrimaryClass

      public Class getPrimaryClass()
      Description copied from interface: SymbolResolver
      Accessor for the candidate class of the query.
      Specified by:
      getPrimaryClass in interface SymbolResolver
      Returns:
      The candidate class

    • resolveClass

      public Class resolveClass(String className)
      Method to perform a lookup of the class name from the input name. Makes use of the query "imports" and the lookup to "entity name".
      Specified by:
      resolveClass in interface SymbolResolver
      Parameters:
      className - Name of the class
      Returns:
      The class corresponding to this name
      Throws:
      ClassNotResolvedException - thrown if not resolvable using imports or entity name

    • getType

      public Class getType(List<String> tuples)
      Specified by:
      getType in interface SymbolResolver

    • getType

      Class getType(Class cls, String fieldName, boolean lastEntry)

    • isKeyword

      protected abstract boolean isKeyword(String name)
      Method to return if the supplied name is a keyword. Keywords can only appear at particular places in a query so we need to detect for valid queries.
      Parameters:
      name - The name
      Returns:
      Whether it is a keyword