EclipseLink Hermes Parser 4.0.2 · org.eclipse.persistence.jpa.jpql.parser.JPQLQueryBNF

Modifier and Type	Field and Description
private Map<String, ExpressionFactory>	cachedExpressionFactories Caches the `ExpressionFactory` mapped by their the JPQL identifier registered with those `ExpressionFactory`.
private String[]	cachedExpressionFactoryIds Caches the collection of unique identifiers of the `ExpressionFactory` registered with this BNF rule.
private String[]	cachedIdentifiers The list of JPQL identifiers that are known by this BNF rule and its children, they are retrieved by scanning the list of `ExpressionFactory` registered with this BNF rule and its children.
private JPQLQueryBNF[]	childQueryBNFs Caches the children of this BNF rule (which actually includes this one as well).
private List<String>	children The children BNF of this one.
private boolean	compound Determines whether this BNF has child BNFs registered only to properly parse a query or if the child BNFs are part of the BNF.
private List<String>	expressionFactoryIds The list of unique identifiers for the `ExpressionFactory` that are registered with this BNF rule.
private ExpressionRegistry	expressionRegistry The `ExpressionRegistry` with which this `JPQLQueryBNF` was registered.
private String	fallbackBNFId The unique identifier of the `JPQLQueryBNF` to use in the last resort.
private String	fallbackExpressionFactoryId The unique identifier of the `ExpressionFactory` to use when no other factories can be used automatically.
private Boolean	handleAggregate Caches the property since any BNF rule is static.
private Boolean	handleCollection Caches the property since any BNF rule is static.
private boolean	handleNestedArray Determines whether this BNF handles parsing a nested array or not.
private boolean	handleSubExpression This flag can be used to determine if this BNF handles parsing a sub-expression, i.e. an expression encapsulated by parenthesis.
private String	id The unique identifier of this BNF rule.
private JPQLQueryBNF[]	nonCompoundChildren Caches the children of this BNF rule (which actually includes this one as well) but do not includes BNF rules that are used for compounding a rule.
private static final Filter<JPQLQueryBNF>	nonCompoundFilter Only keep one instance of the `Filter` used when initializing `nonCompoundChildren` JPQLQueryBNF.

Access	Constructor and Description
protected	JPQLQueryBNF(String The unique identifier of this BNF rule id) Creates a new `JPQLQueryBNF`.

Method Summary

