org.jpox.store.rdbms.query
Class JPQLQueryCompiler

java.lang.Object
  org.jpox.store.query.QueryCompiler
      org.jpox.store.rdbms.query.JavaQueryCompiler
          org.jpox.store.rdbms.query.JPQLQueryCompiler

All Implemented Interfaces:

org.jpox.store.mapped.expression.UnboundVariable.VariableBinder

public class JPQLQueryCompiler
extends JavaQueryCompiler

Compiler of JPQL queries for RDBMS datastores. Takes the input query and provides two forms of compilation :-

• preCompile - where all is compiled except that parameter values arent known
• executionCompile - like preCompile except also using the parameter values, just before execution

During either compilation step other parts of the query are resolved and are available for update by accessors.

Version:

$Revision$

Field Summary

protected java.util.Map	aliases Aliases encountered in FROM clause, with their information keyed by the alias string.
protected org.jpox.store.mapped.expression.ClassExpression[]	candidateExpressions Expressions for the candidate(s).
protected JPQLQueryCompiler	parentCompiler Compiler for any parent query.
protected java.util.Set	processedParameters Set of parameters encountered during this compilation of the query.

Fields inherited from class org.jpox.store.rdbms.query.JavaQueryCompiler

candidateCmd, candidates, distinct, expressionsByVariableName, parentExpr, qs, rangeFromIncl, rangeToExcl, resultClass, resultMetaData, subqueryCandidateExpr, subqueryCandidateExprRootAliasInfo

Fields inherited from class org.jpox.store.query.QueryCompiler

candidateAlias, candidateClass, COMPILE_EXECUTION, COMPILE_EXPLICIT_PARAMETERS, COMPILE_EXPLICIT_VARIABLES, COMPILE_SYNTAX, executionCompile, imports, language, LOCALISER, p, parameterNames, parameters, parameterTypesByName, query, variableNames, variableTypesByName

Constructor Summary

JPQLQueryCompiler(org.jpox.store.query.AbstractJPQLQuery query, org.jpox.util.Imports imports, java.util.Map parameters)
Constructor.

Method Summary

protected org.jpox.store.mapped.expression.ScalarExpression	compileAndExpression()
protected void	compileCandidates() Convenience method to process the candidates for this query.
protected org.jpox.store.mapped.expression.ScalarExpression	compileEqualityExpression()
protected org.jpox.store.mapped.expression.ScalarExpression	compileExpression() Principal method for compiling an expression.
protected org.jpox.store.mapped.expression.ScalarExpression	compileExpressionFromString(java.lang.String str) Convenience method to parse an expression string into its query expression.
protected org.jpox.store.mapped.expression.ClassExpression	compileFromExpression(java.lang.String fromStr) Method to take an expression string from the "from" clause and convert it into a ScalarExpression.
protected void	compileFromJoinExpressions(org.jpox.store.mapped.expression.ClassExpression clsExpr) Method to compile the join expressions in the FROM clause, updating the input ClassExpression with the discovered joins.
protected org.jpox.store.mapped.expression.ScalarExpression	compileIdentifier() An identifier always designates a reference to a single value.
protected org.jpox.store.mapped.expression.ScalarExpression	compileInExpression(org.jpox.store.mapped.expression.ScalarExpression expr) Compile an "IN (in_item{,in_item})" expression block.
protected org.jpox.store.mapped.expression.ScalarExpression	compileLikeExpression(org.jpox.store.mapped.expression.ScalarExpression expr) Compile a "LIKE pattern [ESCAPE {escape char}]" expression block.
protected org.jpox.store.mapped.expression.ScalarExpression	compileMemberExpression(org.jpox.store.mapped.expression.ScalarExpression expr) Compile a "MEMBER [OF] coll_expr" expression block.
protected org.jpox.store.mapped.expression.ScalarExpression	compileNamedImplicitParameter(java.lang.String id) Method to compile a named implicit parameter into an expression.
protected org.jpox.store.mapped.expression.ScalarExpression	compileNotExpression()
protected org.jpox.store.mapped.expression.ScalarExpression	compileNumberedImplicitParameter(java.lang.String id) Method to compile a numbered implicit parameter into an expression.
protected void	compileOrdering(org.jpox.store.mapped.expression.QueryExpression qs, java.lang.String ordering) Convenience method to compile the ordering defintion.
protected org.jpox.store.mapped.expression.ScalarExpression	compileOrExpression()
protected org.jpox.store.mapped.expression.ScalarExpression	compilePrimary() this compiles a primary.
protected org.jpox.store.mapped.expression.ScalarExpression	compileRelationalExpression()
protected org.jpox.store.mapped.expression.ScalarExpression	compileSubqueryVariable(java.lang.String id) Method to compile a subquery, replacing the specified variable with a SubqueryExpression.
protected void	compileUpdate(org.jpox.store.mapped.expression.QueryExpression qs, java.lang.String update) Convenience method to compile the update clause.
protected java.lang.Class	getClassForSubqueryCandidateExpression(java.lang.String candExpr) Convenience method to process the subquery "" to return the class to use.
protected void	performCompile(org.jpox.store.mapped.expression.QueryExpression qs) Perform the actual compilation of the query, populating the provided QueryExpression.
void	processAsSubquery(JPQLQueryCompiler parentCompiler) Method to set the parent compiler/query that this is a subquery of.
protected void	processClassExpression(org.jpox.store.mapped.expression.ClassExpression classExpr) Method to process a ClassExpression from the FROM clause.
protected void	processJoinExpression(org.jpox.store.mapped.expression.JoinExpression joinExpr) Method to process the supplied JoinExpression and add the required join to the current QueryStatement.

