예제 #1
0
  private void doPathExpression(String token, QueryTranslatorImpl q) throws QueryException {

    preprocess(token, q);

    StringTokenizer tokens = new StringTokenizer(token, ".", true);
    pathExpressionParser.start(q);
    while (tokens.hasMoreTokens()) {
      pathExpressionParser.token(tokens.nextToken(), q);
    }
    pathExpressionParser.end(q);
    if (pathExpressionParser.isCollectionValued()) {
      openExpression(q, "");
      appendToken(q, pathExpressionParser.getCollectionSubquery(q.getEnabledFilters()));
      closeExpression(q, "");
      // this is ugly here, but needed because its a subquery
      q.addQuerySpaces(
          q.getCollectionPersister(pathExpressionParser.getCollectionRole()).getCollectionSpaces());
    } else {
      if (pathExpressionParser.isExpectingCollectionIndex()) {
        expectingIndex++;
      } else {
        addJoin(pathExpressionParser.getWhereJoin(), q);
        appendToken(q, pathExpressionParser.getWhereColumn());
      }
    }
  }
예제 #2
0
 void appendToken(QueryTranslatorImpl q, String token) {
   if (expectingIndex > 0) {
     pathExpressionParser.setLastCollectionElementIndexValue(token);
   } else {
     q.appendWhereToken(token);
   }
 }
예제 #3
0
 private void addJoin(JoinSequence joinSequence, QueryTranslatorImpl q) throws QueryException {
   // JoinFragment fromClause = q.createJoinFragment(true);
   // fromClause.addJoins( join.toJoinFragment().toFromFragmentString(), StringHelper.EMPTY_STRING
   // );
   q.addFromJoinOnly(pathExpressionParser.getName(), joinSequence);
   try {
     addToCurrentJoin(
         joinSequence.toJoinFragment(q.getEnabledFilters(), true).toWhereFragmentString());
   } catch (MappingException me) {
     throw new QueryException(me);
   }
 }
예제 #4
0
 public void end(QueryTranslatorImpl q) throws QueryException {
   if (expectingPathContinuation) {
     expectingPathContinuation = false;
     PathExpressionParser.CollectionElement element = pathExpressionParser.lastCollectionElement();
     if (element.elementColumns.length != 1) {
       throw new QueryException("path expression ended in composite collection element");
     }
     appendToken(q, element.elementColumns[0]);
     addToCurrentJoin(element);
   }
   token(")", q);
 }
예제 #5
0
 private String getElementName(
     PathExpressionParser.CollectionElement element, QueryTranslatorImpl q) throws QueryException {
   String name;
   if (element.isOneToMany) {
     name = element.alias;
   } else {
     Type type = element.elementType;
     if (type.isEntityType()) { // ie. a many-to-many
       String entityName = ((EntityType) type).getAssociatedEntityName();
       name = pathExpressionParser.continueFromManyToMany(entityName, element.elementColumns, q);
     } else {
       throw new QueryException("illegally dereferenced collection element");
     }
   }
   return name;
 }
예제 #6
0
 private void preprocess(String token, QueryTranslatorImpl q) throws QueryException {
   // ugly hack for cases like "elements(foo.bar.collection)"
   // (multi-part path expression ending in elements or indices)
   String[] tokens = StringHelper.split(".", token, true);
   if (tokens.length > 5
       && (CollectionPropertyNames.COLLECTION_ELEMENTS.equals(tokens[tokens.length - 1])
           || CollectionPropertyNames.COLLECTION_INDICES.equals(tokens[tokens.length - 1]))) {
     pathExpressionParser.start(q);
     for (int i = 0; i < tokens.length - 3; i++) {
       pathExpressionParser.token(tokens[i], q);
     }
     pathExpressionParser.token(null, q);
     pathExpressionParser.end(q);
     addJoin(pathExpressionParser.getWhereJoin(), q);
     pathExpressionParser.ignoreInitialJoin();
   }
 }
예제 #7
0
  private boolean continuePathExpression(String token, QueryTranslatorImpl q)
      throws QueryException {

    expectingPathContinuation = false;

    PathExpressionParser.CollectionElement element = pathExpressionParser.lastCollectionElement();

    if (token.startsWith(".")) { // the path expression continues after a ]

      doPathExpression(getElementName(element, q) + token, q); // careful with this!

      addToCurrentJoin(element);
      return true; // NOTE: EARLY EXIT!

    } else { // the path expression ends at the ]
      if (element.elementColumns.length != 1) {
        throw new QueryException("path expression ended in composite collection element");
      }
      appendToken(q, element.elementColumns[0]);
      addToCurrentJoin(element);
      return false;
    }
  }
예제 #8
0
 {
   pathExpressionParser = new PathExpressionParser();
   pathExpressionParser.setUseThetaStyleJoin(
       true); // Need this, since join condition can appear inside parens!
 }