Examples of org.eclipse.persistence.jpa.internal.jpql.parser.Expression

Package org.eclipse.persistence.jpa.internal.jpql.parser

Examples of org.eclipse.persistence.jpa.internal.jpql.parser.Expression

org.eclipse.persistence.jpa.internal.jpql.parser.Expression

rg/en/jsr/detail?id=317">JSR 317: Java™ Persistence 2.0

The BNF for the Java Persistence query language, version 2.0:

 QL_statement ::= select_statement | update_statement | delete_statement select_statement ::= select_clause from_clause [where_clause] [groupby_clause] [having_clause] [orderby_clause] update_statement ::= update_clause [where_clause] delete_statement ::= delete_clause [where_clause] from_clause ::= FROM identification_variable_declaration {, {identification_variable_declaration | collection_member_declaration}} identification_variable_declaration ::= range_variable_declaration { join | fetch_join } range_variable_declaration ::= entity_name [AS] identification_variable join ::= join_spec join_association_path_expression [AS] identification_variable fetch_join ::= join_spec FETCH join_association_path_expression join_spec ::= [ LEFT [OUTER] | INNER ] JOIN join_association_path_expression ::= join_collection_valued_path_expression | join_single_valued_path_expression join_collection_valued_path_expression ::= identification_variable.{single_valued_embeddable_object_field.}*collection_valued_field join_single_valued_path_expression ::= identification_variable.{single_valued_embeddable_object_field.}*single_valued_object_field collection_member_declaration ::= IN (collection_valued_path_expression) [AS] identification_variable qualified_identification_variable ::= KEY(identification_variable) | VALUE(identification_variable) | ENTRY(identification_variable) single_valued_path_expression ::= qualified_identification_variable | state_field_path_expression | single_valued_object_path_expression general_identification_variable ::= identification_variable | KEY(identification_variable) | VALUE(identification_variable) state_field_path_expression ::= general_identification_variable.{single_valued_object_field.}*state_field single_valued_object_path_expression ::= general_identification_variable.{single_valued_object_field.}*single_valued_object_field collection_valued_path_expression ::= general_identification_variable.{single_valued_object_field.}*collection_valued_field update_clause ::= UPDATE entity_name [[AS] identification_variable] SET update_item {, update_item} update_item ::= [identification_variable.]{state_field | single_valued_object_field} = new_value new_value ::= scalar_expression | simple_entity_expression | NULL delete_clause ::= DELETE FROM entity_name [[AS] identification_variable] select_clause ::= SELECT [DISTINCT] select_item {, select_item} select_item ::= select_expression [[AS] result_variable] select_expression ::= single_valued_path_expression | scalar_expression | aggregate_expression | identification_variable | OBJECT(identification_variable) | constructor_expression constructor_expression ::= NEW constructor_name ( constructor_item {, constructor_item}* ) constructor_item ::= single_valued_path_expression | scalar_expression | aggregate_expression | identification_variable aggregate_expression ::= { AVG | MAX | MIN | SUM } ([DISTINCT] state_field_path_expression) | COUNT ([DISTINCT] identification_variable | state_field_path_expression | single_valued_object_path_expression) where_clause ::= WHERE conditional_expression groupby_clause ::= GROUP BY groupby_item {, groupby_item} groupby_item ::= single_valued_path_expression | identification_variable having_clause ::= HAVING conditional_expression orderby_clause ::= ORDER BY orderby_item {, orderby_item} orderby_item ::= state_field_path_expression | result_variable [ ASC | DESC ] subquery ::= simple_select_clause subquery_from_clause [where_clause] [groupby_clause] [having_clause] subquery_from_clause ::= FROM subselect_identification_variable_declaration {, subselect_identification_variable_declaration | collection_member_declaration} subselect_identification_variable_declaration ::= identification_variable_declaration | derived_path_expression [AS] identification_variable {join}* | derived_collection_member_declaration derived_path_expression ::= superquery_identification_variable.{single_valued_object_field.}*collection_valued_field | superquery_identification_variable.{single_valued_object_field.}*single_valued_object_field derived_collection_member_declaration ::= IN superquery_identification_variable.{single_valued_object_field.}*collection_valued_field simple_select_clause ::= SELECT [DISTINCT] simple_select_expression simple_select_expression ::= single_valued_path_expression | scalar_expression | aggregate_expression | identification_variable scalar_expression ::= simple_arithmetic_expression | string_primary | enum_primary | datetime_primary | boolean_primary | case_expression | entity_type_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 | in_expression | like_expression | null_comparison_expression | empty_collection_comparison_expression | collection_member_expression | exists_expression between_expression ::= arithmetic_expression [NOT] BETWEEN arithmetic_expression AND arithmetic_expression | string_expression [NOT] BETWEEN string_expression AND string_expression | datetime_expression [NOT] BETWEEN datetime_expression AND datetime_expression in_expression ::= {state_field_path_expression | type_discriminator} [NOT] IN { ( in_item {, in_item}* ) | (subquery) | collection_valued_input_parameter } in_item ::= literal | single_valued_input_parameter like_expression ::= string_expression [NOT] LIKE pattern_value [ESCAPE escape_character] null_comparison_expression ::= {single_valued_path_expression | input_parameter} IS [NOT] NULL empty_collection_comparison_expression ::= collection_valued_path_expression IS [NOT] EMPTY collection_member_expression ::= entity_or_value_expression [NOT] MEMBER [OF] collection_valued_path_expression entity_or_value_expression ::= single_valued_object_path_expression | state_field_path_expression | simple_entity_or_value_expression simple_entity_or_value_expression ::= identification_variable | input_parameter | literal exists_expression ::= [NOT] EXISTS (subquery) all_or_any_expression ::= { ALL | ANY | SOME} (subquery) comparison_expression ::= string_expression comparison_operator {string_expression | all_or_any_expression} | boolean_expression { = | <> } {boolean_expression | all_or_any_expression} | enum_expression { =|<> } {enum_expression | all_or_any_expression} | datetime_expression comparison_operator {datetime_expression | all_or_any_expression} | entity_expression { = | <> } {entity_expression | all_or_any_expression} | arithmetic_expression comparison_operator {arithmetic_expression | all_or_any_expression} | entity_type_expression { = | <> } entity_type_expression} comparison_operator ::= = | > | >= | < | <= | <> arithmetic_expression ::= simple_arithmetic_expression | (subquery) simple_arithmetic_expression ::= arithmetic_term | simple_arithmetic_expression { + | - } arithmetic_term arithmetic_term ::= arithmetic_factor | arithmetic_term { * | / } arithmetic_factor arithmetic_factor ::= [{ + | - }] arithmetic_primary arithmetic_primary ::= state_field_path_expression | numeric_literal | (simple_arithmetic_expression) | input_parameter | functions_returning_numerics | aggregate_expression | case_expression string_expression ::= string_primary | (subquery) string_primary ::= state_field_path_expression | string_literal | input_parameter | functions_returning_strings | aggregate_expression | case_expression datetime_primary ::= state_field_path_expression | input_parameter | functions_returning_datetime | aggregate_expression | case_expression | date_time_timestamp_literal datetime_expression ::= datetime_primary | (subquery) boolean_expression ::= boolean_primary | (subquery) boolean_primary ::= state_field_path_expression | boolean_literal | input_parameter | case_expression enum_expression ::= enum_primary | (subquery) enum_primary ::= state_field_path_expression | enum_literal | input_parameter | case_expression entity_expression ::= single_valued_object_path_expression | simple_entity_expression simple_entity_expression ::= identification_variable | input_parameter entity_type_expression ::= type_discriminator | entity_type_literal | input_parameter type_discriminator ::= TYPE(identification_variable | single_valued_object_path_expression | input_parameter) functions_returning_numerics ::= LENGTH(string_primary) | LOCATE(string_primary, string_primary[, simple_arithmetic_expression]) | ABS(simple_arithmetic_expression) | SQRT(simple_arithmetic_expression) | MOD(simple_arithmetic_expression, simple_arithmetic_expression) | SIZE(collection_valued_path_expression) | INDEX(identification_variable) functions_returning_datetime ::= CURRENT_DATE | CURRENT_TIME | CURRENT_TIMESTAMP | literalTemporal functions_returning_strings ::= CONCAT(string_primary, string_primary {, string_primary}*) | SUBSTRING(string_primary, simple_arithmetic_expression [, simple_arithmetic_expression]) | TRIM([[trim_specification] [trim_character] FROM] string_primary) | LOWER(string_primary) | UPPER(string_primary) trim_specification ::= LEADING | TRAILING | BOTH trim_character ::= string_literal | input_parameter case_expression ::= general_case_expression | simple_case_expression | coalesce_expression | nullif_expression general_case_expression ::= CASE when_clause {when_clause}* ELSE scalar_expression END when_clause ::= WHEN conditional_expression THEN scalar_expression simple_case_expression ::= CASE case_operand simple_when_clause {simple_when_clause}* ELSE scalar_expression END case_operand ::= state_field_path_expression | type_discriminator simple_when_clause ::= WHEN scalar_expression THEN scalar_expression coalesce_expression ::= COALESCE(scalar_expression {, scalar_expression}+) nullif_expression ::= NULLIF(scalar_expression, scalar_expression) boolean_literal ::= TRUE | FALSE string_literal ::= 'string' enum_literal ::= {package_name.}*EnumType.CONSTANT literalTemporal ::= date_literal | TIME_LITERAL | TIMESTAMP_LITERAL date_literal ::= "{" "'d'" (' ' | '\t')+ '\'' DATE_STRING '\'' (' ' | '\t')* "}" TIME_LITERAL ::= "{" "'t'" (' ' | '\t')+ '\'' TIME_STRING '\'' (' ' | '\t')* "}" TIMESTAMP_LITERAL ::= "{" ('ts') (' ' | '\t')+ '\'' DATE_STRING ' ' TIME_STRING '\'' (' ' | '\t')* "}" DATE_STRING ::= '0'..'9' '0'..'9' '0'..'9' '0'..'9' '-' '0'..'9' '0'..'9' '-' '0'..'9' '0'..'9' TIME_STRING ::= '0'..'9' ('0'..'9')? ':' '0'..'9' '0'..'9' ':' '0'..'9' '0'..'9' '.' '0'..'9'