Methods inherited from class org.jpox.store.rdbms.query.JavaQueryCompiler

bindVariable, callUserDefinedScalarExpression, checkExpressionsAgainstGrouping, checkVariableBinding, close, compile, compileAdditiveExpression, compileCastExpression, compileExplicitVariable, compileExpressionsFromString, compileFilter, compileGrouping, compileHaving, compileLiteral, compileMultiplicativeExpression, compileNewObject, compileRange, compileResult, compileSubqueryCandidateExpression, compileUnaryExpression, compileUnaryExpressionNotPlusMinus, executionCompile, getCandidates, getDistinct, getRangeFromIncl, getRangeToExcl, getResultClass, getResultMetaData, preCompile

Methods inherited from class org.jpox.store.query.QueryCompiler

compileExplicitParameters, compileExplicitVariables, getCandidateAlias, getCandidateClass, getParameterNames, getParameterTypesByName

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

aliases

protected transient java.util.Map aliases

Aliases encountered in FROM clause, with their information keyed by the alias string.

candidateExpressions

protected transient org.jpox.store.mapped.expression.ClassExpression[] candidateExpressions

Expressions for the candidate(s). Populated after compiking the candidates.

processedParameters

protected transient java.util.Set processedParameters

Set of parameters encountered during this compilation of the query.

parentCompiler

protected JPQLQueryCompiler parentCompiler

Compiler for any parent query.

Constructor Detail

JPQLQueryCompiler

public JPQLQueryCompiler(org.jpox.store.query.AbstractJPQLQuery query,
                         org.jpox.util.Imports imports,
                         java.util.Map parameters)

Constructor.

Parameters:

query - Query to compile

imports - Imports handler to use for class resolution

parameters - map of declared parameters in the query

Method Detail

processAsSubquery

public void processAsSubquery(JPQLQueryCompiler parentCompiler)

Method to set the parent compiler/query that this is a subquery of. Should be set before calling preCompile/executionCompile.

Parameters:

parentCompiler - The parent compiler

performCompile

protected void performCompile(org.jpox.store.mapped.expression.QueryExpression qs)

Perform the actual compilation of the query, populating the provided QueryExpression.

Specified by:

performCompile in class JavaQueryCompiler

Parameters:

qs - The QueryExpression to use during compilation

compileUpdate

protected void compileUpdate(org.jpox.store.mapped.expression.QueryExpression qs,
                             java.lang.String update)

Convenience method to compile the update clause. Processes the "update" and updates the QueryExpression accordingly.

Parameters:

qs - The Query Expression to apply the update to (if specified)

update - The update specification

compileCandidates

protected void compileCandidates()

Convenience method to process the candidates for this query. Processes the "candidateClassName" and "candidateClass" and sets up "candidates". The QueryExpression "qs" isn't set at this point.

Specified by:

compileCandidates in class JavaQueryCompiler

compileFromExpression

protected org.jpox.store.mapped.expression.ClassExpression compileFromExpression(java.lang.String fromStr)

Method to take an expression string from the "from" clause and convert it into a ScalarExpression. The "from" clause is made up of between 1 and N expression strings (comma separated). The from expression string has the form

{class-expression} [AS] alias [JOIN ...]

or

IN (collection-value-path) [AS] alias [JOIN ...]

Parameters:

fromStr - The from expression string

Returns:

Class Expression for this part of the FROM

compileFromJoinExpressions

protected void compileFromJoinExpressions(org.jpox.store.mapped.expression.ClassExpression clsExpr)

Method to compile the join expressions in the FROM clause, updating the input ClassExpression with the discovered joins.

Parameters:

clsExpr - Class Expression that the join(s) are applied to

getClassForSubqueryCandidateExpression

protected java.lang.Class getClassForSubqueryCandidateExpression(java.lang.String candExpr)

Convenience method to process the subquery "" to return the class to use. If the input "expression" is actually a class name then just returns the class. If the input "expression" starts with the candidate alias of the parent query then returns the class of the expression navigating along its tokens.

Parameters:

candExpr - Candidate expression

Returns:

Class for candidate expression

processClassExpression

protected void processClassExpression(org.jpox.store.mapped.expression.ClassExpression classExpr)

Method to process a ClassExpression from the FROM clause. A ClassExpression can contain a series of joins. The main (first) ClassExpression processed will be for the main candidate. Subsequent ClassExpressions can be for other classes that should be cross-joined in the query. All join expressions for a ClassExpression result in either an INNER or LEFT OUTER join being added to the query. See JPA spec 4.4.5.