Modifier and Type	Method and Description
private void	addChildren(Set<JPQLQueryBNF> The set to add the child BNF rules queryBNFs, Filter<JPQLQueryBNF> The `Filter` determines if the children of a given BNF should be added filter) Adds to the given set the child BNF rules and requests them to add their children as long as they have not been traversed already.
private JPQLQueryBNF[]	buildChildren(Filter<JPQLQueryBNF> filter)
private static Filter<JPQLQueryBNF>	buildNonCompoundFilter()
private void	calculateExpressionFactories()
private void	calculateExpressionFactoryIds(Set<JPQLQueryBNF> queryBNFs, Set<String> factoryIds)
private boolean	calculateHandleAggregate(Set<JPQLQueryBNF> queryBNFs)
private boolean	calculateHandleCollection(Set<JPQLQueryBNF> queryBNFs)
public Iterable<JPQLQueryBNF>	Returns: The children BNFs describing this BNF rule children() Returns the set of all the query BNFs that are part of this BNF.
private JPQLQueryBNF[]	getChildren()
public ExpressionFactory	Returns: The `ExpressionFactory` responsible to parse a portion of the query starting with the given identifier; `null` if nothing was registered for it getExpressionFactory(String The JPQL identifier (in theory) that is used to retrieve the factory responsible to parse a portion of the query starting with that identifier identifier) Retrieves the `ExpressionFactory` that is associated with the given identifier, if the given string is indeed a JPQL identifier.
public Iterable<String>	Returns: The list of unique identifiers of the `ExpressionFactory` registered with this BNF rule and with its children getExpressionFactoryIds() Returns the unique identifiers of the `ExpressionFactory` handled by this BNF rule, which includes those from the children as well.
private String[]	getExpressionFactoryIdsImp()
public ExpressionRegistry	Returns: The registry containing the information related to the JPQL grammar getExpressionRegistry() Returns the registry containing the `JPQLQueryBNFs` and the `ExpressionFactories` that are used to properly parse a JPQL query.
public String	Returns: The unique identifier of the `JPQLQueryBNF` to use in the last resort getFallbackBNFId() When parsing the query and no `JPQLQueryBNFs` can help to parse the query, then it will fall back on this one.
public String	Returns: The unique identifier of the `ExpressionFactory` getFallbackExpressionFactoryId() Returns the unique identifier of the `ExpressionFactory` to use when the fall back BNF ID is not `null`.
public String	Returns: The identifier used to register this `JPQLQueryBNF` with `AbstractExpression` getId() Returns the unique identifier of this `JPQLQueryBNF`.
public Iterable<String>	Returns: The list of JPQL identifiers that are supported by this BNF getIdentifiers() Retrieves the JPQL identifiers that are supported by this BNF rule.
public boolean	Returns: `true` if the sub-expression to parse might have several logical and/or arithmetic expressions; `false` otherwise handleAggregate() Determines whether the `Expression` handles a collection of sub-expressions that are aggregated by logical or arithmetic operators.
public boolean	Returns: `true` if the sub-expression to parse might have several sub-expressions separated by commas; `false` otherwise handleCollection() Determines whether the `Expression` handles a collection of sub-expressions that are separated by commas.
public boolean	handlesNestedArray()
public boolean	Returns: `true` if this BNF handles parsing a sub-expression; `false` otherwise handleSubExpression() Determines whether this BNF handles parsing a sub-expression, i.e. parsing an expression encapsulated by parenthesis.
public boolean	Returns: `true` if the BNF with the given ID is hasChild(String The unique identifier of the BNF rule to check if it's a child of this one queryBNFId) Determines whether the BNF with the given ID is part of this BNF or not.
public boolean	Returns: `true` if the given word is a JPQL identifier and it is supported by this BNF; `false` otherwise hasIdentifier(String A word that could be a JPQL identifier or anything else word) Determines if this query BNF support the given word, which can be an identifier.
protected void	initialize() Initializes this BNF by registering child `JPQLQueryBNFs` and `ExpressionFactories`.
private void	initialize(String The unique identifier of this BNF rule id) Initializes this `JPQLQueryBNF`.
public boolean	Returns: `false` by default isCompound() Determines whether this BNF has child BNFs registered only to properly parse a query or if the child BNFs are part of the BNF.
public Iterable<JPQLQueryBNF>	Returns: The children BNFs describing this BNF rule. The set excludes BNF rules that are used to complete a BNF, such as the BNF rules defined for BETWEEN since they are required to properly parse the query nonCompoundChildren() Returns the set of all the query BNFs that are part of this BNF.
protected final void	registerChild(String The unique identifier of the BNF rule to add as a child queryBNFId) Registers the unique identifier of the BNF rule as a child of this BNF rule.
protected final void	registerExpressionFactory(String The unique identifier of the `ExpressionFactory` expressionFactoryId) Registers a unique identifier of the `ExpressionFactory` to register with this BNF rule.
public void	setCompound(boolean `true` if this BNF represents a compound BNF and its children are not part of this BNF but only to support compound expression; `false` otherwise compound) Determines whether this BNF has child BNFs registered only to properly parse a query or if the child BNFs are part of the BNF.
pack-priv final void	setExpressionRegistry(ExpressionRegistry The registry for a given JPQL grammar expressionRegistry) Sets the backpointer to the `ExpressionRegistry` with which this `JPQLQueryBNF` was registered.
public void	setFallbackBNFId(String The unique identifier of the `JPQLQueryBNF` to use in the last resort fallbackBNFId) When parsing the query and no `JPQLQueryBNFs` can help to parse the query, then it will fall back on the given one.
public void	setFallbackExpressionFactoryId(String The unique identifier of the `ExpressionFactory` fallbackExpressionFactoryId) Sets the unique identifier of the `ExpressionFactory` to use when the fall back BNF ID is not `null`.
public void	setHandleAggregate(boolean `true` if the sub-expression to parse might have several logical and/or arithmetic expressions; `false` otherwise handleAggregate) Sets whether the `Expression` handles a collection of sub-expressions that are aggregated by logical or arithmetic operators.
public void	setHandleCollection(boolean `true` if the sub-expression to parse might have several sub-expressions separated by commas; `false` otherwise handleCollection) Sets whether the `Expression` handles a collection of sub-expressions that are separated by commas.
public void	setHandleNestedArray(boolean `true` if the expression represented by this BNF can be a nested array; `false` otherwise handleNestedArray) Sets whether this BNF supports nested array or not.
public void	setHandleSubExpression(boolean `true` to let the creation of a sub-expression be created by the fallback `ExpressionFactory` registered with this BNF; `false` otherwise (which is the default value) handleSubExpression) Sets whether this BNF handles parsing a sub-expression, i.e. parsing an expression encapsulated by parenthesis.
public String	toString() Overrides java.lang.Object.toString. Returns a string representation of the object.
protected void	toString(StringBuilder The builder used to add information about this class sb) Adds to the given builder more information about this `JPQLQueryBNF`.

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll wait wait wait

Field Detail

cachedExpressionFactories	back to summary
private Map<String, ExpressionFactory> cachedExpressionFactories Caches the `ExpressionFactory` mapped by their the JPQL identifier registered with those `ExpressionFactory`.

cachedExpressionFactoryIds	back to summary
private String[] cachedExpressionFactoryIds Caches the collection of unique identifiers of the `ExpressionFactory` registered with this BNF rule.

cachedIdentifiers	back to summary
private String[] cachedIdentifiers The list of JPQL identifiers that are known by this BNF rule and its children, they are retrieved by scanning the list of `ExpressionFactory` registered with this BNF rule and its children.

childQueryBNFs	back to summary
private JPQLQueryBNF[] childQueryBNFs Caches the children of this BNF rule (which actually includes this one as well).

children	back to summary
private List<String> children The children BNF of this one.

compound	back to summary
private boolean compound Determines whether this BNF has child BNFs registered only to properly parse a query or if the child BNFs are part of the BNF. An example if a compound BNF is `BetweenExpressionBNF`, it registers a series of children BNFs but they shouldn't be used to determine if they are part of that BNF since the comparator identifiers are.

expressionFactoryIds	back to summary
private List<String> expressionFactoryIds The list of unique identifiers for the `ExpressionFactory` that are registered with this BNF rule.

expressionRegistry	back to summary
private ExpressionRegistry expressionRegistry The `ExpressionRegistry` with which this `JPQLQueryBNF` was registered.

fallbackBNFId	back to summary
private String fallbackBNFId The unique identifier of the `JPQLQueryBNF` to use in the last resort.

fallbackExpressionFactoryId	back to summary
private String fallbackExpressionFactoryId The unique identifier of the `ExpressionFactory` to use when no other factories can be used automatically.

handleAggregate	back to summary
private Boolean handleAggregate Caches the property since any BNF rule is static.

handleCollection	back to summary
private Boolean handleCollection Caches the property since any BNF rule is static.

handleNestedArray	back to summary
private boolean handleNestedArray Determines whether this BNF handles parsing a nested array or not.

handleSubExpression	back to summary
private boolean handleSubExpression This flag can be used to determine if this BNF handles parsing a sub-expression, i.e. an expression encapsulated by parenthesis. See `setHandleSubExpression(boolean)` for more details.

id	back to summary
private String id The unique identifier of this BNF rule.

nonCompoundChildren	back to summary
private JPQLQueryBNF[] nonCompoundChildren Caches the children of this BNF rule (which actually includes this one as well) but do not includes BNF rules that are used for compounding a rule.

nonCompoundFilter	back to summary
private static final Filter<JPQLQueryBNF> nonCompoundFilter Only keep one instance of the `Filter` used when initializing `nonCompoundChildren` JPQLQueryBNF. This should help with performance since the filter won't be created for each `JPQLQueryBNF`.

Constructor Detail

JPQLQueryBNF back to summary

JPQLQueryBNF	back to summary
protected JPQLQueryBNF(String id) Creates a new `JPQLQueryBNF`. Parameters id:String The unique identifier of this BNF rule Exceptions NullPointerException: The given unique identifier cannot be `null`

protected JPQLQueryBNF(String id)

Creates a new JPQLQueryBNF.

Parameters

id:String: The unique identifier of this BNF rule

Exceptions

NullPointerException:: The given unique identifier cannot be null

Method Detail

addChildren back to summary

addChildren	back to summary
private void addChildren(Set<JPQLQueryBNF> queryBNFs, Filter<JPQLQueryBNF> filter) Adds to the given set the child BNF rules and requests them to add their children as long as they have not been traversed already. Parameters queryBNFs:Set<JPQLQueryBNF> The set to add the child BNF rules filter:Filter<JPQLQueryBNF> The `Filter` determines if the children of a given BNF should be added

private void addChildren(Set<JPQLQueryBNF> queryBNFs, Filter<JPQLQueryBNF> filter)

Adds to the given set the child BNF rules and requests them to add their children as long as they have not been traversed already.

Parameters

queryBNFs:Set<JPQLQueryBNF>: The set to add the child BNF rules
filter:Filter<JPQLQueryBNF>: The Filter determines if the children of a given BNF should be added

buildChildren	back to summary
private JPQLQueryBNF[] buildChildren(Filter<JPQLQueryBNF> filter)

buildNonCompoundFilter	back to summary
private static Filter<JPQLQueryBNF> buildNonCompoundFilter()

calculateExpressionFactories	back to summary
private void calculateExpressionFactories()

calculateExpressionFactoryIds	back to summary
private void calculateExpressionFactoryIds(Set<JPQLQueryBNF> queryBNFs, Set<String> factoryIds)

calculateHandleAggregate	back to summary
private boolean calculateHandleAggregate(Set<JPQLQueryBNF> queryBNFs)

calculateHandleCollection	back to summary
private boolean calculateHandleCollection(Set<JPQLQueryBNF> queryBNFs)

children	back to summary
public Iterable<JPQLQueryBNF> children() Returns the set of all the query BNFs that are part of this BNF. The set always include this BNF as well. Returns:Iterable<JPQLQueryBNF> The children BNFs describing this BNF rule

children

back to summary

public Iterable<JPQLQueryBNF> children()

Returns the set of all the query BNFs that are part of this BNF. The set always include this BNF as well.

Returns:Iterable<JPQLQueryBNF>: The children BNFs describing this BNF rule

getChildren	back to summary
private JPQLQueryBNF[] getChildren()

getExpressionFactory back to summary

getExpressionFactory	back to summary
public ExpressionFactory getExpressionFactory(String identifier) Retrieves the `ExpressionFactory` that is associated with the given identifier, if the given string is indeed a JPQL identifier. Parameters identifier:String The JPQL identifier (in theory) that is used to retrieve the factory responsible to parse a portion of the query starting with that identifier Returns:ExpressionFactory The `ExpressionFactory` responsible to parse a portion of the query starting with the given identifier; `null` if nothing was registered for it

public ExpressionFactory getExpressionFactory(String identifier)

Retrieves the ExpressionFactory that is associated with the given identifier, if the given string is indeed a JPQL identifier.

Parameters

identifier:String: The JPQL identifier (in theory) that is used to retrieve the factory responsible to parse a portion of the query starting with that identifier

Returns:ExpressionFactory

The ExpressionFactory responsible to parse a portion of the query starting with the given identifier; null if nothing was registered for it

getExpressionFactoryIds back to summary

getExpressionFactoryIds	back to summary
public Iterable<String> getExpressionFactoryIds() Returns the unique identifiers of the `ExpressionFactory` handled by this BNF rule, which includes those from the children as well. Returns:Iterable<String> The list of unique identifiers of the `ExpressionFactory` registered with this BNF rule and with its children

public Iterable<String> getExpressionFactoryIds()

Returns the unique identifiers of the ExpressionFactory handled by this BNF rule, which includes those from the children as well.

Returns:Iterable<String>: The list of unique identifiers of the ExpressionFactory registered with this BNF rule and with its children

getExpressionFactoryIdsImp	back to summary
private String[] getExpressionFactoryIdsImp()

getExpressionRegistry back to summary

getExpressionRegistry	back to summary
public ExpressionRegistry getExpressionRegistry() Returns the registry containing the `JPQLQueryBNFs` and the `ExpressionFactories` that are used to properly parse a JPQL query. Returns:ExpressionRegistry The registry containing the information related to the JPQL grammar

public ExpressionRegistry getExpressionRegistry()

Returns the registry containing the JPQLQueryBNFs and the ExpressionFactories that are used to properly parse a JPQL query.

Returns:ExpressionRegistry: The registry containing the information related to the JPQL grammar

getFallbackBNFId back to summary

getFallbackBNFId	back to summary
public String getFallbackBNFId() When parsing the query and no `JPQLQueryBNFs` can help to parse the query, then it will fall back on this one. Returns:String The unique identifier of the `JPQLQueryBNF` to use in the last resort

public String getFallbackBNFId()

When parsing the query and no JPQLQueryBNFs can help to parse the query, then it will fall back on this one.

Returns:String: The unique identifier of the JPQLQueryBNF to use in the last resort

getFallbackExpressionFactoryId back to summary

getFallbackExpressionFactoryId	back to summary
public String getFallbackExpressionFactoryId() Returns the unique identifier of the `ExpressionFactory` to use when the fall back BNF ID is not `null`. This will be used to parse a portion of the query when the registered `expression factories` cannot parse it. Note This method is only called if `getFallbackBNFId()` does not return `null`. Returns:String The unique identifier of the `ExpressionFactory`

public String getFallbackExpressionFactoryId()

Returns the unique identifier of the ExpressionFactory to use when the fall back BNF ID is not null. This will be used to parse a portion of the query when the registered expression factories cannot parse it.

Note

This method is only called if getFallbackBNFId() does not return null.

Returns:String: The unique identifier of the ExpressionFactory

getId back to summary

getId	back to summary
public String getId() Returns the unique identifier of this `JPQLQueryBNF`. Returns:String The identifier used to register this `JPQLQueryBNF` with `AbstractExpression`

public String getId()

Returns the unique identifier of this JPQLQueryBNF.

Returns:String: The identifier used to register this JPQLQueryBNF with AbstractExpression

getIdentifiers back to summary

getIdentifiers	back to summary
public Iterable<String> getIdentifiers() Retrieves the JPQL identifiers that are supported by this BNF rule. The JPQL identifiers are retrieved by scanning the `ExpressionFactory` registered with this BNF rule and the child BNF rules. Returns:Iterable<String> The list of JPQL identifiers that are supported by this BNF

public Iterable<String> getIdentifiers()

Retrieves the JPQL identifiers that are supported by this BNF rule. The JPQL identifiers are retrieved by scanning the ExpressionFactory registered with this BNF rule and the child BNF rules.

Returns:Iterable<String>: The list of JPQL identifiers that are supported by this BNF

handleAggregate back to summary

handleAggregate	back to summary
public boolean handleAggregate() Determines whether the `Expression` handles a collection of sub-expressions that are aggregated by logical or arithmetic operators. Returns:boolean `true` if the sub-expression to parse might have several logical and/or arithmetic expressions; `false` otherwise

public boolean handleAggregate()

Determines whether the Expression handles a collection of sub-expressions that are aggregated by logical or arithmetic operators.

Returns:boolean: true if the sub-expression to parse might have several logical and/or arithmetic expressions; false otherwise

handleCollection back to summary

handleCollection	back to summary
public boolean handleCollection() Determines whether the `Expression` handles a collection of sub-expressions that are separated by commas. Returns:boolean `true` if the sub-expression to parse might have several sub-expressions separated by commas; `false` otherwise

public boolean handleCollection()

Determines whether the Expression handles a collection of sub-expressions that are separated by commas.

Returns:boolean: true if the sub-expression to parse might have several sub-expressions separated by commas; false otherwise

handlesNestedArray	back to summary
public boolean handlesNestedArray() Since 2.5

handleSubExpression back to summary

handleSubExpression	back to summary
public boolean handleSubExpression() Determines whether this BNF handles parsing a sub-expression, i.e. parsing an expression encapsulated by parenthesis. See `setHandleSubExpression(boolean)` for more details. Returns:boolean `true` if this BNF handles parsing a sub-expression; `false` otherwise

public boolean handleSubExpression()

Determines whether this BNF handles parsing a sub-expression, i.e. parsing an expression encapsulated by parenthesis. See setHandleSubExpression(boolean) for more details.

Returns:boolean: true if this BNF handles parsing a sub-expression; false otherwise

hasChild back to summary

hasChild	back to summary
public boolean hasChild(String queryBNFId) Determines whether the BNF with the given ID is part of this BNF or not. Parameters queryBNFId:String The unique identifier of the BNF rule to check if it's a child of this one Returns:boolean `true` if the BNF with the given ID is Since 2.5.1

public boolean hasChild(String queryBNFId)

Determines whether the BNF with the given ID is part of this BNF or not.

Parameters

queryBNFId:String: The unique identifier of the BNF rule to check if it's a child of this one

Returns:boolean

true if the BNF with the given ID is

Since

2.5.1

hasIdentifier back to summary

hasIdentifier	back to summary
public boolean hasIdentifier(String word) Determines if this query BNF support the given word, which can be an identifier. Parameters word:String A word that could be a JPQL identifier or anything else Returns:boolean `true` if the given word is a JPQL identifier and it is supported by this BNF; `false` otherwise

public boolean hasIdentifier(String word)

Determines if this query BNF support the given word, which can be an identifier.

Parameters

word:String: A word that could be a JPQL identifier or anything else

Returns:boolean

true if the given word is a JPQL identifier and it is supported by this BNF; false otherwise

initialize	back to summary
protected void initialize() Initializes this BNF by registering child `JPQLQueryBNFs` and `ExpressionFactories`.

initialize back to summary

initialize	back to summary
private void initialize(String id) Initializes this `JPQLQueryBNF`. Parameters id:String The unique identifier of this BNF rule Exceptions NullPointerException: The given unique identifier cannot be `null`

private void initialize(String id)

Initializes this JPQLQueryBNF.

Parameters

id:String: The unique identifier of this BNF rule

Exceptions

NullPointerException:: The given unique identifier cannot be null

isCompound back to summary

isCompound	back to summary
public boolean isCompound() Determines whether this BNF has child BNFs registered only to properly parse a query or if the child BNFs are part of the BNF. An example if a compound BNF is `BetweenExpressionBNF`, it registers a series of children BNFs but they shouldn't be used to determine if they are part of that BNF since the comparator identifiers are. Returns:boolean `false` by default

public boolean isCompound()

Determines whether this BNF has child BNFs registered only to properly parse a query or if the child BNFs are part of the BNF. An example if a compound BNF is BetweenExpressionBNF, it registers a series of children BNFs but they shouldn't be used to determine if they are part of that BNF since the comparator identifiers are.

Returns:boolean: false by default

nonCompoundChildren	back to summary
public Iterable<JPQLQueryBNF> nonCompoundChildren() Returns the set of all the query BNFs that are part of this BNF. The set always include this BNF as well. Returns:Iterable<JPQLQueryBNF> The children BNFs describing this BNF rule. The set excludes BNF rules that are used to complete a BNF, such as the BNF rules defined for BETWEEN since they are required to properly parse the query

nonCompoundChildren

back to summary

public Iterable<JPQLQueryBNF> nonCompoundChildren()

Returns the set of all the query BNFs that are part of this BNF. The set always include this BNF as well.

Returns:Iterable<JPQLQueryBNF>: The children BNFs describing this BNF rule. The set excludes BNF rules that are used to complete a BNF, such as the BNF rules defined for BETWEEN since they are required to properly parse the query

registerChild back to summary

registerChild	back to summary
protected final void registerChild(String queryBNFId) Registers the unique identifier of the BNF rule as a child of this BNF rule. Parameters queryBNFId:String The unique identifier of the BNF rule to add as a child Exceptions NullPointerException: The `queryBNFId` cannot be `null`

protected final void registerChild(String queryBNFId)

Registers the unique identifier of the BNF rule as a child of this BNF rule.

Parameters

queryBNFId:String: The unique identifier of the BNF rule to add as a child

Exceptions

NullPointerException:: The queryBNFId cannot be null

registerExpressionFactory back to summary

registerExpressionFactory	back to summary
protected final void registerExpressionFactory(String expressionFactoryId) Registers a unique identifier of the `ExpressionFactory` to register with this BNF rule. Parameters expressionFactoryId:String The unique identifier of the `ExpressionFactory` Exceptions NullPointerException: The `expressionFactoryId` cannot be `null`

protected final void registerExpressionFactory(String expressionFactoryId)

Registers a unique identifier of the ExpressionFactory to register with this BNF rule.

Parameters

expressionFactoryId:String: The unique identifier of the ExpressionFactory

Exceptions

NullPointerException:: The expressionFactoryId cannot be null

setCompound back to summary

public void setCompound(boolean compound)

Parameters

compound:boolean: true if this BNF represents a compound BNF and its children are not part of this BNF but only to support compound expression; false otherwise

setExpressionRegistry back to summary

pack-priv final void setExpressionRegistry(ExpressionRegistry expressionRegistry)

Sets the backpointer to the ExpressionRegistry with which this JPQLQueryBNF was registered.

Parameters

expressionRegistry:ExpressionRegistry: The registry for a given JPQL grammar

setFallbackBNFId back to summary

public void setFallbackBNFId(String fallbackBNFId)

When parsing the query and no JPQLQueryBNFs can help to parse the query, then it will fall back on the given one.

Parameters

fallbackBNFId:String: The unique identifier of the JPQLQueryBNF to use in the last resort

setFallbackExpressionFactoryId back to summary

public void setFallbackExpressionFactoryId(String fallbackExpressionFactoryId)

Sets the unique identifier of the ExpressionFactory to use when the fall back BNF ID is not null. This will be used to parse a portion of the query when the registered expression factories cannot parse it.

Note

This method is only called if getFallbackBNFId() does not return null.

Parameters

fallbackExpressionFactoryId:String: The unique identifier of the ExpressionFactory

setHandleAggregate back to summary

public void setHandleAggregate(boolean handleAggregate)

Sets whether the Expression handles a collection of sub-expressions that are aggregated by logical or arithmetic operators.

Parameters

handleAggregate:boolean: true if the sub-expression to parse might have several logical and/or arithmetic expressions; false otherwise

setHandleCollection back to summary

public void setHandleCollection(boolean handleCollection)

Sets whether the Expression handles a collection of sub-expressions that are separated by commas.

Parameters

handleCollection:boolean: true if the sub-expression to parse might have several sub-expressions separated by commas; false otherwise

setHandleNestedArray back to summary

public void setHandleNestedArray(boolean handleNestedArray)

Sets whether this BNF supports nested array or not. A nested array is a sub-expression with its child being a collection expression: (item_1, item_2, ..., item_n).

Parameters

handleNestedArray:boolean: true if the expression represented by this BNF can be a nested array; false otherwise

Since

2.5

setHandleSubExpression back to summary

public void setHandleSubExpression(boolean handleSubExpression)

Sets whether this BNF handles parsing a sub-expression, i.e. parsing an expression encapsulated by parenthesis. Which in fact would be handled by the fallback ExpressionFactory. The default behavior is to not handle it.

A good example for using this option is when an Expression cannot use any ExpressionFactory for creating a child object, parsing will use the fallback ExpressionFactory, if one was specified. So when this is set to true, the fallback ExpressionFactory will be immediately invoked.

Let's say we want to parse "SELECT e FROM (SELECT a FROM Address a) e", FromClause cannot use a factory for parsing the entity name (that's what usually the FROM clause has) so it uses the fallback factory to create IdentificationVariableDeclaration. Then IdentificationVariableDeclaration also cannot use any factory to create its child object so it uses the fallback factory to create RangeVariableDeclaration. By changing the status of for handling the sub-expression for the BNFs for those objects, then a subquery can be created by RangeVariableDeclaration.

FromClause
 |- IdentificationVariableDeclaration
      |- RangeVariableDeclaration
           |- SubExpression(subquery)

In order to get this working, the following would have to be done into the grammar:

 public class MyJPQLGrammar extends AbstractJPQLGrammar {
  @Override
  protected void initializeBNFs() {
     setHandleSubExpression(InternalFromClauseBNF.ID,                true);
     setHandleSubExpression(InternalSimpleFromClauseBNF.ID,          true);
     setHandleSubExpression(IdentificationVariableDeclarationBNF.ID, true);
     setHandleSubExpression(RangeVariableDeclarationBNF.ID,          true);
  }
}

Parameters

handleSubExpression:boolean: true to let the creation of a sub-expression be created by the fallback ExpressionFactory registered with this BNF; false otherwise (which is the default value)

toString

back to summary

public String toString()

Overrides java.lang.Object.toString.

Doc from java.lang.Object.toString.

Returns a string representation of the object.

Returns:String

a string representation of the object.

Annotations