Examples of org.eclipse.persistence.jpa.jpql.parser.IdentificationVariable

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

Examples of org.eclipse.persistence.jpa.jpql.parser.IdentificationVariable

org.eclipse.persistence.jpa.jpql.parser.IdentificationVariable
An identification variable is a valid identifier declared in the FROM clause of a query.
Requirements:
- All identification variables must be declared in the FROM clause. Identification variables cannot be declared in other clauses.
- An identification variable must not be a reserved identifier or have the same name as any entity in the same persistence unit.
- Identification variables are case insensitive.
- An identification variable evaluates to a value of the type of the expression used in declaring the variable.
An identification variable can range over an entity, embeddable, or basic abstract schema type. An identification variable designates an instance of an abstract schema type or an element of a collection of abstract schema type instances.
Note that for identification variables referring to an instance of an association or collection represented as a {@link java.util.Map}, the identification variable is of the abstract schema type of the map value.
An identification variable always designates a reference to a single value. It is declared in one of three ways:
- In a range variable declaration;
- In a join clause;
- In a collection member declaration.
The identification variable declarations are evaluated from left to right in the FROM clause, and an identification variable declaration can use the result of a preceding identification variable declaration of the query string.
All identification variables used in the SELECT, WHERE, ORDER BY, GROUP BY, or HAVING clause of a SELECT or DELETE statement must be declared in the FROM clause. The identification variables used in the WHERE clause of an UPDATE statement must be declared in the UPDATE clause.
An identification variable is scoped to the query (or subquery) in which it is defined and is also visible to any subqueries within that query scope that do not define an identification variable of the same name. @version 2.4 @since 2.3 @author Pascal Filion


        // The left expression cannot be an identification variable
        if (validator.leftIdentificationVariable &&
            validator.leftIdentificationVariableValid) {


          IdentificationVariable variable = (IdentificationVariable) leftExpression;


          // There is a specific EclipseLink case where it is valid to use an
          // identification variable, which is when the identification variable
          // maps to a direct collection mapping
          if (!isIdentificationVariableValidInComparison(variable)) {


            addProblem(
              leftExpression,
              ComparisonExpression_IdentificationVariable,
              leftExpression.toActualText(),
              expression.getComparisonOperator()
            );


            valid = false;
          }
        }
        // The left expression is a path expression
        else if (validator.leftStateFieldPathExpression &&
                 validator.leftStateFieldPathExpressionValid) {


          Object mapping = helper.resolveMapping(leftExpression);


          // The path expression cannot be a non-basic mapping
          if ((mapping != null) && !helper.isPropertyMapping(mapping)) {


            addProblem(
              leftExpression,
              ComparisonExpression_AssociationField,
              leftExpression.toActualText(),
              expression.getComparisonOperator()
            );


            valid = false;
          }
        }


        // The right expression cannot be an identification variable
        if (validator.rightIdentificationVariable &&
            validator.rightIdentificationVariableValid) {


          IdentificationVariable variable = (IdentificationVariable) rightExpression;


          // There is a specific EclipseLink case where it is valid to use an
          // identification variable, which is when the identification variable
          // maps to a direct collection mapping
          if (!isIdentificationVariableValidInComparison(variable)) {


            addProblem(
              rightExpression,
              ComparisonExpression_IdentificationVariable,
              rightExpression.toActualText(),
              expression.getComparisonOperator()
            );


            valid = false;
          }
        }
        // The right expression is a path expression
        else if (validator.rightStateFieldPathExpression      &&
                 validator.rightStateFieldPathExpressionValid) {


          Object mapping = helper.resolveMapping(rightExpression);


          // The path expression cannot be a non-basic mapping
          if ((mapping != null) && !helper.isPropertyMapping(mapping)) {


            addProblem(
              rightExpression,
              ComparisonExpression_AssociationField,
              rightExpression.toActualText(),
              expression.getComparisonOperator()
            );


            valid = false;
          }
        }
      }
      // '=', '<>'
      else {


        // The left expression is an identification variable
        // The right expression is a path expression
        if (validator.leftIdentificationVariable      &&
            validator.leftIdentificationVariableValid &&
            validator.rightStateFieldPathExpression   &&
            validator.rightStateFieldPathExpressionValid) {


          Object mapping = helper.resolveMapping(rightExpression);
          IdentificationVariable variable = (IdentificationVariable) leftExpression;


          // The path expression can only be a non-basic mapping.
          // There is a specific EclipseLink case where it is valid to use an
          // identification variable, which is when the identification variable
          // maps to a direct collection mapping
          if ((mapping != null) && helper.isPropertyMapping(mapping) &&
              !isIdentificationVariableValidInComparison(variable)) {


            addProblem(
              rightExpression,
              ComparisonExpression_BasicField,
              rightExpression.toActualText(),
              expression.getComparisonOperator()
            );


            valid = false;
          }
        }
        // The left expression is a path expression
        // The right expression is an identification variable
        else if (validator.rightIdentificationVariable      &&
                 validator.rightIdentificationVariableValid &&
                 validator.leftStateFieldPathExpression     &&
                 validator.leftStateFieldPathExpressionValid) {


          Object mapping = helper.resolveMapping(leftExpression);
          IdentificationVariable variable = (IdentificationVariable) rightExpression;


          // The path expression can only be a non-basic mapping.
          // There is a specific EclipseLink case where it is valid to use an
          // identification variable, which is when the identification variable
          // maps to a direct collection mapping

View Full Code Here

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


      IdentificationVariable variable = (IdentificationVariable) expression.getIdentificationVariable();
      Declaration declaration = queryContext.getDeclaration(variable.getVariableName());


      // If the Declaration is RangeDeclaration, then retrieve its Descriptor directly,
      // this will support two cases automatically, the "root" object is
      // 1) An abstract schema name (entity name) -> parsed as AbstractSchemaName
      // 2) A fully qualified class name -> parsed as a CollectionValuedPathExpression

View Full Code Here

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


    expression.getSelectExpression().accept(this);
    IdentificationVariable identificationVariable = (IdentificationVariable) expression.getResultVariable();
    String variableName = identificationVariable.getVariableName();
    queryContext.addQueryExpression(variableName, queryExpression);


    // Note: The type will be calculated when traversing the select expression
  }

View Full Code Here

   */
  @Override
  public void visit(ResultVariable expression) {


    // Now cache the Expression for future retrieval by the ORDER BY clause
    IdentificationVariable identificationVariable = (IdentificationVariable) expression.getResultVariable();
    resultVariable = identificationVariable.getText();


    // Create the Expression that is added to the query as an attribute
    expression.getSelectExpression().accept(this);


    resultVariable = null;

View Full Code Here

  /**
   * {@inheritDoc}
   */
  @Override
  public void visit(ValueExpression expression) {
    IdentificationVariable identificationVariable = (IdentificationVariable) expression.getExpression();
    Expression queryExpression = queryContext.buildExpression(expression, type);
    addAttribute(identificationVariable.getText(), queryExpression);
  }

View Full Code Here

    @Override
    public void visit(Join expression) {


      if (expression.hasIdentificationVariable()) {


        IdentificationVariable identificationVariable = (IdentificationVariable) expression.getIdentificationVariable();
        Expression queryExpression = addNonFetchJoinedAttribute(expression, identificationVariable);


        // Add the ON clause to the expression
        if (expression.hasOnClause()) {
          Expression onClause = queryContext.buildExpression(expression.getOnClause());


          // Create the JOIN expression using the base Expression
          if (expression.isLeftJoin()) {
            queryExpression = baseExpression.leftJoin(queryExpression, onClause);
          }
          else {
            queryExpression = baseExpression.join(queryExpression, onClause);
          }
        }


        // Add the FETCH expression to the Expression
        if (expression.hasFetch()) {


          String variableName = identificationVariable.getVariableName();
          queryExpression = queryContext.getQueryExpression(variableName);


          if (queryExpression == null) {
            queryExpression = queryContext.buildExpression(expression);
            queryContext.addQueryExpression(variableName, queryExpression);

View Full Code Here

                                                              Map<String, List<IdentificationVariable>> identificationVariables) {


    DeclarationResolver declarationResolver = queryContext.getDeclarationResolverImp();


    for (Declaration declaration : declarationResolver.getDeclarations()) {
      IdentificationVariable identificationVariable = declaration.identificationVariable;
      addIdentificationVariable(identificationVariable, identificationVariables);
    }


    for (IdentificationVariable identificationVariable : declarationResolver.getResultVariables()) {
      addIdentificationVariable(identificationVariable, identificationVariables);

View Full Code Here

      declaration.declarationExpression = expression;
      declarations.add(declaration);


      // A derived collection member declaration does not have an identification variable
      if (!expression.isDerived()) {
        IdentificationVariable identificationVariable = (IdentificationVariable) expression.getIdentificationVariable();
        declaration.identificationVariable = identificationVariable;
      }


      // This collection member declaration is the first defined,
      // it is then the base Declaration

View Full Code Here

    public void visit(Join expression) {


      ((AbstractRangeDeclaration) currentDeclaration).addJoin(expression);


      if (!expression.hasFetch() || expression.hasIdentificationVariable()) {
        IdentificationVariable identificationVariable = (IdentificationVariable) expression.getIdentificationVariable();


        JoinDeclaration declaration = new JoinDeclaration(queryContext);
        declaration.baseExpression = expression;
        declaration.identificationVariable = identificationVariable;
        declarations.add(declaration);

View Full Code Here

    /**
     * {@inheritDoc}
     */
    @Override
    public void visit(ResultVariable expression) {
      IdentificationVariable identificationVariable = (IdentificationVariable) expression.getResultVariable();
      resultVariables.add(identificationVariable);
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.eclipse.persistence.jpa.jpql.parser.IdentificationVariable

org.eclipse.persistence.internal.jpa.jpql.AbstractObjectLevelReadQueryVisitor$JoinVisitor

org.eclipse.persistence.internal.jpa.jpql.AbstractReadAllQueryVisitor$JoinVisitor

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

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

org.eclipse.persistence.internal.jpa.jpql.EclipseLinkSemanticValidatorHelper

org.eclipse.persistence.internal.jpa.jpql.ExpressionBuilderVisitor

org.eclipse.persistence.internal.jpa.jpql.ExpressionBuilderVisitor$PathResolver

org.eclipse.persistence.internal.jpa.jpql.ReportItemBuilder

org.eclipse.persistence.internal.jpa.jpql.TypeResolver

org.eclipse.persistence.internal.jpa.jpql.TypeResolver$PathResolver

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.