An example of multiple class expressions

select c from Customer c, Employee e where c.hatsize = e.shoesize

so in this we have a class expression for the main candidate (Customer), and a class expression for Employee which results in a cross join for Employee.

An example of a class expression with joins

 SELECT DISTINCT o
 FROM Order o JOIN o.lineItems l JOIN l.product p
 WHERE ...
 

so we have a ClassExpression for Order, and this has 2 JoinExpressions within it. The first join is from the field "lineItems" of Order, to class LineItem (aliased as "l"). The second join is from the field "product" of LineItem, to class Product (aliased as "p").

Parameters:

classExpr - The class expression to process

processJoinExpression

protected void processJoinExpression(org.jpox.store.mapped.expression.JoinExpression joinExpr)

Method to process the supplied JoinExpression and add the required join to the current QueryStatement. The "fieldName" of the JoinExpression must be of the form "alias.field". No multiple level field names are supported here.

Parameters:

joinExpr - JoinExpression

compileOrdering

protected void compileOrdering(org.jpox.store.mapped.expression.QueryExpression qs,
                               java.lang.String ordering)

Convenience method to compile the ordering defintion. Processes any ordering definition and updates the QueryExpression accordingly.

Parameters:

qs - The Query Expression to apply the ordering to (if specified)

ordering - The ordering specification

compileExpressionFromString

protected org.jpox.store.mapped.expression.ScalarExpression compileExpressionFromString(java.lang.String str)

Convenience method to parse an expression string into its query expression.

Specified by:

compileExpressionFromString in class JavaQueryCompiler

Parameters:

str - The string

Returns:

The query expression for the passed string

compileExpression

protected org.jpox.store.mapped.expression.ScalarExpression compileExpression()

Principal method for compiling an expression. An expression could be the filter, the range, the result, etc.

Specified by:

compileExpression in class JavaQueryCompiler

Returns:

The compiled expression

compileOrExpression

protected org.jpox.store.mapped.expression.ScalarExpression compileOrExpression()

compileAndExpression

protected org.jpox.store.mapped.expression.ScalarExpression compileAndExpression()

compileNotExpression

protected org.jpox.store.mapped.expression.ScalarExpression compileNotExpression()

compileEqualityExpression

protected org.jpox.store.mapped.expression.ScalarExpression compileEqualityExpression()

compileLikeExpression

protected org.jpox.store.mapped.expression.ScalarExpression compileLikeExpression(org.jpox.store.mapped.expression.ScalarExpression expr)

Compile a "LIKE pattern [ESCAPE {escape char}]" expression block. The "LIKE" has already been parsed before here.

Parameters:

expr - The input expression we are performing the LIKE on

Returns:

The equality expression for the LIKE

compileInExpression

protected org.jpox.store.mapped.expression.ScalarExpression compileInExpression(org.jpox.store.mapped.expression.ScalarExpression expr)

Compile an "IN (in_item{,in_item})" expression block. The "IN" has already been parsed before here.

Parameters:

expr - The input expression we are performing the IN on.

Returns:

The equality expression for the IN

compileMemberExpression

protected org.jpox.store.mapped.expression.ScalarExpression compileMemberExpression(org.jpox.store.mapped.expression.ScalarExpression expr)

Compile a "MEMBER [OF] coll_expr" expression block. The "MEMBER" has already been parsed before here.

Parameters:

expr - The input expression we are performing the MEMBER on

Returns:

The equality expression for the MEMBER

compileRelationalExpression

protected org.jpox.store.mapped.expression.ScalarExpression compileRelationalExpression()

compilePrimary

protected org.jpox.store.mapped.expression.ScalarExpression compilePrimary()

this compiles a 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.

Specified by:

compilePrimary in class JavaQueryCompiler

Returns:

Scalar Expression for the primary compiled expression

compileIdentifier

protected org.jpox.store.mapped.expression.ScalarExpression compileIdentifier()

An identifier always designates a reference to a single value. A single value can be one collection, one field.

Returns:

The compiled identifier

compileSubqueryVariable

protected org.jpox.store.mapped.expression.ScalarExpression compileSubqueryVariable(java.lang.String id)

Method to compile a subquery, replacing the specified variable with a SubqueryExpression.

Parameters:

id - Variable name that the subquery replaces.

Returns:

Expression for the subquery

compileNamedImplicitParameter

protected org.jpox.store.mapped.expression.ScalarExpression compileNamedImplicitParameter(java.lang.String id)

Method to compile a named implicit parameter into an expression.

Parameters:

id - Identifier of the named parameter, starts with ":"

Returns:

Expression representing the named param

compileNumberedImplicitParameter

protected org.jpox.store.mapped.expression.ScalarExpression compileNumberedImplicitParameter(java.lang.String id)

Method to compile a numbered implicit parameter into an expression.

Parameters:

id - Identifier of the named parameter, starts with "?" followed by the number

Returns:

Expression representing the numbered param