예제 #1
0
 private void renderNonScalarProperties(
     ASTAppender appender, FromElement fromElement, int nonscalarSize, int k) {
   String text = fromElement.renderPropertySelect(nonscalarSize, k);
   appender.append(SqlTokenTypes.SQL_TOKEN, text, false);
   if (fromElement.getQueryableCollection() != null && fromElement.isFetch()) {
     text = fromElement.renderCollectionSelectFragment(nonscalarSize, k);
     appender.append(SqlTokenTypes.SQL_TOKEN, text, false);
   }
   // Look through the FromElement's children to find any collections of values that should be
   // fetched...
   ASTIterator iter = new ASTIterator(fromElement);
   while (iter.hasNext()) {
     FromElement child = (FromElement) iter.next();
     if (child.isCollectionOfValuesOrComponents() && child.isFetch()) {
       // Need a better way to define the suffixes here...
       text = child.renderValueCollectionSelectFragment(nonscalarSize, nonscalarSize + k);
       appender.append(SqlTokenTypes.SQL_TOKEN, text, false);
     }
   }
 }
예제 #2
0
 private boolean isReturnableEntity(SelectExpression selectExpression) throws SemanticException {
   FromElement fromElement = selectExpression.getFromElement();
   boolean isFetchOrValueCollection =
       fromElement != null
           && (fromElement.isFetch() || fromElement.isCollectionOfValuesOrComponents());
   if (isFetchOrValueCollection) {
     return false;
   } else {
     return selectExpression.isReturnableEntity();
   }
 }
예제 #3
0
  /**
   * Prepares a derived (i.e., not explicitly defined in the query) select clause.
   *
   * @param fromClause The from clause to which this select clause is linked.
   */
  public void initializeDerivedSelectClause(FromClause fromClause) throws SemanticException {
    if (prepared) {
      throw new IllegalStateException("SelectClause was already prepared!");
    }
    // Used to be tested by the TCK but the test is no longer here
    //		if ( getSessionFactoryHelper().isStrictJPAQLComplianceEnabled() && !getWalker().isSubQuery()
    // ) {
    //			// NOTE : the isSubQuery() bit is a temporary hack...
    //			throw new QuerySyntaxException( "JPA-QL compliance requires select clause" );
    //		}
    List fromElements = fromClause.getProjectionList();

    ASTAppender appender =
        new ASTAppender(getASTFactory(), this); // Get ready to start adding nodes.
    int size = fromElements.size();
    ArrayList queryReturnTypeList = new ArrayList(size);

    Iterator iterator = fromElements.iterator();
    for (int k = 0; iterator.hasNext(); k++) {
      FromElement fromElement = (FromElement) iterator.next();
      Type type = fromElement.getSelectType();

      addCollectionFromElement(fromElement);

      if (type != null) {
        boolean collectionOfElements = fromElement.isCollectionOfValuesOrComponents();
        if (!collectionOfElements) {
          if (!fromElement.isFetch()) {
            // Add the type to the list of returned sqlResultTypes.
            queryReturnTypeList.add(type);
          }
          fromElementsForLoad.add(fromElement);
          // Generate the select expression.
          String text = fromElement.renderIdentifierSelect(size, k);
          SelectExpressionImpl generatedExpr =
              (SelectExpressionImpl) appender.append(SqlTokenTypes.SELECT_EXPR, text, false);
          if (generatedExpr != null) {
            generatedExpr.setFromElement(fromElement);
          }
        }
      }
    }

    // Get all the select expressions (that we just generated) and render the select.
    SelectExpression[] selectExpressions = collectSelectExpressions();

    if (getWalker().isShallowQuery()) {
      renderScalarSelects(selectExpressions, fromClause);
    } else {
      renderNonScalarSelects(selectExpressions, fromClause);
    }
    finishInitialization(queryReturnTypeList);
  }
예제 #4
0
 private void addCollectionFromElement(FromElement fromElement) {
   if (fromElement.isFetch()) {
     if (fromElement.getQueryableCollection() != null) {
       String suffix;
       if (collectionFromElements == null) {
         collectionFromElements = new ArrayList();
         suffix = VERSION2_SQL ? "__" : "0__";
       } else {
         suffix = Integer.toString(collectionFromElements.size()) + "__";
       }
       collectionFromElements.add(fromElement);
       fromElement.setCollectionSuffix(suffix);
     }
   }
 }
예제 #5
0
 public boolean include(AST node) {
   FromElement fromElement = (FromElement) node;
   return fromElement.isFetch() && fromElement.getQueryableCollection() != null;
 }
