/** * Compile a subquery. * * @param superquery The containing query of the query to be compiled. * @throws org.hibernate.MappingException Indicates problems resolving things referenced in the * query. * @throws org.hibernate.QueryException Generally some form of syntatic failure. */ void compile(QueryTranslatorImpl superquery) throws QueryException, MappingException { this.tokenReplacements = superquery.tokenReplacements; this.superQuery = superquery; this.shallowQuery = true; this.enabledFilters = superquery.getEnabledFilters(); compile(); }
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()); } } }
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); } }
public void token(String token, QueryTranslatorImpl q) throws QueryException { String lcToken = token.toLowerCase(Locale.ROOT); // Cope with [,] if (token.equals("[") && !expectingPathContinuation) { expectingPathContinuation = false; if (expectingIndex == 0) { throw new QueryException("unexpected ["); } return; } else if (token.equals("]")) { expectingIndex--; expectingPathContinuation = true; return; } // Cope with a continued path expression (ie. ].baz) if (expectingPathContinuation) { boolean pathExpressionContinuesFurther = continuePathExpression(token, q); if (pathExpressionContinuesFurther) { return; // NOTE: early return } } // Cope with a subselect if (!inSubselect && (lcToken.equals("select") || lcToken.equals("from"))) { inSubselect = true; subselect = new StringBuilder(20); } if (inSubselect && token.equals(")")) { bracketsSinceSelect--; if (bracketsSinceSelect == -1) { QueryTranslatorImpl subq = new QueryTranslatorImpl(subselect.toString(), q.getEnabledFilters(), q.getFactory()); try { subq.compile(q); } catch (MappingException me) { throw new QueryException("MappingException occurred compiling subquery", me); } appendToken(q, subq.getSQLString()); inSubselect = false; bracketsSinceSelect = 0; } } if (inSubselect) { if (token.equals("(")) { bracketsSinceSelect++; } subselect.append(token).append(' '); return; } // Cope with special cases of AND, NOT, () specialCasesBefore(lcToken); // Close extra brackets we opened if (!betweenSpecialCase && EXPRESSION_TERMINATORS.contains(lcToken)) { closeExpression(q, lcToken); } // take note when this is a boolean expression if (BOOLEAN_OPERATORS.contains(lcToken)) { booleanTests.removeLast(); booleanTests.addLast(Boolean.TRUE); } if (lcToken.equals("not")) { nots.addLast(!(nots.removeLast())); negated = !negated; return; // NOTE: early return } // process a token, mapping OO path expressions to SQL expressions doToken(token, q); // Open any extra brackets we might need. if (!betweenSpecialCase && EXPRESSION_OPENERS.contains(lcToken)) { openExpression(q, lcToken); } // Cope with special cases of AND, NOT, ) specialCasesAfter(lcToken); }
public void token(String token, QueryTranslatorImpl q) throws QueryException { if (token != null) path.append(token); String alias = q.getPathAlias(path.toString()); if (alias != null) { reset(q); // reset the dotcount (but not the path) currentName = alias; // after reset! currentPropertyMapping = q.getPropertyMapping(currentName); if (!ignoreInitialJoin) { JoinSequence ojf = q.getPathJoin(path.toString()); try { joinSequence.addCondition( ojf.toJoinFragment(q.getEnabledFilters(), true) .toWhereFragmentString()); // after reset! } catch (MappingException me) { throw new QueryException(me); } // we don't need to worry about any condition in the ON clause // here (toFromFragmentString), since anything in the ON condition // is already applied to the whole query } } else if (".".equals(token)) { dotcount++; } else { if (dotcount == 0) { if (!continuation) { if (!q.isName(token)) throw new QueryException("undefined alias: " + token); currentName = token; currentPropertyMapping = q.getPropertyMapping(currentName); } } else if (dotcount == 1) { if (currentName != null) { currentProperty = token; } else if (collectionName != null) { // processCollectionProperty(token, q.getCollectionPersister(collectionRole), // collectionName); continuation = false; } else { throw new QueryException("unexpected"); } } else { // dotcount>=2 // Do the corresponding RHS Type propertyType = getPropertyType(); if (propertyType == null) { throw new QueryException("unresolved property: " + path); } if (propertyType.isComponentType()) { dereferenceComponent(token); } else if (propertyType.isEntityType()) { if (!isCollectionValued()) dereferenceEntity(token, (EntityType) propertyType, q); } else if (propertyType.isCollectionType()) { dereferenceCollection(token, ((CollectionType) propertyType).getRole(), q); } else { if (token != null) throw new QueryException("dereferenced: " + path); } } } }