public HqlSqlWalker(QueryTranslatorImpl qti,
    SessionFactoryImplementor sfi,
    HqlParser parser,
    Map tokenReplacements,
    String collectionRole) 
{
	                                                                                        	 
		setASTFactory( new SqlASTFactory( this ) );
		// Initialize the error handling delegate.
		this.parseErrorHandler = new ErrorCounter();
		this.queryTranslatorImpl = qti;
		this.sessionFactoryHelper = new SessionFactoryHelper( sfi );
		this.literalProcessor = new LiteralProcessor( this );
		this.tokenReplacements = tokenReplacements;
		this.collectionFilterRole = collectionRole;
		this.hqlParser = parser;
		this.printer = new ASTPrinter( SqlTokenTypes.class );
}

Create a new tree transformer.

Parameters:

qti - Back pointer to the query translator implementation that is using this tree transform.

sfi - The session factory implementor where the Hibernate mappings can be found.

parser - A reference to the phase-1 parser

tokenReplacements - Registers the token replacement map with the walker. This map will be used to substitute function names and constants.

collectionRole - The collection role name of the collection used as the basis for the filter, NULL if this is not a collection filter compilation.

 public  void addQuerySpaces(Serializable[] spaces) 
{
		for ( int i = 0; i <  spaces.length; i++ ) {
			querySpaces.add( spaces[i] );
		}
}

 protected  void beforeSelectClause() throws SemanticException 
{
		// Turn off includeSubclasses on all FromElements.
		FromClause from = getCurrentFromClause();
		List fromElements = from.getFromElements();
		for ( Iterator iterator = fromElements.iterator(); iterator.hasNext(); ) {
			FromElement fromElement = ( FromElement ) iterator.next();
			fromElement.setIncludeSubclasses( false );
		}
}

 protected AST createFromElement(String path,
    AST alias,
    AST propertyFetch) throws SemanticException 
{
		FromElement fromElement = currentFromClause.addFromElement( path, alias );
		fromElement.setAllPropertyFetch(propertyFetch!=null);
		return fromElement;
}

 protected AST createFromFilterElement(AST filterEntity,
    AST alias) throws SemanticException 
{
		FromElement fromElement = currentFromClause.addFromElement( filterEntity.getText(), alias );
		FromClause fromClause = fromElement.getFromClause();
		QueryableCollection persister = sessionFactoryHelper.getCollectionPersister( collectionFilterRole );
		// Get the names of the columns used to link between the collection
		// owner and the collection elements.
		String[] keyColumnNames = persister.getKeyColumnNames();
		String fkTableAlias = persister.isOneToMany()
				? fromElement.getTableAlias()
				: fromClause.getAliasGenerator().createName( collectionFilterRole );
		JoinSequence join = sessionFactoryHelper.createJoinSequence();
		join.setRoot( persister, fkTableAlias );
		if ( !persister.isOneToMany() ) {
			join.addJoin( ( AssociationType ) persister.getElementType(),
					fromElement.getTableAlias(),
					JoinFragment.INNER_JOIN,
					persister.getElementColumnNames( fkTableAlias ) );
		}
		join.addCondition( fkTableAlias, keyColumnNames, " = ?" );
		fromElement.setJoinSequence( join );
		fromElement.setFilter( true );
		if ( log.isDebugEnabled() ) {
			log.debug( "createFromFilterElement() : processed filter FROM element." );
		}
		return fromElement;
}

 protected  void createFromJoinElement(AST path,
    AST alias,
    int joinType,
    AST fetchNode,
    AST propertyFetch,
    AST with) throws SemanticException 
{
		boolean fetch = fetchNode != null;
		if ( fetch && isSubQuery() ) {
			throw new QueryException( "fetch not allowed in subquery from-elements" );
		}
		// The path AST should be a DotNode, and it should have been evaluated already.
		if ( path.getType() != SqlTokenTypes.DOT ) {
			throw new SemanticException( "Path expected for join!" );
		}
		DotNode dot = ( DotNode ) path;
		int hibernateJoinType = JoinProcessor.toHibernateJoinType( joinType );
		dot.setJoinType( hibernateJoinType );	// Tell the dot node about the join type.
		dot.setFetch( fetch );
		// Generate an explicit join for the root dot node.   The implied joins will be collected and passed up
		// to the root dot node.
		dot.resolve( true, false, alias == null ? null : alias.getText() );
		FromElement fromElement = dot.getImpliedJoin();
		fromElement.setAllPropertyFetch(propertyFetch!=null);
		if ( with != null ) {
			if ( fetch ) {
				throw new SemanticException( "with-clause not allowed on fetched associations; use filters" );
			}
			handleWithFragment( fromElement, with );
		}
		if ( log.isDebugEnabled() ) {
			log.debug( "createFromJoinElement() : " + getASTPrinter().showAsString( fromElement, "-- join tree --" ) );
		}
}

 protected AST createIntoClause(String path,
    AST propertySpec) throws SemanticException 
{
		Queryable persister = ( Queryable ) getSessionFactoryHelper().requireClassPersister( path );
		IntoClause intoClause = ( IntoClause ) getASTFactory().create( INTO, persister.getEntityName() );
		intoClause.setFirstChild( propertySpec );
		intoClause.initialize( persister );
		addQuerySpaces( persister.getQuerySpaces() );
		return intoClause;
}

 protected  void evaluateAssignment(AST eq) throws SemanticException 
{
		prepareLogicOperator( eq );
		Queryable persister = getCurrentFromClause().getFromElement().getQueryable();
		evaluateAssignment( eq, persister, -1 );
}

 protected AST generateNamedParameter(AST delimiterNode,
    AST nameNode) throws SemanticException 
{
		String name = nameNode.getText();
		trackNamedParameterPositions( name );
		// create the node initially with the param name so that it shows
		// appropriately in the "original text" attribute
		ParameterNode parameter = ( ParameterNode ) astFactory.create( NAMED_PARAM, name );
		parameter.setText( "?" );
		NamedParameterSpecification paramSpec = new NamedParameterSpecification(
				( ( Node ) delimiterNode ).getLine(),
		        ( ( Node ) delimiterNode ).getColumn(),
				name
		);
		parameter.setHqlParameterSpecification( paramSpec );
		parameters.add( paramSpec );
		return parameter;
}

 protected AST generatePositionalParameter(AST inputNode) throws SemanticException 
{
		if ( namedParameters.size()  > 0 ) {
			throw new SemanticException( "cannot define positional parameter after any named parameters have been defined" );
		}
		ParameterNode parameter = ( ParameterNode ) astFactory.create( PARAM, "?" );
		PositionalParameterSpecification paramSpec = new PositionalParameterSpecification(
				( ( Node ) inputNode ).getLine(),
		        ( ( Node ) inputNode ).getColumn(),
				positionalParameterCount++
		);
		parameter.setHqlParameterSpecification( paramSpec );
		parameters.add( paramSpec );
		return parameter;
}

 public ASTPrinter getASTPrinter() 
{
		return printer;
}

 public AliasGenerator getAliasGenerator() 
{
		return aliasGenerator;
}

 public ArrayList getAssignmentSpecifications() 
{
		return assignmentSpecifications;
}

 public FromClause getCurrentFromClause() 
{
		return currentFromClause;
}

 public Map getEnabledFilters() 
{
		return queryTranslatorImpl.getEnabledFilters();
}

 public FromClause getFinalFromClause() 
{
		FromClause top = currentFromClause;
		while ( top.getParentFromClause() != null ) {
			top = top.getParentFromClause();
		}
		return top;
}

 public int getImpliedJoinType() 
{
		return impliedJoinType;
}

 public LiteralProcessor getLiteralProcessor() 
{
		return literalProcessor;
}

 public int[] getNamedParameterLocations(String name) throws QueryException 
{
		Object o = namedParameters.get( name );
		if ( o == null ) {
			QueryException qe = new QueryException( QueryTranslator.ERROR_NAMED_PARAMETER_DOES_NOT_APPEAR + name );
			qe.setQueryString( queryTranslatorImpl.getQueryString() );
			throw qe;
		}
		if ( o instanceof Integer ) {
			return new int[]{( ( Integer ) o ).intValue()};
		}
		else {
			return ArrayHelper.toIntArray( ( ArrayList ) o );
		}
}

