EJB query: BNF syntax

The Backus-Naur Form (BNF) is one of the most commonly used notations for specifying the syntax of programming languages or command sets. This article lists the syntax for Enterprise JavaBeans (EJB) query language.

EJB QL ::= [select_clause] from_clause [where_clause] [order_by_clause]
 DYNAMIC EJB QL := query_expression  [order_by_clause]    query_expression := query_term [UNION [ALL] query_term]*
 query_term :=  {select_clause_dynamic  from_clause  [where_clause]   [group_by_clause] [having_clause] } | (query_expression) }  [order_by_clause]
 
from_clause::=FROM identification_variable_declaration                 [, {identification_variable_declaration | collection_member_declaration } ]*
 identification_variable_declaration::=collection_member_declaration |
       range_variable_declaration [join]*
 join :=  [ { LEFT [OUTER] | INNER  }]  JOIN  {collection_valued_path_expression | single_valued_path_expression}
 [AS] identifier  collection_member_declaration::=
       IN ( collection_valued_path_expression ) [AS] identifier  range_variable_declaration::=abstract_schema_name [AS] identifier  single_valued_path_expression ::=
       {single_valued_navigation | identification_variable}. ( cmp_field |     method  |  cmp_field.value_object_attribute |  cmp_field.value_object_method )
          | single_valued_navigation
 single_valued_navigation::=
       identification_variable.[  single_valued_cmr_field.  ]*              single_valued_cmr_field    collection_valued_path_expression ::=
       identification_variable.[  single_valued_cmr_field.  ]*             collection_valued_cmr_field
 select_clause::= SELECT { ALL | DISTINCT }  {single_valued_path_expression |
                         identification_variable |  OBJECT ( identification_variable) |
        aggregate_functions }   select_clause_dynamic ::= SELECT { ALL | DISTINCT }  [ selection , ]*  selection   selection  ::= { expression  |  subselect }  [[AS] id ]
 order_by_clause::= ORDER BY [ {single_valued_path_expression | integer}  [ASC|DESC],]*
      {single_valued_path_expression | integer}[ASC|DESC]
 where_clause::= WHERE conditional_expression
 conditional_expression ::= conditional_term |                             conditional_expression OR conditional_term
conditional_term ::= conditional_factor |                       conditional_term AND conditional_factor
conditional_factor ::= [NOT] conditional_primary
conditional_primary::=simple_cond_expression | (conditional_expression)
 simple_cond_expression ::= comparison_expression | between_expression |         like_expression | in_expression | null_comparison_expression |
       empty_collection_comparison_expression | quantified_expression |
       exists_expression | is_of_type_expression  |  collection_member_expression
 between_expression ::= expression [NOT] BETWEEN expression AND expression  in_expression ::= single_valued_path_expression [NOT] IN             { (subselect) |  ( [ atom ,]* atom )  }
 atom = { string-literal | numeric-constant | input-parameter }
                 like_expression ::= expression [NOT] LIKE                  {string_literal | input_parameter}                  [ESCAPE {string_literal | input_parameter}]
 null_comparison_expression ::=         single_valued_path_expression IS [ NOT ] NULL   empty_collection_comparison_expression ::=
       collection_valued_path_expression IS [NOT] EMPTY
 collection_member_expression  ::=
       { single_valued_path_expression |  input_paramter }  [ NOT ] MEMBER [ OF ]           collection_valued_path_expression
 quantified_expression ::=
       expression comparison_operator {SOME | ANY | ALL} (subselect)
 exists_expression ::= EXISTS {collection_valued_path_expression |  (subselect)}
 subselect ::= SELECT [{ ALL | DISTINCT }]  expression  from_clause [where_clause]         [group_by_clause] [having_clause]
 group_by_clause::= GROUP BY [single_valued_path_expression,]*
                    single_valued_path_expression
 having_clause ::= HAVING conditional_expression
 
is_of_type_expression ::= identifier  IS OF TYPE
            ([[ONLY] abstract_schema_name,]* [ONLY] abstract_schema_name)    comparison_expression ::=  expression   comparison_operator { expression |  ( subquery ) }
 comparison_operator ::=    = | > | >= | < | <= | <>   method ::=  method_name( [[expression , ]* expression ] )      expression ::= term |   expression {+|-} term   term ::=  factor |  term {*|/} factor
 factor ::= {+|-} primary  primary ::= single_valued_path_expression | literal |
       ( expression ) |  input_parameter | functions | aggregate_functions
 aggregate_functions :=         AVG([ALL|DISTINCT] expression) |
       COUNT({[ALL|DISTINCT] expression | * | identification_variable }) |
       MAX([ALL|DISTINCT] expression) |
       MIN([ALL|DISTINCT] expression) |
       SUM([ALL|DISTINCT] expression) |
 functions ::=          ABS(expression) |          BIGINT(expression) |
        CHAR({expression [,{ISO|USA|EUR|JIS}] )  |
        CONCAT (expression , expression ) |
        DATE(expression) |
        DAY({expression ) |
        DAYS( expression) |
        DECIMAL( expression [,integer[,integer]])
        DIGITS( expression) |
        DOUBLE( expression ) |
        FLOAT( expression) |
        HOUR ( expression ) |
        INTEGER( expression ) |
        LCASE ( expression) |
        LENGTH(expression) |
        LOCATE( expression, expression [, expression] ) |
        MICROSECOND( expression ) |
        MINUTE ( expression ) |
        MOD ( expression , expression ) |
        MONTH( expression ) |
        REAL( expression) |
        SECOND( expression ) |
        SMALLINT( expression )  |
        SQRT (  expression) |
        SUBSTRING( expression, expression[, expression]) |
        TIME( expression ) |
        TIMESTAMP( expression ) |
        UCASE ( expression) |
        YEAR( expression )
 xrel := XREL identification_variable . { single_valued_cmr_field | collection_valued_cmr_field }
             [ , identification_variable . { single_valued_cmr_field | collection_valued_cmr_field } ]*

EJB Query Restrictions and Exceptions

EJB-QL Limitation with CMP Inheritance and FROM Clause Joins Usage

The EJB-QL parser has been found to improperly generate SQL with queries that match the following cumulative criteria:

• The EJB-QL query contains a join in the FROM clause (For example, FROM Entity a, IN (a.b.c.d) dGroup).

• The EJB-QL query contains a predicate that navigates across an inner path element also associated with the FROM clause join (For example, WHERE a.b.g.id = :?1).

• One or more of the non-leaf path entities in the FROM join utilize entity type inheritance (For example, b extends b_super).

• The entity addressed by the common path element in the predicate also utilizes entity type inheritance (For example, g extends g_super).

The EJB Query processor will emit a WQRY1113E warning, which can indicate that this scenario has been encountered.

Related concepts

EJB query language

Related tasks

Use EJB query