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

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

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

org.eclipse.persistence.jpa.jpql.parser.JPQLExpression
A JPQLExpression is the root of the parsed tree representation of a JPQL query. The query is parsed based on what was registered in the {@link JPQLGrammar}'s {@link ExpressionRegistry}.
A JPQL statement may be either a SELECT statement, an UPDATE statement, or a DELETE FROM statement.

BNF: QL_statement ::= {@link SelectStatement select_statement} |{@link UpdateStatement update_statement} |{@link DeleteStatement delete_statement}
It is possible to parse a portion of a JPQL query. The ID of the JPQLQueryBNF is used to parse that portion and {@link #getQueryStatement()} then returns only the parsed tree representationof that JPQL fragment. @version 2.4.2 @since 2.3 @author Pascal Filion

    sb.append(TRIM);
    sb.append(LEFT_PARENTHESIS);
    sb.append(jpqlFragment);
    sb.append(RIGHT_PARENTHESIS);


    JPQLExpression jpqlExpression = new JPQLExpression(
      sb,
      getGrammar(),
      FunctionsReturningStringsBNF.ID,
      true
    );


    TrimExpression trimExpression = (TrimExpression) jpqlExpression.getQueryStatement();
    setSpecification(trimExpression.getSpecification());
    parseTrimCharacter(trimExpression.getTrimCharacter().toParsedText());
    super.parse(trimExpression.getExpression().toParsedText());


    // The trim character is actually the string primary

View Full Code Here

   *
   * @return The root of the parsed tree
   */
  public JPQLExpression getExpression() {
    if (jpqlExpression == null) {
      jpqlExpression = new JPQLExpression(getJPQLFragment(), jpqlGrammar, isTolerant());
    }
    return jpqlExpression;
  }

View Full Code Here

   */
  public ContentAssistProposals buildProposals(int position, ContentAssistExtension extension) {


    try {


      JPQLExpression jpqlExpression = queryContext.getJPQLExpression();
      String jpqlQuery = queryContext.getJPQLQuery();


      // Calculate the position of the cursor within the parsed tree
      queryPosition = jpqlExpression.buildPosition(jpqlQuery, position);


      // Retrieve the word from the JPQL query (which is the text before the position of the cursor)
      wordParser = new WordParser(jpqlQuery);
      wordParser.setPosition(position);
      word = wordParser.partialWord();

View Full Code Here

                                           String selectionCriteria,
                                           AbstractSession session) {


    try {
      // Create the parsed tree representation of the selection criteria
      JPQLExpression jpqlExpression = new JPQLExpression(
        selectionCriteria,
        DefaultEclipseLinkJPQLGrammar.instance(),
        ConditionalExpressionBNF.ID,
        isTolerant()
      );


      // Caches the info and add a virtual range variable declaration
      JPQLQueryContext queryContext = new JPQLQueryContext(jpqlGrammar());
      queryContext.cache(session, null, jpqlExpression, selectionCriteria);
      queryContext.addRangeVariableDeclaration(entityName, "this");


      // Validate the JPQL query, which will use the JPQL grammar matching the validation
      // level, for now, only validate the query statement because there could be an unknown
      // ending that is an order by clause
      validate(queryContext, jpqlExpression.getQueryStatement());


      // Create the Expression representing the selection criteria
      return queryContext.buildExpression(jpqlExpression.getQueryStatement());
    }
    catch (JPQLException exception) {
      throw exception;
    }
    catch (Exception exception) {

View Full Code Here

                                         DatabaseQuery query,
                                         AbstractSession session) {


    try {
      // Parse the JPQL query with the most recent JPQL grammar
      JPQLExpression jpqlExpression = new JPQLExpression(
        jpqlQuery,
        DefaultEclipseLinkJPQLGrammar.instance(),
        isTolerant()
      );


      // Create a context that caches the information contained in the JPQL query
      // (especially from the FROM clause)
      JPQLQueryContext queryContext = new JPQLQueryContext(jpqlGrammar());
      queryContext.cache(session, query, jpqlExpression, jpqlQuery);


      // Validate the JPQL query, which will use the JPQL grammar matching the validation level
      validate(queryContext, jpqlExpression);


      // Create the DatabaseQuery by visiting the parsed tree
      DatabaseQueryVisitor visitor = new DatabaseQueryVisitor(queryContext, jpqlQuery);
      jpqlExpression.accept(visitor);


      // Add the input parameter types to the DatabaseQuery
      if (query == null) {
        query = queryContext.getDatabaseQuery();
        addArguments(queryContext, query);

View Full Code Here

   *
   * @return The root of the parsed tree
   */
  public JPQLExpression getExpression() {
    if (jpqlExpression == null) {
      jpqlExpression = new JPQLExpression(getJPQLFragment(), jpqlGrammar, isTolerant());
    }
    return jpqlExpression;
  }

View Full Code Here


    return parameterTypeVisitor;
  }


  private JPQLExpression parse(String jpqlQuery) {
    return new JPQLExpression(jpqlQuery, jpqlGrammar);
  }

View Full Code Here

   * list if the JPQL query is invalid or incomplete
   */
  public List<ClassDescriptor> getClassDescriptors(CharSequence jpqlQuery, AbstractSession session) {


    // Parse the JPQL query
    JPQLExpression jpqlExpression = new JPQLExpression(jpqlQuery, jpqlGrammar, true);


    // Create the context and cache the information
    JPQLQueryContext queryContext = new JPQLQueryContext(jpqlGrammar);
    queryContext.cache(session, null, jpqlExpression, jpqlQuery);


    // Visit the JPQL query and collect the descriptors defined in the declaration clauses
    DescriptorCollector collector = new DescriptorCollector(queryContext);
    jpqlExpression.accept(collector);


    return new ArrayList<ClassDescriptor>(collector.descriptors);
  }

View Full Code Here

   * setting the {@link IQuery}.
   */
  protected void initializeRoot() {


    if (jpqlExpression == null) {
      jpqlExpression = new JPQLExpression(query.getExpression(), jpqlGrammar, tolerant);
    }


    currentQuery = jpqlExpression;
    contexts.put(currentQuery, this);
  }

View Full Code Here

   * list if the JPQL query is invalid or incomplete
   */
  public List<ClassDescriptor> getClassDescriptors(CharSequence jpqlQuery, AbstractSession session) {


    // Parse the JPQL query
    JPQLExpression jpqlExpression = new JPQLExpression(jpqlQuery, jpqlGrammar, true);


    // Create the context and cache the information
    JPQLQueryContext queryContext = new JPQLQueryContext(jpqlGrammar);
    queryContext.cache(session, null, jpqlExpression, jpqlQuery);


    // Visit the JPQL query and collect the descriptors defined in the declaration clauses
    DescriptorCollector collector = new DescriptorCollector(queryContext);
    jpqlExpression.accept(collector);


    return new ArrayList<ClassDescriptor>(collector.descriptors);
  }

View Full Code Here

0 1 2 3 4

TOP

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

org.eclipse.persistence.internal.jpa.jpql.HermesParser

org.eclipse.persistence.internal.jpa.jpql.JPQLQueryContext

org.eclipse.persistence.internal.jpa.jpql.JPQLQueryHelper

org.eclipse.persistence.jpa.jpql.AbstractContentAssistVisitor

org.eclipse.persistence.jpa.jpql.BasicRefactoringTool

org.eclipse.persistence.jpa.jpql.JPQLQueryContext

org.eclipse.persistence.jpa.jpql.model.AbstractJPQLQueryBuilder

org.eclipse.persistence.jpa.jpql.model.query.TrimExpressionStateObject

org.eclipse.persistence.jpa.jpql.tools.AbstractContentAssistVisitor

org.eclipse.persistence.jpa.jpql.tools.BasicRefactoringTool

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.