[hibernate-commits] Hibernate SVN: r15748 - in core/branches/SQL_GEN_REDESIGN/src/main: java/org/hibernate/hql/ast/phase/parse and 1 other directories.

Tuesday, 6 January 2009

Author: steve.ebersole(a)jboss.com
Date: 2009-01-06 15:29:32 -0500 (Tue, 06 Jan 2009)
New Revision: 15748

Removed:
   core/branches/SQL_GEN_REDESIGN/src/main/antlr/hql/resolve.g
  
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/hql/ast/phase/parse/HqlParser.java
  
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/hql/ast/phase/parse/PathCollector.java
Modified:
  
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/normalize/CollectionPersisterReference.java
Log:
HHH-2407 : HQL translation rework ->
HHH-3687 : parse (phase1)
HHH-3688 : normalize (phase2)

Deleted: core/branches/SQL_GEN_REDESIGN/src/main/antlr/hql/resolve.g
===================================================================

--- core/branches/SQL_GEN_REDESIGN/src/main/antlr/hql/resolve.g	2009-01-06 20:11:13 UTC
(rev 15747)
+++ core/branches/SQL_GEN_REDESIGN/src/main/antlr/hql/resolve.g	2009-01-06 20:29:32 UTC
(rev 15748)
@@ -1,844 +0,0 @@
-header {
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
- * indicated by the @author tags or express copyright attribution
- * statements applied by the authors.  All third-party contributions are
- * distributed under license by Red Hat Middleware LLC.
- *
- * This copyrighted material is made available to anyone wishing to use, modify,
- * copy, or redistribute it subject to the terms and conditions of the GNU
- * Lesser General Public License, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this distribution; if not, write to:
- * Free Software Foundation, Inc.
- * 51 Franklin Street, Fifth Floor
- * Boston, MA  02110-1301  USA
- *
- * Portions of SQL grammar parsing copyright (C) 2003 by Lubos Vnuk.  All rights
- * reserved.  These portions are distributed under license by Red Hat Middleware
- * LLC and are covered by the above LGPL notice.  If you redistribute this material,
- * with or without modification, you must preserve this copyright notice in its
- * entirety.
- */
-package org.hibernate.hql.ast.phase.parse;
-import antlr.collections.AST;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-}
-
-/**
- * An Antlr tree parser for "resolving" or "normalizing" an HQL
syntax AST.  This
- * parser provides the vast majority of the semantic analysis of the HQL AST.
- * <p/>
- * Both "resolving" and "normalizing" here seek a single goal of
building a
- * dis-ambiguated, generic query AST.
- * <p/>
- * The act of resolving is essentially the process of simplifying complex node
- * structures into atomic components based on contextual information (aka, the
- * current parser state).  The main thrust of this process is breaking down
- * dot-structures (a series of DOT INDET pairs) into <ul>
- * <li>a series of "implicit" join structures injected into the from
clause tree</li>
- * <li>a simple structure representing the "meaning" of the
"leaf" of said dot-structure</li>
- * </ul>
- * <p/>
- * The act of normalizing essentially refers to the process of dis-ambiguating
- * node structures based on their context and creating a unified AST
- * representation for different ways to express the same "idea".  An example of
this
- * is normalizing implicit join dot-structures into a structure akin to its explicit
- * join corollary.
- *
- * @author Joshua Davis
- * @author Steve Ebersole
- */
-class GeneratedHqlResolver extends TreeParser;
-
-options {
-	importVocab=HqlParse;
-	exportVocab=HqlResolve;
-	buildAST=true;
-}
-
-tokens {
-	PROPERTY_REF;
-	ENTITY_PERSISTER_REF;
-	COLLECTION_PERSISTER_REF;
-	PERSISTER_ALIAS_REF;
-	BOGUS;
-
-//	SELECT_CLAUSE;
-}
-
-
-// -- Declarations --
-{
-    private static Logger log = LoggerFactory.getLogger( GeneratedHqlResolver.class );
-
-	private int ordinalParamCount = 0;
-
-    protected boolean isPersisterReferenceAlias(AST alias) {
-        return false;
-    }
-
-	protected AST resolveAlias(AST alias) {
-		return alias;
-	}
-
-    protected boolean isUnqualifiedPropertyReference(AST property) {
-        return false;
-    }
-
-    protected AST buildUnqualifiedPropertyReference(AST propertyNameNode) {
-        return propertyNameNode;
-    }
-
-    protected AST resolvePropertyPathTerminus(AST source, AST propertyNameNode) {
-        return propertyNameNode;
-    }
-
-    protected AST resolvePropertyPathIntermediary(AST source, AST propertyNameNode) {
-        return propertyNameNode;
-    }
-
-    protected void validateIndexOperationOperands(AST collectionPropertyRef, AST
selector) {
-    }
-
-    protected AST resolveQualifiedRoot(AST alias) {
-        return null;
-    }
-
-    protected AST resolveUnqualifiedRoot(AST alias) {
-        return null;
-    }
-
-    protected AST resolveIndexedRoot(AST alias) {
-        return null;
-    }
-
-
-	// Statement node BEGIN/END handling ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-	protected void pushStatement(AST statementNode) {
-	}
-
-	protected void popStatement() {
-	}
-
-
-	// property-path context pushing/popping ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-	protected void pushFromClausePropertyPathContext(AST joinType, AST fetch, AST alias, AST
propertyFetch) {
-	}
-
-	protected void popFromClausePropertyPathContext() {
-	}
-
-	protected void pushOnFragmentPropertyPathContext(AST rhsPersisterReference) {
-	}
-
-	protected void popOnFragmentPropertyPathContext() {
-	}
-
-	protected void pushWithFragmentPropertyPathContext(AST rhsPersisterReference) {
-	}
-
-	protected void popWithFragmentPropertyPathContext() {
-	}
-
-    protected void pushSelectClausePropertyPathContext() {
-    }
-
-    protected void popSelectClausePropertyPathContext() {
-    }
-
-
-	// persister reference handling ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-	protected AST buildEntityPersisterReference(AST entityName, AST alias, AST
propertyFetch) {
-		return entityName;
-	}
-
-	protected AST buildAdHocJoinNode(AST persisterReference, AST joinType, AST withFragment)
{
-		return persisterReference;
-	}
-
-	protected void applyWithFragment(AST withFragment) {
-	}
-
-
-	// parameter handling ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-	private AST generateNamedParameter(AST delim, AST name) throws SemanticException {
-		// use the source delim node to properly transfer line/column number information :(
-		AST param = #( delim );
-		param.setType( NAMED_PARAM );
-		param.setText( name.getText() );
-		return param;
-	}
-
-	private AST generateOrdinalParameter(AST source) throws SemanticException {
-		// use the source node to properly transfer line/column number information :(
-		AST param = #( source );
-		param.setType( ORDINAL_PARAM );
-		param.setText( Integer.toString( ordinalParamCount++ ) );
-		return param;
-	}
-
-    protected void injectSelectAlias( AST selectExpression, AST alias) {
-    }
-
-    protected void registerSelectExpression(AST selectExpression) {
-    }
-
-    protected AST handleSelectedPropertyRef(AST propertyRef) {
-        return propertyRef;
-    }
-}
-
-// Statement rules
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-/**
- * The main grammar rule
- */
-statement :
-    updateStatement
-    | deleteStatement
-    | insertStatement
-    | selectStatement
-;
-
-
-// <tt>UPDATE</tt> statement
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-/**
- * Recognize an <tt>UPDATE</tt> statement
- */
-updateStatement :
-    #(
-        UPDATE { pushStatement( #updateStatement ); }
-	        (VERSIONED)?
-	        ENTITY_NAME (ALIAS)?
-	        setClause
-	        (whereClause)? { popStatement(); }
-    )
-;
-
-setClause :
-    #( SET (assignment)+ )
-;
-
-assignment :
-    #( ASSIGNMENT_OP assignmentField newValue )
-;
-
-assignmentField :
-    propertyReference
-;
-
-newValue :
-    valueExpression
-;
-
-
-
-// <tt>DELETE</tt> statement
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-/**
- * Recognize an HQL <tt>DELETE</tt> statement
- */
-deleteStatement :
-    #(
-	    DELETE { pushStatement( #deleteStatement ); }
-	        ENTITY_NAME (ALIAS)?
-	        (whereClause)? { popStatement(); }
-    )
-;
-
-
-// <tt>INSERT</tt> statement
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-/**
- * Recognize an HQL <tt>INSERT</tt> statement
- */
-insertStatement :
-    #(
-        INSERT { pushStatement( #insertStatement ); }
-            intoClause
-            queryExpression { popStatement(); }
-    )
-;
-
-intoClause :
-    #( INTO ENTITY_NAME insertabilitySpecification )
-;
-
-insertabilitySpecification :
-    #( INSERTABILITY_SPEC (insertablePropertySpecification)+ )
-;
-
-/**
- * The property being inserted into.
- */
-insertablePropertySpecification :
-    IDENT
-;
-
-
-// <tt>SELECT</tt> statement rules
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-/**
- * Recognize an HQL <tt>SELECT</tt> statement.
- * <p/>
- * This corresponds most closely to the <cursor specification> rule in ISO/ANSI
SQL...
- */
-selectStatement :
-    #( QUERY queryExpression orderByClause )
-;
-
-orderByClause :
-    #( ORDER (sortSpecification)+ )
-;
-
-sortSpecification :
-    #( SORT_SPEC sortKey (collationSpecification)? (orderingSpecification)? )
-;
-
-sortKey :
-    // todo : do we want to explicitly limit these?
-    valueExpression
-;
-
-collationSpecification :
-    COLLATE
-;
-
-orderingSpecification :
-    ORDER_SPEC
-;
-
-queryExpression :
-    #(
-        QUERY { pushStatement( #queryExpression ); }
-            querySpec ( ( UNION | INTERSECT | EXCEPT ) (ALL)? querySpec )* {
popStatement( #queryExpression ); }
-    )
-;
-
-subquery :
-    queryExpression
-;
-
-querySpec :
-     selectFrom ( whereClause )? ( groupByClause ( havingClause )? )?
-;
-
-
-selectFrom! :
-    #( SELECT_FROM fromClause (selectClause)? )
-;
-
-fromClause :
-    #( FROM (persisterSpace)+ )
-;
-
-persisterSpace :
-    #( PERSISTER_SPACE entityPersisterReference ( qualifiedJoin | crossJoin )* )
-;
-
-entityPersisterReference! :
-    en:ENTITY_NAME (a:ALIAS)? (pf:PROP_FETCH)? {
-		#entityPersisterReference = buildEntityPersisterReference( en, a, pf );
-	}
-;
-
-crossJoin :
-    #( JOIN CROSS entityPersisterReference )
-;
-
-qualifiedJoin :
-    #(
-		j:JOIN (jt:nonCrossJoinType)? (
-            e:entityPersisterReference (on:onFragment[#e])? {
-                buildAdHocJoinNode( #e, #jt, #on );
-                if ( on != null ) {
-                    popOnFragmentPropertyPathContext();
-                }
-            }
-            | (f:FETCH)? (a:ALIAS)? (pf:PROP_FETCH)? { pushFromClausePropertyPathContext(
jt, #f, #a, #pf ); } prop:propertyRef (with:withFragment[#prop])? {
-                popFromClausePropertyPathContext();
-            }
-        )
-	)
-;
-
-nonCrossJoinType :
-    ( (LEFT | RIGHT) (OUTER)? )
-	| INNER
-	;
-
-onFragment[ AST rhsPersisterReference ]
-	: #( o:ON { pushOnFragmentPropertyPathContext( rhsPersisterReference ); } le:logicalExpr
) {
-		#onFragment = #( o, le );
-	}
-	;
-
-withFragment[ AST rhsPropertyReference ]
-	: #( w:WITH { pushWithFragmentPropertyPathContext( rhsPropertyReference ); }
le:logicalExpr ) {
-		#withFragment = #( w, le );
-		applyWithFragment( #withFragment );
-		popWithFragmentPropertyPathContext();
-	}
-	;
-
-
-
-
-
-
-
-
-
-
-
-
-///////////////////////////////////////////////////////////////////////////////
-// The statement sub-rules
-
-selectStatement :
-    query ( ( m:MINUS | u:UNION ) (a:ALL)? query )*
-;
-
-
-
-
-///////////////////////////////////////////////////////////////////////////////
-
-query
-	: #(QUERY { pushStatement( #query ); }
-			// The first phase places the FROM first to make processing the SELECT simpler.
-			#( SELECT_FROM fromClause (selectClause)? )
-			(whereClause)?
-			(groupClause)?
-			(orderClause)? {
-				popStatement();
-			}
-		)
-	;
-
-selectClause
-	: #( SELECT { pushSelectClausePropertyPathContext(); } ( d:DISTINCT )? x:selectExprList
) {
-		#selectClause = #([SELECT_CLAUSE,"{select clause}"], #d, #x);
-		popSelectClausePropertyPathContext();
-	}
-	;
-
-selectExprList
-    : ( selectExprValue )+
-    ;
-
-selectExprValue
-    : ( selectExpr | aliasedSelectExpr ) {
-        registerSelectExpression( #selectExprValue );
-    }
-    ;
-
-aliasedSelectExpr
-	: #( AS se:selectExpr i:identifier! ) {
-	    injectSelectAlias( #se, #i );
-		#aliasedSelectExpr = #se;
-	}
-    ;
-
-// TODO : the old grammar had both literal and constant available as select expressions,
but that is probably not valid; it is certainly not valid for non-subqueries
-selectExpr
-    : (persisterReferenceAliasCheck) => persisterRefRef
-    | pr:propertyRef { #selectExpr = handleSelectedPropertyRef( #pr ); }
-    | arithmeticExpr
-    | count
-    | literal
-    | constant
-    ;
-
-persisterRefRef!
-    : alias:IDENT {
-        #persisterRefRef = #( [ PERSISTER_REF_REF, alias.getText() ] ); 
-    }
-    ;
-
-count
-	: #(COUNT ( DISTINCT | ALL )? ( propertyRef | literal | ROW_STAR ) )
-	;
-
-fromClause
-	: #( f:FROM rootFromElement ( explicitJoin | rootFromElement )* )
-	;
-
-rootFromElement!
-	: #( RANGE e:entityPersisterReference ) {
-		#rootFromElement = #e;
-	}
-	;
-
-entityPersisterReference!
-	: en:ENTITY_NAME (a:ALIAS)? (pf:PROP_FETCH)? {
-		#entityPersisterReference = buildEntityPersisterReference( en, a, pf );
-	}
-	;
-
-explicitJoin!
-	: #(
-		j:JOIN (jt:joinType)?
-			(
-				e:entityPersisterReference (on:onFragment[#e])? {
-					buildAdHocJoinNode( #e, #jt, #on );
-					if ( on != null ) {
-						popOnFragmentPropertyPathContext();
-					}
-				}
-				| (f:FETCH)? (a:ALIAS)? (pf:PROP_FETCH)? { pushFromClausePropertyPathContext( jt, #f,
#a, #pf ); } prop:propertyRef (with:withFragment[#prop])? {
-					popFromClausePropertyPathContext();
-				}
-			)
-	)
-	;
-
-
-///////////////////////////////////////////////////////////////////////////////
-// propertyRef related rules...
-//
-
-/**
- * The top level property ref recognition rule.
- */
-propertyRef
-    : (unqualifiedPropertyRefCheck) => unqualifiedPropertyRef
-    | implicitJoin
-    | indexOperation
-    ;
-
-/**
- * A rule utilizing a validating semantic predicate to contextually
- * ensure that we have unqualified property reference.  Generally
- * used from within syntactic predicates to disambiguate the match path
- *
- * see {@link #implicitJoinSource} for example
- */
-unqualifiedPropertyRefCheck!
-    : prop:IDENT { isUnqualifiedPropertyReference( prop ) }?
-    ;
-
-/**
- * AST construction rule for building AST relating to *known*
- * unqualified property references.  Do not call this rule unless
- * you know for certain (ala, have verified via the unqualifiedPropertyRefCheck
- * rule or similiar) that the next token is an IDENT representing an
- * unqualified property reference.
- */
-unqualifiedPropertyRef!
-    : prop:IDENT {
-        #unqualifiedPropertyRef = buildUnqualifiedPropertyReference( prop );
-    }
-    ;
-
-/**
- * A rule utilizing a validating semantic predicate to contextually
- * ensure that we have an alias for a persister reference previously
- * encountered and processed.  Generally used from within syntactic
- * predicates to disambiguate the path.
- */
-persisterReferenceAliasCheck!
-    : alias:IDENT { isPersisterReferenceAlias( alias ) }?
-    ;
-
-/**
- * AST construction rule for building AST relating to *known*
- * persister reference aliases.  Do not call this rule unless
- * you know for certain (ala, have verified via the persisterReferenceAliasCheck
- * rule or similiar) that the next token is an IDENT representing an
- * alias for a persister reference
- */
-persisterReferenceAlias!
-    : alias:IDENT {
-        #persisterReferenceAlias = resolveAlias( alias );
-    }
-    ;
-
-/**
- * Perhaps better named as 'complex property ref' or 'pathed property
ref' i.e.
- * Anyway, the basic idea is (DOT <source> IDENT)
- */
-implicitJoin!
-    : #( d:DOT source:implicitJoinSource prop:IDENT) {
-        #implicitJoin = resolvePropertyPathTerminus( #source, #prop );
-    }
-    ;
-
-intermediateImplicitJoin!
-    : #( d:DOT source:implicitJoinSource prop:IDENT) {
-        #intermediateImplicitJoin = resolvePropertyPathIntermediary( #source, #prop );
-    }
-    ;
-
-/**
- * The output of the implicitJoinSource rule is a {@link
org.hibernate.sql.ast.phase.resolve.patg.PropertyPathPart}
- * reference which is a tokenized and encoded representation of the current path
expression
- * resolution state.
- */
-implicitJoinSource
-    : (persisterReferenceAliasCheck) => a:IDENT { #implicitJoinSource =
resolveQualifiedRoot( #a ); }
-    | (unqualifiedPropertyRefCheck) => pr:IDENT { #implicitJoinSource =
resolveUnqualifiedRoot( #pr ); }
-    | intermediateImplicitJoin
-    | i:indexOperation { #implicitJoinSource = resolveIndexedRoot( #i ); }
-    ;
-
-indexOperation
-    : #( i:INDEX_OP coll:propertyRef selector:indexSelector ) {
-        validateIndexOperationOperands( #coll, #selector );
-    }
-    ;
-
-indexSelector
-	: constant
-	| parameter
-	| arithmeticExpr
-	| collectionFunctionCall
-	;
-
-//
-// <end> propertyRef related rules...
-///////////////////////////////////////////////////////////////////////////////
-
-collectionFunctionCall
-	: #( METHOD_CALL pathAsIdent ( #(EXPR_LIST alias ) )? )
-	;
-
-alias!
-	: i:identifier {
-		#alias = resolveAlias( i );
-	}
-	;
-
-joinType
-	: ( (LEFT | RIGHT) (OUTER)? )
-	| FULL
-	| INNER
-	;
-
-onFragment[ AST rhsPersisterReference ]
-	: #( o:ON { pushOnFragmentPropertyPathContext( rhsPersisterReference ); } le:logicalExpr
) {
-		#onFragment = #( o, le );
-	}
-	;
-
-withFragment[ AST rhsPropertyReference ]
-	: #( w:WITH { pushWithFragmentPropertyPathContext( rhsPropertyReference ); }
le:logicalExpr ) {
-		#withFragment = #( w, le );
-		applyWithFragment( #withFragment );
-		popWithFragmentPropertyPathContext();
-	}
-	;
-
-
-intoClause
-	: #(i:INTO (subtree)* )
-	;
-
-whereClause
-	: #(WHERE logicalExpr )
-	;
-
-groupClause
-	: #(GROUP (subtree)* )
-	;
-
-orderClause
-	: #(ORDER (subtree)* )
-	;
-
-
-logicalExpr
-	: #(AND logicalExpr logicalExpr)
-	| #(OR logicalExpr logicalExpr)
-	| #(NOT logicalExpr)
-	| comparisonExpr
-	;
-
-comparisonExpr
-	:
-	( #(EQ exprOrSubquery exprOrSubquery)
-	| #(NE exprOrSubquery exprOrSubquery)
-	| #(LT exprOrSubquery exprOrSubquery)
-	| #(GT exprOrSubquery exprOrSubquery)
-	| #(LE exprOrSubquery exprOrSubquery)
-	| #(GE exprOrSubquery exprOrSubquery)
-	| #(LIKE exprOrSubquery expr ( #(ESCAPE expr) )? )
-	| #(NOT_LIKE exprOrSubquery expr ( #(ESCAPE expr) )? )
-	| #(BETWEEN exprOrSubquery exprOrSubquery exprOrSubquery)
-	| #(NOT_BETWEEN exprOrSubquery exprOrSubquery exprOrSubquery)
-	| #(IN exprOrSubquery inRhs )
-	| #(NOT_IN exprOrSubquery inRhs )
-	| #(IS_NULL exprOrSubquery)
-	| #(IS_NOT_NULL exprOrSubquery)
-	| #(EXISTS ( expr | collectionFunctionOrSubselect ) )
-	)
-	;
-
-inRhs
-	: #(IN_LIST ( collectionFunctionOrSubselect | ( (expr)* ) ) )
-	;
-
-exprOrSubquery
-	: expr
-	| query
-	| #(ANY collectionFunctionOrSubselect)
-	| #(ALL collectionFunctionOrSubselect)
-	| #(SOME collectionFunctionOrSubselect)
-	;
-
-collectionFunctionOrSubselect
-	: collectionFunction
-	| query
-	;
-
-collectionFunction
-	: #( ELEMENTS propertyRef )
-	| #( INDICES propertyRef )
-	;
-
-aggregateExpr
-	: expr
-	| collectionFunction
-	;
-
-expr
-	: addrExpr
-	| #( VECTOR_EXPR (expr)* )
-	| constant
-	| arithmeticExpr
-	| functionCall								// Function call, not in the SELECT clause.
-	| parameter
-	| count										// Count, not in the SELECT clause.
-	;
-
-arithmeticExpr
-	: #(PLUS expr expr)
-	| #(MINUS expr expr)
-	| #(DIV expr expr)
-	| #(STAR expr expr)
-	| #(UNARY_MINUS expr)
-	| caseExpr
-	;
-
-caseExpr
-	: #(CASE (#(WHEN logicalExpr expr))+ (#(ELSE expr))?)
-	| #(CASE2 expr (#(WHEN expr expr))+ (#(ELSE expr))?)
-	;
-
-//addrExpr
-//	: propertyRef
-//	| #(INDEX_OP addrExprLhs expr)
-//	;
-
-addrExpr
-	: propertyRef
-	;
-
-addrExprLhs
-	: addrExpr
-	;
-
-constant
-	: NULL
-	| TRUE
-	| FALSE
-	| javaConstant
-	;
-
-javaConstant
-    : JAVA_CONSTANT
-    ;
-
-literal
-	: NUM_INT
-	| NUM_LONG
-	| NUM_FLOAT
-	| NUM_DOUBLE
-	| QUOTED_STRING
-	;
-
-parameter!
-	: #( c:COLON (c2:COLON)? i:identifier ) {
-		if ( c2 != null ) {
-			// allows escaping the colon...
-			String text = ":" + i.getText();
-			#parameter = #( [IDENT, text] );
-		}
-		else {
-			#parameter = generateNamedParameter( c, i );
-		}
-	}
-	| #( p:PARAM (n:NUM_INT)? ) {
-		if ( n != null ) {
-			// An ejb3-style "positional parameter", which we handle internally as a
named-parameter
-			#parameter = generateNamedParameter( p, n );
-		}
-		else {
-			#parameter = generateOrdinalParameter( p );
-		}
-	}
-	;
-
-functionCall
-	: #(METHOD_CALL pathAsIdent ( #(EXPR_LIST (expr)* ) )? )
-	| #(AGGREGATE aggregateExpr )
-	;
-
-//propertyRef
-//	: propertyPath
-//	;
-
-propertyName
-	: identifier
-	| CLASS
-	| ELEMENTS
-	| INDICES
-	;
-
-// Matches a path and returns the normalized string for the path (usually
-// fully qualified a class name).
-pathAsString returns [String p] {
-	p = "???";
-	String x = "?x?";
-	}
-	: a:identifier { p = a.getText(); }
-	| #(DOT x=pathAsString y:identifier) {
-			StringBuffer buf = new StringBuffer();
-			buf.append(x).append(".").append(y.getText());
-			p = buf.toString();
-		}
-	;
-
-// Returns a path as a single identifier node.
-pathAsIdent {
-    String text = "?text?";
-    }
-    : text=pathAsString {
-        #pathAsIdent = #([IDENT,text]);
-    }
-    ;
-
-identifier
-	: (IDENT | WEIRD_IDENT)
-	;
-
-// General subtree.  Matches anything, copies the tree verbatim.
-subtree
-	: #(. (subtree)*)
-	;

Deleted:
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/hql/ast/phase/parse/HqlParser.java
===================================================================
---
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/hql/ast/phase/parse/HqlParser.java	2009-01-06
20:11:13 UTC (rev 15747)
+++
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/hql/ast/phase/parse/HqlParser.java	2009-01-06
20:29:32 UTC (rev 15748)
@@ -1,623 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
- * indicated by the @author tags or express copyright attribution
- * statements applied by the authors.  All third-party contributions are
- * distributed under license by Red Hat Middleware LLC.
- *
- * This copyrighted material is made available to anyone wishing to use, modify,
- * copy, or redistribute it subject to the terms and conditions of the GNU
- * Lesser General Public License, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this distribution; if not, write to:
- * Free Software Foundation, Inc.
- * 51 Franklin Street, Fifth Floor
- * Boston, MA  02110-1301  USA
- */
-package org.hibernate.hql.ast.phase.parse;
-
-import org.hibernate.sql.ast.util.ASTUtil;
-import org.hibernate.sql.ast.util.ASTPrinter;
-import org.hibernate.sql.ast.util.ErrorCounter;
-import org.hibernate.sql.ast.util.ParseErrorHandler;
-import org.hibernate.QueryException;
-import org.hibernate.MappingException;
-import org.hibernate.persister.entity.EntityPersister;
-import org.hibernate.engine.SessionFactoryImplementor;
-import org.hibernate.sql.ast.common.CommonHibernateLexer;
-import org.hibernate.sql.ast.common.TokenImpl;
-import org.hibernate.sql.ast.common.Node;
-import org.hibernate.util.ReflectHelper;
-import org.hibernate.util.StringHelper;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.StringReader;
-import java.io.PrintStream;
-import java.io.PrintWriter;
-
-import antlr.collections.AST;
-import antlr.RecognitionException;
-import antlr.TokenStreamException;
-import antlr.Token;
-import antlr.ASTPair;
-import antlr.MismatchedTokenException;
-import antlr.SemanticException;
-import antlr.ASTFactory;
-
-/**
- * The parser used by Hibernate to generate an AST given an input
- * HQL string (a "stream parser").  The produced AST is then used
- * (and mutated) by later phases/parsers to apply semantic resolution;
- * this parser, however, is all about syntax resolution.
- *
- * @author Steve Ebersole
- */
-public class HqlParser extends GeneratedHqlParser {
-	private static final Logger log = LoggerFactory.getLogger( HqlParser.class );
-
-	private final Context context;
-	private final ParseErrorHandler parseErrorHandler = new ErrorCounter();
-	private final ASTPrinter printer = new ASTPrinter( HqlParseTokenTypes.class );
-	private int traceDepth = 0;
-
-	public static interface Context {
-		/**
-		 * Does this name represent an entity name?
-		 *
-		 * @param name The name to check
-		 * @return True if the name represents an entioty name; false otherwise.
-		 */
-		public boolean isEntityName(String name);
-
-		/**
-		 * Get the import "replacement" name for the given name (e.g., 'User'
-> 'com.acme.User').  <tt>null</tt>
-		 * indicates an unrecognized name.
-		 *
-		 * @param name The name for which to locate the imported name.
-		 * @return The corresponding imported name, or null.
-		 */
-		public String getImportedName(String name);
-
-		/**
-		 * Does the given name represent a registered function name?
-		 *
-		 * @param name The name to check
-		 * @return True if the name matches a registered function name; false otherwise.
-		 */
-		public boolean isRegisteredFunctionName(String name);
-	}
-
-	public HqlParser(String hql, Context context) {
-		super( new CommonHibernateLexer( new StringReader( hql ) ) );
-		this.context = context;
-		super.setASTFactory( new ASTFactoryImpl() );
-	}
-
-	public HqlParser(String hql, final SessionFactoryImplementor sessionFactoryImplementor)
{
-		this(
-				hql,
-				new Context() {
-					public boolean isEntityName(String name) {
-						return findEntityPersisterByName( name ) != null;
-					}
-
-					public String getImportedName(String name) {
-						return sessionFactoryImplementor.getImportedClassName( name );
-					}
-
-					public boolean isRegisteredFunctionName(String name) {
-						return sessionFactoryImplementor.getDialect().getFunctions().get( name ) != null;
-					}
-
-					private EntityPersister findEntityPersisterByName(String name) throws
MappingException {
-						try {
-							return sessionFactoryImplementor.getEntityPersister( name );
-						}
-						catch ( MappingException ignore ) {
-							// unable to locate it using this name
-						}
-
-						// If that didn't work, try using the 'import' name.
-						String importedClassName = sessionFactoryImplementor.getImportedClassName( name );
-						if ( importedClassName == null ) {
-							return null;
-						}
-						return sessionFactoryImplementor.getEntityPersister( importedClassName );
-					}
-				}
-		);
-	}
-
-
-	// overrides of Antlr infastructure methods ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-	public void reportError(RecognitionException e) {
-		parseErrorHandler.reportError( e );
-	}
-
-	public void reportError(String s) {
-		parseErrorHandler.reportError( s );
-	}
-
-	public void reportWarning(String s) {
-		parseErrorHandler.reportWarning( s );
-	}
-
-	public ParseErrorHandler getParseErrorHandler() {
-		return parseErrorHandler;
-	}
-
-	static public void panic() {
-		//overriden to avoid System.exit
-		throw new QueryException( "Parser: panic" );
-	}
-
-	public void setASTFactory(ASTFactory astFactory) {
-		throw new UnsupportedOperationException( "not allowed!" );
-	}
-
-
-// various AST output methods ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-	public void traceIn(String s) throws TokenStreamException {
-		if ( inputState.guessing > 0 ) {
-			return;
-		}
-		String prefix = StringHelper.repeat( "-", (traceDepth++ * 2) ) +
"->";
-		trace( prefix + s );
-	}
-
-	public void traceOut(String s) throws TokenStreamException {
-		if ( inputState.guessing > 0 ) {
-			return;
-		}
-		String prefix = "<-" + StringHelper.repeat( "-", (--traceDepth *
2) );
-		trace( prefix + s );
-	}
-
-    private void trace(String msg) {
-		System.out.println( msg );
-//		log.trace( msg );
-	}
-
-	public void dumpAst(AST ast) {
-		dumpAst( ast, "DUMP" );
-	}
-
-	public void dumpAst(AST ast, String header) {
-		log.info( printer.showAsString( ast, header ) );
-	}
-
-	public void showAst(AST ast, PrintStream out) {
-		showAst( ast, new PrintWriter( out ) );
-	}
-
-	private void showAst(AST ast, PrintWriter pw) {
-		printer.showAst( ast, pw );
-	}
-
-
-	// overrides of grammar semantic actions ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-	public String extractPath(AST tree) {
-		try {
-			return PathCollector.getPath( tree );
-		}
-		catch ( Throwable t ) {
-			return tree.getText();
-		}
-	}
-
-	public boolean isRegisteredFunction(AST tree) {
-		return context.isRegisteredFunctionName( extractPath( tree ) );
-	}
-
-	public boolean isJavaConstant(String path) {
-		try {
-			log.debug( "Testing path [" + path + "] as potential java
constant" );
-			Object value = ReflectHelper.getConstantValueStrictly( path );
-			log.debug( "Resolved path to java constant [" + value + "]" );
-			return true;
-		}
-		catch( Throwable t ) {
-			log.debug( "Path did not resolve to java constant : " + t );
-			return false;
-		}
-	}
-
-	public String resolveEntityName(String name) {
-		return context.getImportedName( name );
-	}
-
-	public String resolveDynamicInstantiationPojoName(AST name) throws SemanticException {
-		String path = extractPath( name );
-		if ( "list".equals( path ) || "map".equals( path ) ) {
-			return path;
-		}
-		else {
-			String importedName = context.getImportedName( path );
-			try {
-				Class importedClass = ReflectHelper.classForName( importedName );
-				return importedClass.getName();
-			}
-			catch ( ClassNotFoundException e ) {
-				throw new SemanticException( "Unable to locate dynamic instantiation class
[" + importedName + "]" );
-			}
-		}
-	}
-
-	protected AST processEqualityExpression(AST x) {
-		if ( x == null ) {
-			log.warn( "processEqualityExpression() : No expression to process!" );
-			return null;
-		}
-
-		int type = x.getType();
-		if ( log.isTraceEnabled() ) {
-			log.trace( "processEqualityExpression() -> type : {}, name : {}",
Integer.toString( type ), ASTUtil.getTokenTypeName( HqlParseTokenTypes.class, type ) );
-		}
-		if ( type == EQUALS_OP || type == NOT_EQUALS_OP || type == SQL_NOT_EQUALS_OP ) {
-			boolean negated = ( type != EQUALS_OP );
-			if ( x.getNumberOfChildren() == 2 ) {
-				AST a = x.getFirstChild();
-				AST b = a.getNextSibling();
-				// (EQ NULL b) => (IS_NULL b)
-				if ( a.getType() == NULL && b.getType() != NULL ) {
-					return createIsNullParent( b, negated );
-				}
-				// (EQ a NULL) => (IS_NULL a)
-				else if ( b.getType() == NULL && a.getType() != NULL ) {
-					return createIsNullParent( a, negated );
-				}
-				else if ( b.getType() == EMPTY ) {
-					return processIsEmpty( a, negated );
-				}
-				else {
-					return x;
-				}
-			}
-			else {
-				return x;
-			}
-		}
-		else {
-			return x;
-		}
-	}
-
-	private AST createIsNullParent(AST node, boolean negated) {
-		node.setNextSibling( null );
-		int type = negated ? IS_NOT_NULL : IS_NULL;
-		String text = negated ? "is not null" : "is null";
-		return ASTUtil.createParent( astFactory, type, text, node );
-	}
-
-	protected AST processMemberOf(AST path, AST notNode) {
-		AST inNode = notNode == null ? astFactory.create( IN, "in" ) :
astFactory.create( NOT_IN, "not in" );
-		AST subqueryNode = createSubquery( path );
-		AST inListNode = ASTUtil.createParent( astFactory, IN_LIST, "in-list",
subqueryNode );
-		inNode.addChild( inListNode );
-		return inNode;
-	}
-
-	private AST createSubquery(AST subquerySource) {
-//		AST ast = ASTUtil.createParent( astFactory, RANGE, "RANGE", node );
-// todo : what is the type of 'node'?
-		log.debug(
-				"Generating subquery; incoming node type = {}; incoming node = [{}]",
-				printer.getTokenTypeName( subquerySource.getType() ),
-				subquerySource
-		);
-		AST fromNode = ASTUtil.createParent( astFactory, FROM, "from", subquerySource
);
-		AST selectFromNode = ASTUtil.createParent( astFactory, SELECT_FROM,
"SELECT_FROM", fromNode );
-		return ASTUtil.createParent( astFactory, QUERY, "QUERY", selectFromNode );
-	}
-
-	protected AST processIsEmpty(AST collection, AST notToken) {
-		return processIsEmpty( collection, notToken != null );
-	}
-
-	private AST processIsEmpty(AST node, boolean negated) {
-		node.setNextSibling( null );
-		AST ast = createSubquery( node );
-		ast = ASTUtil.createParent( astFactory, EXISTS, "exists", ast );
-		// Add NOT if it's negated.
-		if ( negated ) {
-			ast = ASTUtil.createParent( astFactory, NOT, "not", ast );
-		}
-		return ast;
-	}
-	public AST negateNode(AST x) {
-		//TODO: switch statements are always evil! We already had bugs because
-		//      of forgotten token types. Use polymorphism for this!
-		switch ( x.getType() ) {
-			case OR:
-				x.setType(AND);
-				x.setText("{and}");
-				negateNode( x.getFirstChild() );
-				negateNode( x.getFirstChild().getNextSibling() );
-				return x;
-			case AND:
-				x.setType(OR);
-				x.setText("{or}");
-				negateNode( x.getFirstChild() );
-				negateNode( x.getFirstChild().getNextSibling() );
-				return x;
-			case EQUALS_OP:
-				x.setType( NOT_EQUALS_OP );
-				x.setText( "{not}" + x.getText() );
-				return x;	// (NOT (EQ a b) ) => (NE a b)
-			case NOT_EQUALS_OP:
-				x.setType( EQUALS_OP );
-				x.setText( "{not}" + x.getText() );
-				return x;	// (NOT (NE a b) ) => (EQ a b)
-			case GREATER_THAN_OP:
-				x.setType( LESS_THAN_OR_EQUALS_OP );
-				x.setText( "{not}" + x.getText() );
-				return x;	// (NOT (GT a b) ) => (LE a b)
-			case LESS_THAN_OP:
-				x.setType( GREATER_THAN_OR_EQUALS_OP );
-				x.setText( "{not}" + x.getText() );
-				return x;	// (NOT (LT a b) ) => (GE a b)
-			case GREATER_THAN_OR_EQUALS_OP:
-				x.setType( LESS_THAN_OP );
-				x.setText( "{not}" + x.getText() );
-				return x;	// (NOT (GE a b) ) => (LT a b)
-			case LESS_THAN_OR_EQUALS_OP:
-				x.setType( GREATER_THAN_OP );
-				x.setText( "{not}" + x.getText() );
-				return x;	// (NOT (LE a b) ) => (GT a b)
-			case LIKE:
-				x.setType( NOT_LIKE );
-				x.setText( "{not}" + x.getText() );
-				return x;	// (NOT (LIKE a b) ) => (NOT_LIKE a b)
-			case NOT_LIKE:
-				x.setType( LIKE );
-				x.setText( "{not}" + x.getText() );
-				return x;	// (NOT (NOT_LIKE a b) ) => (LIKE a b)
-			case IN:
-				x.setType( NOT_IN );
-				x.setText( "{not}" + x.getText() );
-				return x;
-			case NOT_IN:
-				x.setType( IN );
-				x.setText( "{not}" + x.getText() );
-				return x;
-			case IS_NULL:
-				x.setType( IS_NOT_NULL );
-				x.setText( "{not}" + x.getText() );
-				return x;	// (NOT (IS_NULL a b) ) => (IS_NOT_NULL a b)
-			case IS_NOT_NULL:
-				x.setType( IS_NULL );
-				x.setText( "{not}" + x.getText() );
-				return x;	// (NOT (IS_NOT_NULL a b) ) => (IS_NULL a b)
-			case BETWEEN:
-				x.setType( NOT_BETWEEN );
-				x.setText( "{not}" + x.getText() );
-				return x;	// (NOT (BETWEEN a b) ) => (NOT_BETWEEN a b)
-			case NOT_BETWEEN:
-				x.setType( BETWEEN );
-				x.setText( "{not}" + x.getText() );
-				return x;	// (NOT (NOT_BETWEEN a b) ) => (BETWEEN a b)
-			case NOT:
-				return x.getFirstChild();			// (NOT (NOT x) ) => (x)
-			default:
-				return super.negateNode( x );		// Just add a 'not' parent.
-		}
-	}
-
-	protected void transferTrackingInfo(AST source, AST target) {
-		if ( target instanceof Node ) {
-			( ( Node ) target ).transferTrackingInfo( source );
-		}
-		else {
-			super.transferTrackingInfo( source, target );
-		}
-	}
-
-	/**
-	 * Overrides the base behavior to retry keywords as identifiers.
-	 *
-	 * @param token The token.
-	 * @param ex    The recognition exception.
-	 * @return AST - The new AST.
-	 * @throws antlr.RecognitionException if the substitution was not possible.
-	 * @throws antlr.TokenStreamException if the substitution was not possible.
-	 */
-	public AST handleIdentifierError(Token token, RecognitionException ex) throws
RecognitionException, TokenStreamException {
-		// If the token can tell us if it could be an identifier...
-		if ( token instanceof TokenImpl ) {
-			TokenImpl hqlToken = ( TokenImpl ) token;
-			// ... and the token could be an identifer and the error is
-			// a mismatched token error ...
-			if ( hqlToken.isPossibleIdentifier() && ex instanceof MismatchedTokenException
) {
-				MismatchedTokenException mte = ( MismatchedTokenException ) ex;
-				// ... and the expected token type was an identifier, then:
-				if ( mte.expecting == IDENT ) {
-					// Use the token as an identifier.
-					reportWarning(
-							"Keyword  '"+ token.getText()
-							+ "' is being interpreted as an identifier due to: "
-							+ mte.getMessage()
-					);
-					// Add the token to the AST.
-					ASTPair currentAST = new ASTPair();
-//					token.setType( WEIRD_IDENT );
-					token.setType( IDENT );
-					astFactory.addASTChild( currentAST, astFactory.create( token ) );
-					consume();
-					return currentAST.root;
-				}
-			}
-		}
-		return super.handleIdentifierError( token, ex );
-	}
-
-    public void handleDotIdent() throws TokenStreamException {
-        // This handles HHH-354, where there is a strange property name in a where
clause.
-        // If the lookahead contains a DOT then something that isn't an IDENT...
-		handleDotIdent( 1 );
-    }
-
-	protected int handleDotIdent(int offset) throws TokenStreamException {
-		while ( LA( offset ) == DOT ) {
-			switch ( LA( offset+1 ) ) {
-				case IDENT:
-				case CLASS:
-					break; // break the case statement, not the loop...
-				default:
-					convertPossibleIdentifier( ( TokenImpl ) LT( offset+1 ) );
-			}
-			offset += 2;
-		}
-		return offset;
-	}
-
-	protected void weakKeywords() throws TokenStreamException {
-		switch ( LA( 1 ) ) {
-			case ORDER:
-			case GROUP:
-                // Case 1: Multi token keywords GROUP BY and ORDER BY
-				// The next token ( LT(2) ) should be 'by'... otherwise, this is just an
ident.
-				if ( LA( 2 ) != BY ) {
-					convertPossibleIdentifier( ( TokenImpl ) LT(1) );
-				}
-				break;
-			case IDENT:
-				break;
-			default :
-				if ( LA(0) == FROM && LA(2) == DOT ) {
-					convertPossibleIdentifier( ( TokenImpl ) LT(1) );
-				}
-		}
-	}
-
-	protected void unequivocalKeywordAsIdentifier() throws TokenStreamException {
-		if ( LA(1) == IDENT ) {
-			return;
-		}
-		convertPossibleIdentifier( ( TokenImpl ) LT(1) );
-	}
-
-    protected void potentialUpdatePersisterAlias() throws TokenStreamException {
-		switch( LA(1) ) {
-			case AS:
-				// alias rule will handle this...
-			case SET:
-				// SET marks the beginning of the UPDATE's SET-clause
-				break;
-			default:
-				convertPossibleIdentifier( ( TokenImpl ) LT(1) );
-		}
-	}
-
-    protected void potentialDeletePersisterAlias() throws TokenStreamException {
-		switch( LA(1) ) {
-			case AS:
-				// alias rule will handle this...
-			case WHERE:
-				break;
-			default:
-				convertPossibleIdentifier( ( TokenImpl ) LT(1) );
-		}
-    }
-
-    protected void prepareForPersisterReferenceRoot() throws TokenStreamException {
-		if ( LA(1) == IN ) {
-			return;
-		}
-
-		unequivocalKeywordAsIdentifier();
-
-		if ( LA(1) == IDENT && LA(2) == IN ) {
-			return;
-		}
-
-		prepareForBasicEntityPersisterReference();
-	}
-
-    protected void prepareForCrossJoinElements() throws TokenStreamException {
-		unequivocalKeywordAsIdentifier();
-		prepareForBasicEntityPersisterReference();
-    }
-
-	protected void prepareForBasicEntityPersisterReference() throws TokenStreamException {
-		int offset = handleDotIdent( 2 );
-		int next = LA(offset);
-		switch ( next ) {
-			case AS: {
-				// the next token would need to be the persister alias
-				convertPossibleIdentifier( (TokenImpl) LT(offset+1) );
-				break;
-			}
-			case IDENT : {
-				// nothing to do
-				break;
-			}
-			case WHERE:
-			case COMMA:
-			case ON:
-			case WITH:
-			case JOIN:
-			case RIGHT:
-			case LEFT:
-			case CROSS: {
-				// single token structural elements indicating that the next thing could not be an
alias
-				break;
-			}
-			case UNION:
-			case INTERSECT:
-			case EXCEPT: {
-				int nextNext = LA(offset+1);
-				if ( nextNext == SELECT || nextNext == FROM ) {
-					break;
-				}
-				else if ( nextNext == ALL ) {
-					int nextNextNext = LA(offset+2);
-					if ( nextNextNext == SELECT || nextNextNext == FROM ) {
-						break;
-					}
-				}
-				convertPossibleIdentifier( ( TokenImpl ) LT(offset) );
-				break;
-			}
-			case GROUP:
-			case ORDER:
-				if ( LA(offset+1) != BY ) {
-					convertPossibleIdentifier( ( TokenImpl ) LT(offset) );
-				}
-				break;
-			case FETCH:
-				if ( ! ( LA(offset+1) == ALL && LA(offset+2) == PROPERTIES ) ) {
-					// not sure sure I like allowing 'fetch' as an indentifier
-					log.warn( "interpretting [fetch] keyword as alias; consider using differen
alias" );
-					convertPossibleIdentifier( ( TokenImpl ) LT(offset) );
-				}
-				break;
-			default:
-				convertPossibleIdentifier( ( TokenImpl ) LT(offset) );
-				break;
-		}
-	}
-
-	protected void prepareForQualifiedJoinElements() throws TokenStreamException {
-		unequivocalKeywordAsIdentifier();
-		prepareForBasicEntityPersisterReference();
-    }
-
-	protected void convertPossibleIdentifier(TokenImpl token) {
-		if ( token.isPossibleIdentifier() ) {
-			token.setType( IDENT );
-			log.debug( "Converting keyword-to-identifier [{}]; [id={}]", token, new
Integer(System.identityHashCode( token ) ) );
-		}
-	}
-}

Deleted:
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/hql/ast/phase/parse/PathCollector.java
===================================================================
---
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/hql/ast/phase/parse/PathCollector.java	2009-01-06
20:11:13 UTC (rev 15747)
+++
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/hql/ast/phase/parse/PathCollector.java	2009-01-06
20:29:32 UTC (rev 15748)
@@ -1,74 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
- * indicated by the @author tags or express copyright attribution
- * statements applied by the authors.  All third-party contributions are
- * distributed under license by Red Hat Middleware LLC.
- *
- * This copyrighted material is made available to anyone wishing to use, modify,
- * copy, or redistribute it subject to the terms and conditions of the GNU
- * Lesser General Public License, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this distribution; if not, write to:
- * Free Software Foundation, Inc.
- * 51 Franklin Street, Fifth Floor
- * Boston, MA  02110-1301  USA
- */
-package org.hibernate.hql.ast.phase.parse;
-
-import org.hibernate.sql.ast.util.NodeTraverser;
-
-import antlr.collections.AST;
-
-/**
- * Utilizes a NodeTraverser in order to collect a path from
- * a (expecting dot-structure) an AST.
- *
- * @author Steve Ebersole
- */
-public class PathCollector implements NodeTraverser.VisitationStrategy,
HqlParseTokenTypes {
-	private String path = "";
-
-	private PathCollector() {
-	}
-
-	public void visit(AST node) {
-		if ( node.getType() == DOT ) {
-			path += '.';
-		}
-		else if ( "$".equals( node.getText() ) ) {
-			// allowable for treating java constants
-			path += '$';
-		}
-		else {
-			path += node.getText();
-		}
-	}
-
-	public static String getPath(AST dotStructure) {
-		if ( dotStructure.getType() == IDENT ) {
-			return dotStructure.getText();
-		}
-
-		return extractText( dotStructure );
-	}
-
-	private static String extractText(AST node) {
-		AST lhs = node.getFirstChild();
-		AST rhs = lhs.getNextSibling();
-
-		if ( lhs.getType() == IDENT ) {
-			return lhs.getText() + node.getText() + rhs.getText();
-		}
-		else {
-			return extractText( lhs ) + node.getText() + rhs.getText();
-		}
-	}
-}

Modified:
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/normalize/CollectionPersisterReference.java
===================================================================
---
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/normalize/CollectionPersisterReference.java	2009-01-06
20:11:13 UTC (rev 15747)
+++
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/normalize/CollectionPersisterReference.java	2009-01-06
20:29:32 UTC (rev 15748)
@@ -31,7 +31,6 @@
 import org.hibernate.type.EntityType;
 import org.hibernate.type.ComponentType;
 import org.hibernate.persister.collection.QueryableCollection;
-import org.hibernate.persister.collection.CollectionPropertyMapping;
 import org.hibernate.persister.entity.Queryable;
 
 /**
@@ -39,11 +38,9 @@
  *
  * @author Steve Ebersole
  */
-public class CollectionPersisterReference extends AbstractPersisterReference
-		implements NormalizationContextAwareNode, DisplayableNode {
+public class CollectionPersisterReference extends AbstractPersisterReference implements
PersisterReference, NormalizationContextAwareNode, DisplayableNode {
 	private NormalizationContext resolutionContext;
 	private transient QueryableCollection persister;
-	private transient CollectionPropertyMapping propertyMapping;
 
 	/**
 	 * Retrieve the collection "role" identifying the underlying {@link
org.hibernate.persister.collection.CollectionPersister}
@@ -123,7 +120,7 @@
 		this.resolutionContext = resolutionContext;
 	}
 
-	private final SessionFactoryImplementor getSessionFactory() {
+	private SessionFactoryImplementor getSessionFactory() {
 		if ( resolutionContext == null ) {
 			throw new AssertionFailure( "resolution context was null on attempt to retrieve
session factory reference" );
 		}


    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

[hibernate-commits] Hibernate SVN: r15748 - in core/branches/SQL_GEN_REDESIGN/src/main: java/org/hibernate/hql/ast/phase/parse and 1 other directories.