The following BNFs is the EclipseLink's extension over the standard JPQL BNF.

join ::= join_spec { join_association_path_expression | join_treat_association_path_expression } [AS] identification_variable join_treat_association_path_expression ::= TREAT(join_association_path_expression AS entity_type_literal) functions_returning_strings ::= ... | func_expression functions_returning_numerics ::= ... | func_expression functions_returning_datetime ::= ... | func_expression func_expression ::= FUNC (func_name {, func_item}*) func_item ::= scalar_expression (NOT SURE) orderby_item ::= state_field_path_expression | result_variable | scalar_expression [ ASC | DESC ] groupby_item ::= single_valued_path_expression | identification_variable | scalar_expression aggregate_expression ::= { AVG | MAX | MIN | SUM | COUNT } ([DISTINCT] scalar_expression) in_item ::= literal | single_valued_input_parameter | scalar_expression

@version 2.3 @since 2.3 @author Pascal Filion

      addProblem(expression, startPosition, endPosition, TrimExpression_InvalidExpression);
    }


    // Invalid trim character
    if (expression.hasTrimCharacter()) {
      Expression trimCharacter = expression.getTrimCharacter();


      // Make sure it's not an input parameter
      String inputParameter = queryContext.literal(trimCharacter, LiteralType.INPUT_PARAMETER);


      if (ExpressionTools.stringIsEmpty(inputParameter)) {

View Full Code Here


    private void validateSeparation(CollectionExpression expression) {


      for (int index = 0, count = expression.childrenSize(); index + 1 < count; index++) {


        Expression expression1 = expression.getChild(index);


        if (isNull(expression1)) {
          int startPosition = position(expression1);
          int endPosition   = startPosition;


          addProblem(
            expression,
            startPosition,
            endPosition,
            CollectionExpression_MissingExpression,
            String.valueOf(index + 1)
          );
        }


        if (!validateSeparator(expression, index)) {
          Expression expression2 = expression.getChild(index + 1);


          int startPosition = position(expression1) + length(expression1);
          int endPosition   = position(expression2);


          // The space is part of the child expression, move backward
          if (!expression.hasSpace(index)) {
            startPosition--;
          }


          if (!validateOnly) {
            addProblem(
              expression,
              startPosition,
              endPosition,
              wrongSeparatorProblemKey,
              expression1.toParsedText(),
              expression2.toParsedText()
            );
          }
        }
      }
    }

View Full Code Here

   * {@inheritDoc}
   */
  @Override
  public void visit(LikeExpression expression) {


    Expression patternValue     = expression.getPatternValue();
    Expression stringExpression = expression.getStringExpression();
    Expression escapeCharacter  = expression.getEscapeCharacter();


    if (escapeCharacter == inputParameter) {
      this.type = Character.class;
    }
    else if (patternValue.isAncestor(inputParameter)) {

View Full Code Here

    expression.getStateFieldPathExpression().accept(this);
  }


  private void visitCompoundExpression(CompoundExpression expression) {


    Expression leftExpression  = expression.getLeftExpression();
    Expression rightExpression = expression.getRightExpression();


    // Now traverse the other side to find its return type
    if (leftExpression.isAncestor(inputParameter)) {
      if (currentExpression == null) {
        currentExpression = expression;
        rightExpression.accept(this);
        currentExpression = null;
      }
      else {
        type = null;
        ignoreType = true;
        expression = null;
      }
    }
    // Now traverse the other side to find its return type
    else if (rightExpression.isAncestor(inputParameter)) {
      if (currentExpression == null) {
        currentExpression = expression;
        leftExpression.accept(this);
        currentExpression = null;
      }

View Full Code Here

  /**
   * {@inheritDoc}
   */
  public void visit(SelectClause expression) {


    Expression selectExpression = expression.getSelectExpression();


    // visit(CollectionExpression) iterates through the children but for a
    // SELECT clause, a CollectionExpression means the result type is Object[]
    CollectionExpression collectionExpression = collectionExpression(selectExpression);


    if (collectionExpression != null) {
      resolver = buildClassResolver(Object[].class);
    }
    else {
      selectExpression.accept(this);
    }
  }

View Full Code Here


      addProblem(expression, startPosition, endPosition, missingConditionalExpressionMessageKey);
    }
    // Invalid conditional expression
    else {
      Expression conditionalExpression = expression.getConditionalExpression();


      if (!isValid(conditionalExpression, ConditionalExpressionBNF.ID)) {
        int startPosition = position(conditionalExpression);
        int endPosition   = startPosition + length(conditionalExpression);
        addProblem(expression, startPosition, endPosition, invalidConditionalExpressionMessageKey);

View Full Code Here


    // More than one entity abstract schema type is declared
    CollectionExpression collectionExpression = collectionExpression(expression.getRangeVariableDeclaration());


    if (collectionExpression != null) {
      Expression firstChild = collectionExpression.getChild(0);
      int startPosition = position(firstChild) + length(firstChild);
      int endPosition = position(collectionExpression) + length(collectionExpression);
      boolean malformed = false;


      for (int index = collectionExpression.childrenSize() - 1; --index >= 0; ) {

View Full Code Here

      int endPosition   = startPosition;
      addProblem(expression, startPosition, endPosition, InExpression_MissingExpression);
    }
    // Make sure it's a valid expression
    else {
      Expression pathExpression = expression.getExpression();


      if (!isValid(pathExpression, StateFieldPathExpressionBNF.ID) &&
          !isValid(pathExpression, TypeExpressionBNF.ID)) {


        int startPosition = position(expression);

View Full Code Here

        startPosition++;
      }


      // Validate the escape character
      if (expression.hasEscapeCharacter()) {
         Expression escapeCharacter = expression.getEscapeCharacter();
         int endPosition = startPosition + length(escapeCharacter);


         // Check for a string literal (single quoted character)
         String character = queryContext.literal(escapeCharacter, LiteralType.STRING_LITERAL);


         if (character.length() > 0) {
           character = ExpressionTools.unquote(character);


           if (character.length() != 1) {
             addProblem(
               expression,
               startPosition,
               endPosition,
               LikeExpression_InvalidEscapeCharacter,
               escapeCharacter.toParsedText()
             );
           }
         }
         else {
           // Check for an input parameter
           character = queryContext.literal(escapeCharacter, LiteralType.INPUT_PARAMETER);


           if (character.length() == 0) {
             addProblem(
              expression,
              startPosition,
              endPosition,
              LikeExpression_InvalidEscapeCharacter,
              escapeCharacter.toParsedText()
            );
           }
         }
       }
       else {

View Full Code Here

  @Override
  public void visit(SimpleSelectClause expression) {


    // Select expression cannot be a collection
    if (expression.hasSelectExpression()) {
      Expression selectExpression = expression.getSelectExpression();


      if (collectionExpression(selectExpression) != null) {
        addProblem(
          selectExpression,
          SimpleSelectClause_NotSingleExpression,
          selectExpression.toParsedText()
        );
      }


      super.visit(expression);
    }

View Full Code Here

0 1 2 3 4 5 6

TOP

Related Classes of org.eclipse.persistence.jpa.internal.jpql.parser.Expression

org.eclipse.persistence.jpa.internal.jpql.ContentAssistVisitor

org.eclipse.persistence.jpa.internal.jpql.DeclarationResolver$DeclarationVisitor

org.eclipse.persistence.jpa.internal.jpql.GrammarValidator

org.eclipse.persistence.jpa.internal.jpql.GrammarValidator$AbstractCollectionValidator

org.eclipse.persistence.jpa.internal.jpql.ParameterTypeVisitor

org.eclipse.persistence.jpa.internal.jpql.ResolverBuilder

org.eclipse.persistence.jpa.internal.jpql.SemanticValidator

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.