Returns the locations of all occurrences of the named parameter.

 public int getNumberOfParametersInSetClause() 
{
		return numberOfParametersInSetClause;
}

 public ArrayList getParameters() 
{
		return parameters;
}

 public ParseErrorHandler getParseErrorHandler() 
{
		return parseErrorHandler;
}

 public Set getQuerySpaces() 
{
		return querySpaces;
}

Returns the set of unique query spaces (a.k.a. table names) that occurred in the query.

 public String[] getReturnAliases() 
{
		return selectClause.getQueryReturnAliases();
}

 public Type[] getReturnTypes() 
{
		return selectClause.getQueryReturnTypes();
}

 public SelectClause getSelectClause() 
{
		return selectClause;
}

 public SessionFactoryHelper getSessionFactoryHelper() 
{
		return sessionFactoryHelper;
}

 public Map getTokenReplacements() 
{
		return tokenReplacements;
}

 public boolean isFilter() 
{
		return collectionFilterRole != null;
}

 protected boolean isNonQualifiedPropertyRef(AST ident) 
{
		final String identText = ident.getText();
		if ( currentFromClause.isFromElementAlias( identText ) ) {
			return false;
		}
		List fromElements = currentFromClause.getExplicitFromElements();
		if ( fromElements.size() == 1 ) {
			final FromElement fromElement = ( FromElement ) fromElements.get( 0 );
			try {
				log.trace( "attempting to resolve property [" + identText + "] as a non-qualified ref" );
				return fromElement.getPropertyMapping( identText ).toType( identText ) != null;
			}
			catch( QueryException e ) {
				// Should mean that no such property was found
			}
		}
		return false;
}

 public boolean isShallowQuery() 
{
		// select clauses for insert statements should alwasy be treated as shallow
		return getStatementType() == INSERT || queryTranslatorImpl.isShallowQuery();
}

 protected  void lookupAlias(AST aliasRef) throws SemanticException 
{
		FromElement alias = currentFromClause.getFromElement( aliasRef.getText() );
		FromReferenceNode aliasRefNode = ( FromReferenceNode ) aliasRef;
		aliasRefNode.setFromElement( alias );
}

 protected AST lookupNonQualifiedProperty(AST property) throws SemanticException 
{
		final FromElement fromElement = ( FromElement ) currentFromClause.getExplicitFromElements().get( 0 );
		AST syntheticDotNode = generateSyntheticDotNodeForNonQualifiedPropertyRef( property, fromElement );
		return lookupProperty( syntheticDotNode, false, getCurrentClauseType() == HqlSqlTokenTypes.SELECT );
}

 protected AST lookupProperty(AST dot,
    boolean root,
    boolean inSelect) throws SemanticException 
{
		DotNode dotNode = ( DotNode ) dot;
		FromReferenceNode lhs = dotNode.getLhs();
		AST rhs = lhs.getNextSibling();
		switch ( rhs.getType() ) {
			case SqlTokenTypes.ELEMENTS:
			case SqlTokenTypes.INDICES:
				if ( log.isDebugEnabled() ) {
					log.debug( "lookupProperty() " + dotNode.getPath() + " = > " + rhs.getText() + "(" + lhs.getPath() + ")" );
				}
				CollectionFunction f = ( CollectionFunction ) rhs;
				// Re-arrange the tree so that the collection function is the root and the lhs is the path.
				f.setFirstChild( lhs );
				lhs.setNextSibling( null );
				dotNode.setFirstChild( f );
				resolve( lhs );			// Don't forget to resolve the argument!
				f.resolve( inSelect );	// Resolve the collection function now.
				return f;
			default:
				// Resolve everything up to this dot, but don't resolve the placeholders yet.
				dotNode.resolveFirstChild();
				return dotNode;
		}
}

 public static  void panic() 
{
		throw new QueryException( "TreeWalker: panic" );
}

 protected  void postProcessDML(RestrictableStatement statement) throws SemanticException 
{
		statement.getFromClause().resolve();
		FromElement fromElement = ( FromElement ) statement.getFromClause().getFromElements().get( 0 );
		Queryable persister = fromElement.getQueryable();
		// Make #@%$^#^&# sure no alias is applied to the table name
		fromElement.setText( persister.getTableName() );
		// append any filter fragments; the EMPTY_MAP is used under the assumption that
		// currently enabled filters should not affect this process
		if ( persister.getDiscriminatorType() != null ) {
			new SyntheticAndFactory( getASTFactory() ).addDiscriminatorWhereFragment(
			        statement,
			        persister,
			        java.util.Collections.EMPTY_MAP,
			        fromElement.getTableAlias()
			);
		}
}

 protected  void postProcessDelete(AST delete) throws SemanticException 
{
		postProcessDML( ( DeleteStatement ) delete );
}

 protected  void postProcessInsert(AST insert) throws SemanticException, QueryException 
{
		InsertStatement insertStatement = ( InsertStatement ) insert;
		insertStatement.validate();
		SelectClause selectClause = insertStatement.getSelectClause();
		Queryable persister = insertStatement.getIntoClause().getQueryable();
		if ( !insertStatement.getIntoClause().isExplicitIdInsertion() ) {
			// We need to generate ids as part of this bulk insert.
			//
			// Note that this is only supported for sequence-style generators and
			// post-insert-style generators; basically, only in-db generators
			IdentifierGenerator generator = persister.getIdentifierGenerator();
			if ( !supportsIdGenWithBulkInsertion( generator ) ) {
				throw new QueryException( "can only generate ids as part of bulk insert with either sequence or post-insert style generators" );
			}
			AST idSelectExprNode = null;
			if ( SequenceGenerator.class.isAssignableFrom( generator.getClass() ) ) {
				String seqName = ( String ) ( ( SequenceGenerator ) generator ).generatorKey();
				String nextval = sessionFactoryHelper.getFactory().getDialect().getSelectSequenceNextValString( seqName );
				idSelectExprNode = getASTFactory().create( HqlSqlTokenTypes.SQL_TOKEN, nextval );
			}
			else {
				//Don't need this, because we should never ever be selecting no columns in an insert ... select...
				//and because it causes a bug on DB2
				/*String idInsertString = sessionFactoryHelper.getFactory().getDialect().getIdentityInsertString();
				if ( idInsertString != null ) {
					idSelectExprNode = getASTFactory().create( HqlSqlTokenTypes.SQL_TOKEN, idInsertString );
				}*/
			}
			if ( idSelectExprNode != null ) {
				AST currentFirstSelectExprNode = selectClause.getFirstChild();
				selectClause.setFirstChild( idSelectExprNode );
				idSelectExprNode.setNextSibling( currentFirstSelectExprNode );
				insertStatement.getIntoClause().prependIdColumnSpec();
			}
		}
		final boolean includeVersionProperty = persister.isVersioned() &&
				!insertStatement.getIntoClause().isExplicitVersionInsertion() &&
				persister.isVersionPropertyInsertable();
		if ( includeVersionProperty ) {
			// We need to seed the version value as part of this bulk insert
			VersionType versionType = persister.getVersionType();
			AST versionValueNode = null;
			if ( sessionFactoryHelper.getFactory().getDialect().supportsParametersInInsertSelect() ) {
				versionValueNode = getASTFactory().create( HqlSqlTokenTypes.PARAM, "?" );
				ParameterSpecification paramSpec = new VersionTypeSeedParameterSpecification( versionType );
				( ( ParameterNode ) versionValueNode ).setHqlParameterSpecification( paramSpec );
				parameters.add( 0, paramSpec );
			}
			else {
				if ( isIntegral( versionType ) ) {
					try {
						Object seedValue = versionType.seed( null );
						versionValueNode = getASTFactory().create( HqlSqlTokenTypes.SQL_TOKEN, seedValue.toString() );
					}
					catch( Throwable t ) {
						throw new QueryException( "could not determine seed value for version on bulk insert [" + versionType + "]" );
					}
				}
				else if ( isDatabaseGeneratedTimestamp( versionType ) ) {
					String functionName = sessionFactoryHelper.getFactory().getDialect().getCurrentTimestampSQLFunctionName();
					versionValueNode = getASTFactory().create( HqlSqlTokenTypes.SQL_TOKEN, functionName );
				}
				else {
					throw new QueryException( "cannot handle version type [" + versionType + "] on bulk inserts with dialects not supporting parameters in insert-select statements" );
				}
			}
			AST currentFirstSelectExprNode = selectClause.getFirstChild();
			selectClause.setFirstChild( versionValueNode );
			versionValueNode.setNextSibling( currentFirstSelectExprNode );
			insertStatement.getIntoClause().prependVersionColumnSpec();
		}
		if ( insertStatement.getIntoClause().isDiscriminated() ) {
			String sqlValue = insertStatement.getIntoClause().getQueryable().getDiscriminatorSQLValue();
			AST discrimValue = getASTFactory().create( HqlSqlTokenTypes.SQL_TOKEN, sqlValue );
			insertStatement.getSelectClause().addChild( discrimValue );
		}
}

 protected  void postProcessUpdate(AST update) throws SemanticException 
{
		UpdateStatement updateStatement = ( UpdateStatement ) update;
		postProcessDML( updateStatement );
}

 protected  void prepareArithmeticOperator(AST operator) throws SemanticException 
{
		( ( OperatorNode ) operator ).initialize();
}

 protected  void prepareFromClauseInputTree(AST fromClauseInput) 
{
		if ( !isSubQuery() ) {
//			// inject param specifications to account for dynamic filter param values
//			if ( ! getEnabledFilters().isEmpty() ) {
//				Iterator filterItr = getEnabledFilters().values().iterator();
//				while ( filterItr.hasNext() ) {
//					FilterImpl filter = ( FilterImpl ) filterItr.next();
//					if ( ! filter.getFilterDefinition().getParameterNames().isEmpty() ) {
//						Iterator paramItr = filter.getFilterDefinition().getParameterNames().iterator();
//						while ( paramItr.hasNext() ) {
//							String parameterName = ( String ) paramItr.next();
//							// currently param filters *only* work with single-column parameter types;
//							// if that limitation is ever lifted, this logic will need to change to account for that
//							ParameterNode collectionFilterKeyParameter = ( ParameterNode ) astFactory.create( PARAM, "?" );
//							DynamicFilterParameterSpecification paramSpec = new DynamicFilterParameterSpecification(
//									filter.getName(),
//									parameterName,
//									filter.getFilterDefinition().getParameterType( parameterName ),
//									 positionalParameterCount++
//							);
//							collectionFilterKeyParameter.setHqlParameterSpecification( paramSpec );
//							parameters.add( paramSpec );
//						}
//					}
//				}
//			}
			if ( isFilter() ) {
				// Handle collection-fiter compilation.
				// IMPORTANT NOTE: This is modifying the INPUT (HQL) tree, not the output tree!
				QueryableCollection persister = sessionFactoryHelper.getCollectionPersister( collectionFilterRole );
				Type collectionElementType = persister.getElementType();
				if ( !collectionElementType.isEntityType() ) {
					throw new QueryException( "collection of values in filter: this" );
				}
				String collectionElementEntityName = persister.getElementPersister().getEntityName();
				ASTFactory inputAstFactory = hqlParser.getASTFactory();
				AST fromElement = ASTUtil.create( inputAstFactory, HqlTokenTypes.FILTER_ENTITY, collectionElementEntityName );
				ASTUtil.createSibling( inputAstFactory, HqlTokenTypes.ALIAS, "this", fromElement );
				fromClauseInput.addChild( fromElement );
				// Show the modified AST.
				if ( log.isDebugEnabled() ) {
					log.debug( "prepareFromClauseInputTree() : Filter - Added 'this' as a from element..." );
				}
				queryTranslatorImpl.showHqlAst( hqlParser.getAST() );
				// Create a parameter specification for the collection filter...
				Type collectionFilterKeyType = sessionFactoryHelper.requireQueryableCollection( collectionFilterRole ).getKeyType();
				ParameterNode collectionFilterKeyParameter = ( ParameterNode ) astFactory.create( PARAM, "?" );
				CollectionFilterKeyParameterSpecification collectionFilterKeyParameterSpec = new CollectionFilterKeyParameterSpecification(
						collectionFilterRole, collectionFilterKeyType, positionalParameterCount++
				);
				collectionFilterKeyParameter.setHqlParameterSpecification( collectionFilterKeyParameterSpec );
				parameters.add( collectionFilterKeyParameterSpec );
			}
		}
}

 protected  void prepareLogicOperator(AST operator) throws SemanticException 
{
		( ( OperatorNode ) operator ).initialize();
}

 protected  void prepareVersioned(AST updateNode,
    AST versioned) throws SemanticException 
{
		UpdateStatement updateStatement = ( UpdateStatement ) updateNode;
		FromClause fromClause = updateStatement.getFromClause();
		if ( versioned != null ) {
			// Make sure that the persister is versioned
			Queryable persister = fromClause.getFromElement().getQueryable();
			if ( !persister.isVersioned() ) {
				throw new SemanticException( "increment option specified for update of non-versioned entity" );
			}
			VersionType versionType = persister.getVersionType();
			if ( versionType instanceof UserVersionType ) {
				throw new SemanticException( "user-defined version types not supported for increment option" );
			}
			AST eq = getASTFactory().create( HqlSqlTokenTypes.EQ, "=" );
			AST versionPropertyNode = generateVersionPropertyNode( persister );
			eq.setFirstChild( versionPropertyNode );
			AST versionIncrementNode = null;
			if ( Date.class.isAssignableFrom( versionType.getReturnedClass() ) ) {
				versionIncrementNode = getASTFactory().create( HqlSqlTokenTypes.PARAM, "?" );
				ParameterSpecification paramSpec = new VersionTypeSeedParameterSpecification( versionType );
				( ( ParameterNode ) versionIncrementNode ).setHqlParameterSpecification( paramSpec );
				parameters.add( 0, paramSpec );
			}
			else {
				// Not possible to simply re-use the versionPropertyNode here as it causes
				// OOM errors due to circularity :(
				versionIncrementNode = getASTFactory().create( HqlSqlTokenTypes.PLUS, "+" );
				versionIncrementNode.setFirstChild( generateVersionPropertyNode( persister ) );
				versionIncrementNode.addChild( getASTFactory().create( HqlSqlTokenTypes.IDENT, "1" ) );
			}
			eq.addChild( versionIncrementNode );
			evaluateAssignment( eq, persister, 0 );
			AST setClause = updateStatement.getSetClause();
			AST currentFirstSetElement = setClause.getFirstChild();
			setClause.setFirstChild( eq );
			eq.setNextSibling( currentFirstSetElement );
		}
}

 protected  void processBoolean(AST constant) throws SemanticException 
{
		literalProcessor.processBoolean( constant );  // Use the delegate.
}

 protected  void processConstant(AST constant) throws SemanticException 
{
		literalProcessor.processConstant( constant, true );  // Use the delegate, resolve identifiers as FROM element aliases.
}

 protected  void processConstructor(AST constructor) throws SemanticException 
{
		ConstructorNode constructorNode = ( ConstructorNode ) constructor;
		constructorNode.prepare();
}

 protected  void processFunction(AST functionCall,
    boolean inSelect) throws SemanticException 
{
		MethodNode methodNode = ( MethodNode ) functionCall;
		methodNode.resolve( inSelect );
}

 protected  void processIndex(AST indexOp) throws SemanticException 
{
		IndexNode indexNode = ( IndexNode ) indexOp;
		indexNode.resolve( true, true );
}

 protected  void processNumericLiteral(AST literal) 
{
		literalProcessor.processNumeric( literal );
}

 protected  void processQuery(AST select,
    AST query) throws SemanticException 
{
		if ( log.isDebugEnabled() ) {
			log.debug( "processQuery() : " + query.toStringTree() );
		}
		try {
			QueryNode qn = ( QueryNode ) query;
			// Was there an explicit select expression?
			boolean explicitSelect = select != null && select.getNumberOfChildren()  > 0;
			if ( !explicitSelect ) {
				// No explicit select expression; render the id and properties
				// projection lists for every persister in the from clause into
				// a single 'token node'.
				//TODO: the only reason we need this stuff now is collection filters,
				//      we should get rid of derived select clause completely!
				createSelectClauseFromFromClause( qn );
			}
			else {
				// Use the explicitly declared select expression; determine the
				// return types indicated by each select token
				useSelectClause( select );
			}
			// After that, process the JOINs.
			// Invoke a delegate to do the work, as this is farily complex.
			JoinProcessor joinProcessor = new JoinProcessor( astFactory, queryTranslatorImpl );
			joinProcessor.processJoins( qn, isSubQuery() );
			// Attach any mapping-defined "ORDER BY" fragments
			Iterator itr = qn.getFromClause().getProjectionList().iterator();
			while ( itr.hasNext() ) {
				final FromElement fromElement = ( FromElement ) itr.next();
//			if ( fromElement.isFetch() && fromElement.isCollectionJoin() ) {
				if ( fromElement.isFetch() && fromElement.getQueryableCollection() != null ) {
					// Does the collection referenced by this FromElement
					// specify an order-by attribute?  If so, attach it to
					// the query's order-by
					if ( fromElement.getQueryableCollection().hasOrdering() ) {
						String orderByFragment = fromElement
								.getQueryableCollection()
								.getSQLOrderByString( fromElement.getCollectionTableAlias() );
						qn.getOrderByClause().addOrderFragment( orderByFragment );
					}
					if ( fromElement.getQueryableCollection().hasManyToManyOrdering() ) {
						String orderByFragment = fromElement.getQueryableCollection()
								.getManyToManyOrderByString( fromElement.getTableAlias() );
						qn.getOrderByClause().addOrderFragment( orderByFragment );
					}
				}
			}
		}
		finally {
			popFromClause();
		}
}

 protected  void pushFromClause(AST fromNode,
    AST inputFromNode) 
{
		FromClause newFromClause = ( FromClause ) fromNode;
		newFromClause.setParentFromClause( currentFromClause );
		currentFromClause = newFromClause;
}