예제 #6
0
  /**
   * Prepares an explicitly defined select clause.
   *
   * @param fromClause The from clause linked to this select clause.
   * @throws SemanticException indicates a semntic issue with the explicit select clause.
   */
  public void initializeExplicitSelectClause(FromClause fromClause) throws SemanticException {
    if (prepared) {
      throw new IllegalStateException("SelectClause was already prepared!");
    }

    // explicit = true;	// This is an explict Select.
    // ArrayList sqlResultTypeList = new ArrayList();
    ArrayList queryReturnTypeList = new ArrayList();

    // First, collect all of the select expressions.
    // NOTE: This must be done *before* invoking setScalarColumnText() because setScalarColumnText()
    // changes the AST!!!
    SelectExpression[] selectExpressions = collectSelectExpressions();

    // we only support parameters in select in the case of INSERT...SELECT statements
    if (getParameterPositions().size() > 0
        && getWalker().getStatementType() != HqlSqlTokenTypes.INSERT) {
      throw new QueryException(
          "Parameters are only supported in SELECT clauses when used as part of a INSERT INTO DML statement");
    }

    for (int i = 0; i < selectExpressions.length; i++) {
      SelectExpression selectExpression = selectExpressions[i];

      if (AggregatedSelectExpression.class.isInstance(selectExpression)) {
        aggregatedSelectExpression = (AggregatedSelectExpression) selectExpression;
        queryReturnTypeList.addAll(aggregatedSelectExpression.getAggregatedSelectionTypeList());
        scalarSelect = true;
      } else {
        // we have no choice but to do this check here
        // this is not very elegant but the "right way" would most likely involve a bigger rewrite
        // so as to
        // treat ParameterNodes in select clauses as SelectExpressions
        boolean inSubquery =
            selectExpression instanceof QueryNode
                && ((QueryNode) selectExpression).getFromClause().getParentFromClause() != null;
        if (getWalker().getStatementType() == HqlSqlTokenTypes.INSERT && inSubquery) {
          // we do not support parameters for subqueries in INSERT...SELECT
          if (((QueryNode) selectExpression).getSelectClause().getParameterPositions().size() > 0) {
            throw new QueryException(
                "Use of parameters in subqueries of INSERT INTO DML statements is not supported.");
          }
        }

        Type type = selectExpression.getDataType();
        if (type == null) {
          throw new IllegalStateException(
              "No data type for node: "
                  + selectExpression.getClass().getName()
                  + " "
                  + new ASTPrinter(SqlTokenTypes.class).showAsString((AST) selectExpression, ""));
        }
        // sqlResultTypeList.add( type );

        // If the data type is not an association type, it could not have been in the FROM clause.
        if (selectExpression.isScalar()) {
          scalarSelect = true;
        }

        if (isReturnableEntity(selectExpression)) {
          fromElementsForLoad.add(selectExpression.getFromElement());
        }

        // Always add the type to the return type list.
        queryReturnTypeList.add(type);
      }
    }

    // init the aliases, after initing the constructornode
    initAliases(selectExpressions);

    if (!getWalker().isShallowQuery()) {
      // add the fetched entities
      List fromElements = fromClause.getProjectionList();

      ASTAppender appender =
          new ASTAppender(getASTFactory(), this); // Get ready to start adding nodes.
      int size = fromElements.size();

      Iterator iterator = fromElements.iterator();
      for (int k = 0; iterator.hasNext(); k++) {
        FromElement fromElement = (FromElement) iterator.next();

        if (fromElement.isFetch()) {
          FromElement origin = null;
          if (fromElement.getRealOrigin() == null) {
            // work around that crazy issue where the tree contains
            // "empty" FromElements (no text); afaict, this is caused
            // by FromElementFactory.createCollectionJoin()
            if (fromElement.getOrigin() == null) {
              throw new QueryException(
                  "Unable to determine origin of join fetch ["
                      + fromElement.getDisplayText()
                      + "]");
            } else {
              origin = fromElement.getOrigin();
            }
          } else {
            origin = fromElement.getRealOrigin();
          }
          if (!fromElementsForLoad.contains(origin)) {
            throw new QueryException(
                "query specified join fetching, but the owner "
                    + "of the fetched association was not present in the select list "
                    + "["
                    + fromElement.getDisplayText()
                    + "]");
          }
          Type type = fromElement.getSelectType();
          addCollectionFromElement(fromElement);
          if (type != null) {
            boolean collectionOfElements = fromElement.isCollectionOfValuesOrComponents();
            if (!collectionOfElements) {
              // Add the type to the list of returned sqlResultTypes.
              fromElement.setIncludeSubclasses(true);
              fromElementsForLoad.add(fromElement);
              // sqlResultTypeList.add( type );
              // Generate the select expression.
              String text = fromElement.renderIdentifierSelect(size, k);
              SelectExpressionImpl generatedExpr =
                  (SelectExpressionImpl) appender.append(SqlTokenTypes.SELECT_EXPR, text, false);
              if (generatedExpr != null) {
                generatedExpr.setFromElement(fromElement);
              }
            }
          }
        }
      }

      // generate id select fragment and then property select fragment for
      // each expression, just like generateSelectFragments().
      renderNonScalarSelects(collectSelectExpressions(), fromClause);
    }

    if (scalarSelect || getWalker().isShallowQuery()) {
      // If there are any scalars (non-entities) selected, render the select column aliases.
      renderScalarSelects(selectExpressions, fromClause);
    }

    finishInitialization(/*sqlResultTypeList,*/ queryReturnTypeList);
  }