Sets the current 'FROM' context.

 public  void reportError(RecognitionException e) 
{
		parseErrorHandler.reportError( e ); // Use the delegate.
}

 public  void reportError(String s) 
{
		parseErrorHandler.reportError( s ); // Use the delegate.
}

 public  void reportWarning(String s) 
{
		parseErrorHandler.reportWarning( s );
}

 protected  void resolve(AST node) throws SemanticException 
{
		if ( node != null ) {
			// This is called when it's time to fully resolve a path expression.
			ResolvableNode r = ( ResolvableNode ) node;
			if ( isInFunctionCall() ) {
				r.resolveInFunctionCall( false, true );
			}
			else {
				r.resolve( false, true );	// Generate implicit joins, only if necessary.
			}
		}
}

 protected  void resolveSelectExpression(AST node) throws SemanticException 
{
		// This is called when it's time to fully resolve a path expression.
		int type = node.getType();
		switch ( type ) {
			case DOT:
				DotNode dot = ( DotNode ) node;
				dot.resolveSelectExpression();
				break;
			case ALIAS_REF:
				// Notify the FROM element that it is being referenced by the select.
				FromReferenceNode aliasRefNode = ( FromReferenceNode ) node;
				//aliasRefNode.resolve( false, false, aliasRefNode.getText() ); //TODO: is it kosher to do it here?
				aliasRefNode.resolve( false, false ); //TODO: is it kosher to do it here?
				FromElement fromElement = aliasRefNode.getFromElement();
				if ( fromElement != null ) {
					fromElement.setIncludeSubclasses( true );
				}
			default:
				break;
		}
}

 protected  void setAlias(AST selectExpr,
    AST ident) 
{
        ((SelectExpression) selectExpr).setAlias(ident.getText());
}

 protected  void setImpliedJoinType(int joinType) 
{
		impliedJoinType = JoinProcessor.toHibernateJoinType( joinType );
}

 public static boolean supportsIdGenWithBulkInsertion(IdentifierGenerator generator) 
{
		return SequenceGenerator.class.isAssignableFrom( generator.getClass() )
		        || PostInsertIdentifierGenerator.class.isAssignableFrom( generator.getClass() );
}