Author: steve.ebersole(a)jboss.com Date: 2006-12-19 14:08:27 -0500 (Tue, 19 Dec 2006) New Revision: 11003 Added: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/PhaseContext.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/CollectionPersisterReference.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/DeleteStatementNode.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/EntityPersisterReference.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/HqlResolver.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/HqlResolverASTFactory.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/InsertStatementNode.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/JoinNode.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/JoinType.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PersisterReference.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PersisterReferenceBuilder.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PersisterReferenceContext.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PropertyReference.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/StatementNode.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/UpdateStatementNode.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/tree/PhaseContextAwareNode.java Removed: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PropertyReferenceSource.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/tree/ASTFactoryAwareNode.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/tree/PersisterReferenceContextAwareNode.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/tree/SessionFactoryAwareNode.java Modified: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/Aliasable.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PersisterReferenceContextAwareNode.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/ResolutionContext.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/ResolutionContextAwareNode.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/path/AbstractPathResolutionStrategy.java branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/path/BasicPathResolutionStrategySupport.java Log: switched to a more in-line resolution of path expressions using org.hibernate.hql.ast.resolve.path.PathResolutionStrategy Added: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/PhaseContext.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/PhaseContext.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/PhaseContext.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -0,0 +1,27 @@ +package org.hibernate.hql.ast; + +import antlr.ASTFactory; + +import org.hibernate.engine.SessionFactoryImplementor; + +/** + * Defines services which are available to any HQL translation phase. + * + * @author Steve Ebersole + */ +public interface PhaseContext { + /** + * Retrieve a reference to the factory associated with this context for + * creating AST/Node instances. + * + * @return The ASTFactory. + */ + public ASTFactory getASTFactory(); + + /** + * Retrieve a reference to the session factory associated with this context. + * + * @return The session factory. + */ + public SessionFactoryImplementor getSessionFactory(); +} Modified: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/Aliasable.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/Aliasable.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/Aliasable.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -1,10 +1,15 @@ package org.hibernate.hql.ast.resolve; /** - * {@inheritDoc} + * Contract for things which can be aliased by other parts of an HQL query. * * @author Steve Ebersole */ public interface Aliasable { + /** + * Get the alias by which other parts of an HQL query can refer to this. + * + * @return The alias. + */ public String getAlias(); } Added: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/CollectionPersisterReference.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/CollectionPersisterReference.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/CollectionPersisterReference.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -0,0 +1,146 @@ +package org.hibernate.hql.ast.resolve; + +import org.hibernate.HibernateException; +import org.hibernate.hql.CollectionProperties; +import org.hibernate.persister.collection.CollectionPropertyMapping; +import org.hibernate.persister.collection.QueryableCollection; +import org.hibernate.persister.entity.Queryable; +import org.hibernate.type.AssociationType; +import org.hibernate.type.ComponentType; +import org.hibernate.type.EntityType; +import org.hibernate.type.Type; + +/** + * A reference to an {@link org.hibernate.persister.collection.CollectionPersister}. + * + * @author Steve Ebersole + */ +public class CollectionPersisterReference extends EntityPersisterReference { + + private String role; + private transient QueryableCollection persister; + private transient CollectionPropertyMapping propertyMapping; + + /** + * Initializes the structure of this persister reference node. + * <p/> + * TODO : better to have these injected via constructor? + * + * @param role The role name of the corresponding {@link org.hibernate.persister.collection.CollectionPersister}. + * @param alias The HQL alias for this persister reference. + * @param propertyFetch Whether lazy property fetching should be applied. + */ + public void initialize(String role, String alias, boolean propertyFetch) { + this.role = role; + super.initialize( alias, propertyFetch ); + } + + /** + * Retrieve a reference to the underlying collection persister. + * + * @return The collection persister. + */ + public QueryableCollection getCollectionPersister() { + if ( persister == null ) { + persister = ( QueryableCollection ) getSessionFactory().getCollectionPersister( role ); + } + return persister; + } + + /** + * Retrieve the entity persister for the elements of this collection if + * the elements happen to be entities. + * <p/> + * TODO : perhaps we should just return null here in the case of non-entity elements? + * + * @return The element's entity persister. + * @throws HibernateException If the collection is not a collection of entities. + */ + public Queryable getEntityPersister() { + if ( getCollectionPersister().getElementType().isEntityType() ) { + EntityType elementEntityType = ( EntityType ) getCollectionPersister().getElementType(); + return ( Queryable ) elementEntityType.getAssociatedJoinable( getSessionFactory() ); + } + else { + throw new HibernateException( "not a collection of entities" ); + } + } + + /** + * + * Retrieves the logical name; here the collection role of the underlying + * {@link org.hibernate.persister.collection.CollectionPersister}. + * + * @return The collection role. + */ + public String getName() { + return role; + } + + /** + * {@inheritDoc} + */ + public AssociationType getPersisterType() { + return ( AssociationType ) getCollectionPersister().getElementType(); + } + + /** + * {@inheritDoc} + */ + public Type getPropertyType(String propertyName) { + if ( CollectionProperties.isAnyCollectionProperty( propertyName ) ) { + if ( propertyMapping == null ) { + propertyMapping = new CollectionPropertyMapping( getCollectionPersister() ); + } + return propertyMapping.toType( propertyName ); + } + else { + Type elementType = getCollectionPersister().getElementType(); + if ( elementType.isAssociationType() ) { + // a collection of entities + EntityType elementEntityType = ( EntityType ) elementType; + try { + Queryable elementEntityPersister = ( Queryable ) elementEntityType + .getAssociatedJoinable( getSessionFactory() ); + return elementEntityPersister.getPropertyType( propertyName ); + } + catch( Throwable t ) { + // ignore + } + } + else if ( elementType.isComponentType() ) { + ComponentType elementComponentType = ( ComponentType ) elementType; + String[] subPropertyNames = elementComponentType.getPropertyNames(); + for ( int i = 0; i < subPropertyNames.length; i++ ) { + if ( subPropertyNames[i].equals( propertyName ) ) { + return elementComponentType.getSubtypes()[i]; + } + } + } + } + return null; + } + + /** + * {@inheritDoc} + */ + public boolean containsProperty(String propertyName) { + // this should not be called for "collection properties" (i.e., size, index, etc) + // so we make that assumption here... + try { + return getPropertyType( propertyName ) != null; + } + catch( Throwable t ) { + // ignore + } + return false; + } + + /** + * {@inheritDoc} + */ + public String toString() { + return "CollectionPersisterReference {role=" + getName() + ", alias=" + getAlias() + + ", element-type=" + getCollectionPersister().getElementType() + "}"; + } +} Added: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/DeleteStatementNode.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/DeleteStatementNode.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/DeleteStatementNode.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -0,0 +1,27 @@ +package org.hibernate.hql.ast.resolve; + +import org.hibernate.HibernateException; +import org.hibernate.hql.ast.resolve.path.BasicPathResolutionStrategySupport; +import org.hibernate.hql.ast.resolve.path.PathResolutionStrategy; + +/** + * Specialized statement node for representing DELETE statements + * + * @author Steve Ebersole + */ +public class DeleteStatementNode extends StatementNode { + + /** + * {@inheritDoc} + */ + public PathResolutionStrategy buildBasicPathResolutionStrategy(ResolutionContext resolutionContext) { + return new BasicPathResolutionStrategySupport( resolutionContext ) { + protected void validateJoinCreation(PersisterReference origin, String property) { + throw new HibernateException( + "delete statement cannot contain path expressions resolving to implicit joins" + ); + } + }; + } + +} Added: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/EntityPersisterReference.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/EntityPersisterReference.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/EntityPersisterReference.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -0,0 +1,113 @@ +package org.hibernate.hql.ast.resolve; + +import org.hibernate.persister.entity.Queryable; +import org.hibernate.type.AssociationType; +import org.hibernate.type.Type; + +/** + * A reference to an {@link org.hibernate.persister.entity.EntityPersister}. + * + * @author Steve Ebersole + */ +public class EntityPersisterReference extends PersisterReference { + + private String entityName; + private String alias; + private boolean propertyFetch; + private transient Queryable persister; + + /** + * Initializes the structure of this persister reference node. + * <p/> + * TODO : better to have these injected via constructor? + * + * @param entityName The entity-name of the corresponding {@link org.hibernate.persister.entity.EntityPersister}. + * @param alias The HQL alias for this persister reference. + * @param propertyFetch Whether lazy property fetching should be applied. + */ + public void initialize(String entityName, String alias, boolean propertyFetch) { + this.entityName = entityName; + initialize( alias, propertyFetch ); + } + + protected void initialize(String alias, boolean propertyFetch) { + this.alias = alias; + this.propertyFetch = propertyFetch; + } + + /** + * Retrieves a reference to the underlying entity persister. + * + * @return The underlying entity persister. + */ + public Queryable getEntityPersister() { + if ( persister == null ) { + persister = ( Queryable ) getSessionFactory().getEntityPersister( entityName ); + } + return persister; + } + + /** + * Retrieves the logical name; here the entity-name of the underlying + * {@link org.hibernate.persister.entity.EntityPersister}. + * + * @return The entity-name. + */ + public String getName() { + return entityName; + } + + /** + * Retrieve the alias by which the persister reference can be located from the + * {@link PersisterReferenceContext}. + * + * @return The HQL alias. + */ + public String getAlias() { + return alias; + } + + /** + * Is lazy property fetching enabled for this persister reference. + * + * @return True if this persister reference indicates that lazy properties + * be immediately fetched; false otherwise. + */ + public boolean isPropertyFetch() { + return propertyFetch; + } + + /** + * {@inheritDoc} + */ + public AssociationType getPersisterType() { + return ( AssociationType ) getEntityPersister().getType(); + } + + /** + * {@inheritDoc} + */ + public Type getPropertyType(String propertyName) { + try { + return getEntityPersister().getPropertyType( propertyName ); + } + catch( Throwable t ) { + return null; + } + } + + /** + * {@inheritDoc} + */ + public boolean containsProperty(String propertyName) { + return getPropertyType( propertyName ) != null; + } + + /** + * {@inheritDoc} + */ + public String toString() { + return "EntityPersisterReference {entity-name=" + entityName + ", alias=" + alias + "}"; + } + +} Added: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/HqlResolver.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/HqlResolver.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/HqlResolver.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -0,0 +1,254 @@ +package org.hibernate.hql.ast.resolve; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import org.hibernate.hql.antlr.GeneratedHqlResolver; +import org.hibernate.hql.antlr.ResolveTokenTypes; +import org.hibernate.hql.ast.util.ASTPrinter; +import org.hibernate.hql.ast.resolve.path.PathResolutionStrategyStack; +import org.hibernate.hql.ast.resolve.path.PathResolutionStrategy; +import org.hibernate.hql.ast.resolve.path.PropertyPathPart; +import org.hibernate.hql.ast.resolve.path.FromClausePathResolutionStrategy; +import org.hibernate.hql.ast.resolve.path.OnFragmentPathResolutionStrategy; +import org.hibernate.hql.ast.resolve.path.WithFragmentPathResolutionStrategy; +import org.hibernate.engine.SessionFactoryImplementor; +import org.hibernate.QueryException; + +import antlr.collections.AST; + +/** + * Actual resolver implementation used in the query translator providing + * semantic action implementation. + * + * @author Joshua Davis + * @author Steve Ebersole + */ +public class HqlResolver extends GeneratedHqlResolver implements ResolutionContext { + + private static final Log log = LogFactory.getLog( HqlResolver.class ); + private static final ASTPrinter printer = new ASTPrinter( ResolveTokenTypes.class ).setShowClassNames( false ); + + private final SessionFactoryImplementor sessionFactory; + private final PersisterReferenceBuilder persisterReferenceBuilder; + + private StatementNode currentStatement; + private PathResolutionStrategyStack pathResolutionStrategyStack = new PathResolutionStrategyStack(); + + public HqlResolver(SessionFactoryImplementor sessionFactory) { + super(); + this.sessionFactory = sessionFactory; + setASTFactory( new HqlResolverASTFactory( this ) ); + persisterReferenceBuilder = new PersisterReferenceBuilder( this ); + } + + + // ResolutionContext implementation ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + public SessionFactoryImplementor getSessionFactory() { + return sessionFactory; + } + + public PersisterReferenceContext getCurrentPersisterReferenceContext() { + return currentStatement.getPersisterReferenceContext(); + } + + public PersisterReferenceBuilder getPersisterReferenceBuilder() { + return persisterReferenceBuilder; + } + + public PathResolutionStrategy getCurrentPathResolutionStrategy() { + return pathResolutionStrategyStack.getCurrent(); + } + + + // semantic action overrides ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + protected boolean isPersisterReferenceAlias(AST alias) { + log.trace( "Checking [" + textOrNull( alias ) + "] as persister-ref alias" ); + return getCurrentPersisterReferenceContext().isContainedAlias( alias.getText() ); + } + + protected AST resolveAlias(AST alias) { + log.trace( "resolving property reference alias [" + textOrNull( alias ) + "]" ); + return getCurrentPersisterReferenceContext().locatePersisterReferenceByAlias( alias.getText() ); + } + + protected boolean isUnqualifiedPropertyReference(AST property) { + log.trace( "Checking [" + textOrNull( property ) + "] as unqualified-prop-ref" ); + return getCurrentPersisterReferenceContext().isContainedExposedProperty( property.getText() ); + } + + protected AST buildUnqualifiedPropertyReference(AST propertyNameNode) { + String propertyName = propertyNameNode.getText(); + log.trace( "building unqualified property reference [" + propertyName + "]" ); + PropertyPathPart root = pathResolutionStrategyStack.getCurrent().resolveRoot( getCurrentPersisterReferenceContext().locatePersisterReferenceExposingProperty( propertyName ) ); + return root.resolveTerminalPathPart( propertyName ); + } + + protected AST resolvePropertyPathTerminus(AST source, AST propertyNameNode) { + log.trace( "resolving terminal path expression [" + textOrNull( propertyNameNode ) + "]" ); + return pathResolutionStrategyStack.getCurrent().resolveTerminalPathPart( ( PropertyPathPart ) source, textOrNull( propertyNameNode ) ); + } + + protected AST resolvePropertyPathIntermediary(AST source, AST propertyNameNode) { + log.trace( "resolving intermediate path expression [" + textOrNull( propertyNameNode ) + "]" ); + return pathResolutionStrategyStack.getCurrent().resolveIntermediatePathPart( ( PropertyPathPart ) source, textOrNull( propertyNameNode ) ); + } + + protected void validateIndexOperationOperands(AST collectionPropertyRef, AST selector) { + // TODO : temporary implementation... + log.trace( "Validating index op : collection = [" + textOrNull( collectionPropertyRef ) + "]; selector = [" + textOrNull( selector ) + "]" ); + super.validateIndexOperationOperands( collectionPropertyRef, selector ); + } + + protected AST resolveQualifiedRoot(AST alias) { + log.debug( "resolving path expression root as alias [" + alias.getText() + "]" ); + return pathResolutionStrategyStack.getCurrent().resolveRoot( getCurrentPersisterReferenceContext().locatePersisterReferenceByAlias( alias.getText() ) ); + } + + protected AST resolveUnqualifiedRoot(AST propertyName) { + log.debug( "resolving path expression root as unqualified property [" + propertyName.getText() + "]" ); + PropertyPathPart root = pathResolutionStrategyStack.getCurrent().resolveRoot( getCurrentPersisterReferenceContext().locatePersisterReferenceExposingProperty( propertyName.getText() ) ); + return root.resolveIntermediatePathPart( propertyName.getText() ); + } + + protected AST resolveIndexedRoot(AST indexNode) { + // TODO : need to resolve the INDEX_OP node to the referenced persister and have the path resolution strategy encode that as the root... + return indexNode; + } + + /** + * Semantic action called whenever we start a new statement (i.e top-level statement vs. subquery) + * + * @param statementNode The statement we are starting to process. + */ + protected void pushStatement(AST statementNode) { + log.trace( "pushing new statement context [" + statementNode + "]" ); + StatementNode statement = ( StatementNode ) statementNode; + if ( currentStatement != null ) { + currentStatement.pushChild( statement ); + } + currentStatement = statement; + pathResolutionStrategyStack.push( currentStatement.buildBasicPathResolutionStrategy( this ) ); + } + + /** + * Semantic action called whenever we complete processing a statement. + */ + protected void popStatement() { + log.trace( "popping statement context : " + currentStatement + " -> " + currentStatement.getParentStatement() ); + currentStatement = currentStatement.getParentStatement(); + pathResolutionStrategyStack.pop(); + } + + protected void pushFromClausePropertyPathContext(AST joinTypeNode, AST fetch, AST alias, AST propertyFetch) { + log.debug( "pushing explicit (from clause) property path context" ); + pathResolutionStrategyStack.push( + new FromClausePathResolutionStrategy( + this, + resolveJoinType( joinTypeNode ), + propertyFetch != null, + fetch != null, + textOrNull( alias ) + ) + ); + } + + protected void popFromClausePropertyPathContext() { + log.debug( "popping explicit (from clause) property path context" ); + pathResolutionStrategyStack.pop(); + } + + protected void pushOnFragmentPropertyPathContext(AST rhsPersisterReference) { + log.debug( "pushing on-fragment path handler [rhs=" + rhsPersisterReference.getText() + "]" ); + OnFragmentPathResolutionStrategy strategy = new OnFragmentPathResolutionStrategy( this, ( PersisterReference ) rhsPersisterReference ); + pathResolutionStrategyStack.push( strategy ); + } + + protected void popOnFragmentPropertyPathContext() { + log.debug( "popping on-fragment path handler" ); + pathResolutionStrategyStack.pop(); + } + + protected void pushWithFragmentPropertyPathContext(AST rhsPropertyReference) { + log.debug( "pushing with-fragment path handler" ); + // can only be used in conjunction with property reference generated + // directly from FromClausePropertyPathHandler... + FromClausePathResolutionStrategy.PropertyReferenceAdapter propertyAdapter = ( FromClausePathResolutionStrategy.PropertyReferenceAdapter ) rhsPropertyReference; + WithFragmentPathResolutionStrategy strategy = new WithFragmentPathResolutionStrategy( this, propertyAdapter.getOrigination(), propertyAdapter.getRhs() ); + pathResolutionStrategyStack.push( strategy ); + } + + protected void popWithFragmentPropertyPathContext() { + log.debug( "popping on-fragment path handler" ); + pathResolutionStrategyStack.pop(); + } + + /** + * Semantic action called to perform generation of an {@link EntityPersisterReference} + * representing a "root" persister reference. + * + * @param entityName The name of the entity. + * @param alias An (optional) alias for later qualification-resolution to the generated + * persister reference. + * @param propertyFetch Was property fetching explicitly specified. + * @return The generated reference. + */ + protected AST buildEntityPersisterReference(AST entityName, AST alias, AST propertyFetch) { + return buildEntityPersisterReference( entityName.getText(), textOrNull( alias ), propertyFetch != null ); + } + + private EntityPersisterReference buildEntityPersisterReference(String entityName, String alias, boolean propertyFetching) { + return persisterReferenceBuilder.buildEntityPersisterReference( entityName, alias, propertyFetching ); + } + + private String textOrNull(AST node) { + return node == null ? null : node.getText(); + } + + protected AST buildAdHocJoinNode(AST rhs, AST joinTypeNode, AST onClause) { + log.debug( printer.showAsString( onClause, "ON fragment for ad-hoc-join building" ) ); + JoinType joinType = resolveJoinType( joinTypeNode ); + OnFragmentPathResolutionStrategy strategy = ( OnFragmentPathResolutionStrategy ) pathResolutionStrategyStack.getCurrent(); + PersisterReference lhs = strategy.getDiscoveredLHS(); + if ( lhs == null ) { + throw new QueryException( "Unable to discover left hand side of ad-hoc-join" ); + } + return getPersisterReferenceBuilder().buildJoinNode( lhs, ( PersisterReference ) rhs, joinType, null, false ); + } + + protected void applyWithFragment(AST withFragment) { + log.debug( printer.showAsString( withFragment, "WITH fragment" ) ); + WithFragmentPathResolutionStrategy strategy = ( WithFragmentPathResolutionStrategy ) pathResolutionStrategyStack.getCurrent(); + strategy.applyWithFragment( withFragment ); + } + + private JoinType resolveJoinType(AST joinType) { + int joinTypeType = joinType == null ? INNER : joinType.getType(); + switch ( joinTypeType ) { + case INNER: + return JoinType.INNER; + case LEFT: + return JoinType.LEFT; + case RIGHT: + return JoinType.RIGHT; + case FULL: + return JoinType.FULL; + } + // if no match found, throw exception + throw new QueryException( "Unrecognized join type [" + joinType.getText() + "]" ); + } + + protected String reconstitutePathString(AST propertyReference) { + AST child = propertyReference.getFirstChild(); + String prefix = ""; + StringBuffer buffer = new StringBuffer(); + while ( child != null ) { + buffer.append( prefix ).append( child.getText() ); + prefix = "."; + child = child.getNextSibling(); + } + return buffer.toString(); + } +} Added: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/HqlResolverASTFactory.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/HqlResolverASTFactory.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/HqlResolverASTFactory.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -0,0 +1,69 @@ +package org.hibernate.hql.ast.resolve; + +import antlr.collections.AST; +import antlr.Token; + +import org.hibernate.hql.ast.HqlASTFactory; +import org.hibernate.hql.ast.tree.PhaseContextAwareNode; +import org.hibernate.hql.antlr.ResolveTokenTypes; + +/** + * AST factory for the resolver phase. + * + * @author Joshua Davis + * @author Steve Ebersole + */ +public class HqlResolverASTFactory extends HqlASTFactory implements ResolveTokenTypes { + + private final ResolutionContext context; + + public HqlResolverASTFactory(ResolutionContext context) { + this.context = context; + } + + public Class getASTNodeType(int tokenType) { + switch (tokenType) { + case QUERY: + return SelectStatementNode.class; + case UPDATE: + return UpdateStatementNode.class; + case DELETE: + return DeleteStatementNode.class; + case INSERT: + return InsertStatementNode.class; + case ENTITY_PERSISTER_REF: + return EntityPersisterReference.class; + case COLLECTION_PERSISTER_REF: + return CollectionPersisterReference.class; + case JOIN: + return JoinNode.class; + case PROPERTY_REF: + return PropertyReference.class; + } + return super.getASTNodeType( tokenType ); + } + + protected AST createUsingCtor(Token token, String string) { + AST node = super.createUsingCtor( token, string ); + prepare( node ); + return node; + } + + protected AST create(Class aClass) { + AST node = super.create( aClass ); + prepare( node ); + return node; + } + + private void prepare(AST node) { + if ( node instanceof PhaseContextAwareNode ) { + ( ( PhaseContextAwareNode ) node ).injectPhaseContext( context ); + } + if ( node instanceof ResolutionContextAwareNode ) { + ( ( ResolutionContextAwareNode ) node ).injectResolutionContext( context ); + } + if ( node instanceof PersisterReferenceContextAwareNode ) { + ( ( PersisterReferenceContextAwareNode ) node ).injectPersisterReferenceContext( context.getCurrentPersisterReferenceContext() ); + } + } +} Added: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/InsertStatementNode.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/InsertStatementNode.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/InsertStatementNode.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -0,0 +1,27 @@ +package org.hibernate.hql.ast.resolve; + +import org.hibernate.HibernateException; +import org.hibernate.hql.ast.resolve.path.BasicPathResolutionStrategySupport; +import org.hibernate.hql.ast.resolve.path.PathResolutionStrategy; + +/** + * Specialized statement node for representing INSERT statements + * + * @author Steve Ebersole + */ +public class InsertStatementNode extends StatementNode { + + /** + * {@inheritDoc} + */ + public PathResolutionStrategy buildBasicPathResolutionStrategy(ResolutionContext resolutionContext) { + return new BasicPathResolutionStrategySupport( resolutionContext ) { + protected void validateJoinCreation(PersisterReference origin, String property) { + throw new HibernateException( + "insert statement cannot contain path expressions resolving to implicit joins" + ); + } + }; + } + +} Added: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/JoinNode.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/JoinNode.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/JoinNode.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -0,0 +1,78 @@ +package org.hibernate.hql.ast.resolve; + +import antlr.collections.AST; + +import org.hibernate.hql.ast.tree.Node; +import org.hibernate.hql.ast.tree.DisplayableNode; + +/** + * Represents an HQL join. The coneptualization here is strictly that of + * the join in terms of the context of the HQL query. + * <p/> + * The structure here is such that the JoinNode has a mandatory child which is + * a {@link org.hibernate.hql.ast.resolve.PersisterReference} representing the + * right-hand-side (RHS) of the join. Optionally, it may contain an additional + * child which would represent a subtree of join conditions; these join conditions + * would be in addition to the defined property-join conditions. + * <p/> + * The left-hand-side (LHS) of the JoinNode is actually the parent of the + * JoinNode. Antlr, however, does not maintain this bi-directionality, so here + * we keep a referenc to our parent (the LHS) as an inst var so that we can + * refer to it as need be later. + * + * @author Steve Ebersole + */ +public class JoinNode extends Node implements DisplayableNode { + + private JoinType joinType; + private String propertyName; + private PersisterReference lhs; + + public JoinNode() { + super.setText( "join" ); + } + + public void initialize(JoinType joinType, String propertyName, PersisterReference lhs) { + this.joinType = joinType; + this.propertyName = propertyName; + this.lhs = lhs; + } + + public JoinType getJoinType() { + return joinType; + } + + public void setJoinType(JoinType joinType) { + this.joinType = joinType; + } + + public PersisterReference getLhs() { + return lhs; + } + + public PersisterReference getRhs() { + return ( PersisterReference ) getFirstChild(); + } + + public String getPropertyName() { + return propertyName; + } + + public AST getExplicitJoinConditions() { + return getFirstChild().getNextSibling(); + } + + public void applyExplicitJoinConditions(AST conditions) { + getFirstChild().setNextSibling( conditions ); + } + + public String getDisplayText() { + return "{" + "type=" + joinType + + ", lhs=" + ( lhs == null ? "???" : lhs.getAlias() ) + + ", property=" + ( propertyName == null ? "n/a" : propertyName ) + "}"; + } + + public String toString() { + return "JoinNode " + getDisplayText(); + } +} Added: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/JoinType.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/JoinType.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/JoinType.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -0,0 +1,62 @@ +package org.hibernate.hql.ast.resolve; + +import java.io.Serializable; +import java.util.HashMap; + +/** + * Represents a canonical join type. + * <p/> + * Note that currently HQL really only supports inner and left outer joins + * (though cross joins can also be achieved). This is because joins in HQL + * are always defined in relation to a mapped association. However, when we + * start allowing users to specify ad-hoc joins this may need to change to + * allow the full spectrum of join types. Thus the others are provided here + * currently just for completeness and for future expansion. + * + * @author Steve Ebersole + */ +public class JoinType implements Serializable { + /** + * Represents an inner join. + */ + public static final JoinType INNER = new JoinType( "inner" ); + /** + * Represents a left outer join. + */ + public static final JoinType LEFT = new JoinType( "left outer" ); + /** + * Represents a right outer join. + */ + public static final JoinType RIGHT = new JoinType( "right outer" ); + /** + * Represents a cross join (aka a cartesian product). + */ + public static final JoinType CROSS = new JoinType( "cross" ); + /** + * Represents a full join. + */ + public static final JoinType FULL = new JoinType( "full" ); + + private static final HashMap INSTANCES = new HashMap(); + static { + INSTANCES.put( INNER.name, INNER ); + INSTANCES.put( LEFT.name, LEFT ); + INSTANCES.put( RIGHT.name, RIGHT ); + INSTANCES.put( CROSS.name, CROSS ); + INSTANCES.put( FULL.name, FULL ); + } + + private final String name; + + private JoinType(String name) { + this.name = name; + } + + public String toString() { + return name; + } + + private Object readResolve() { + return INSTANCES.get( name ); + } +} Added: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PersisterReference.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PersisterReference.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PersisterReference.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -0,0 +1,96 @@ +package org.hibernate.hql.ast.resolve; + +import java.util.HashMap; +import java.util.Map; + +import org.hibernate.hql.ast.tree.Node; +import org.hibernate.type.AssociationType; +import org.hibernate.type.Type; +import org.hibernate.engine.SessionFactoryImplementor; +import org.hibernate.AssertionFailure; + +/** + * Represents a reference to a persister (either entity or collection) within + * an HQL statement. + * + * @author Steve Ebersole + */ +public abstract class PersisterReference extends Node implements Aliasable, ResolutionContextAwareNode { + + private ResolutionContext resolutionContext; + private final Map reusableJoinsByProperty = new HashMap(); + + /** + * Retrieve the logical name of this persister reference. Used in logging + * operations. + * + * @return The logical persister reference name. + */ + public abstract String getName(); + + /** + * The type represented by this persister reference. + * + * @return The type. + */ + public abstract AssociationType getPersisterType(); + + /** + * Does the underlying persister contain such a named property? + * + * @param propertyName The property name to check. + * @return True if the persister contains a property with that name; false + * otherwise. + */ + public abstract boolean containsProperty(String propertyName); + + /** + * Retrieve the type of the given named property rooted at the underlying + * persister; will be <tt>null</tt> if {@link #containsProperty} is false. + * + * @param propertyName The name of the property. + * @return The property's type, or null. + */ + public abstract Type getPropertyType(String propertyName); + + /** + * Get the loggable text of this persister reference. + * + * @return The loggable text. + */ + public String getText() { + return getName() + " (" + getAlias() + ")"; + } + + /** + * Locate a previously {@link #registerReusableJoinByProperty registered} + * implicit join by the property name/path. + * + * @param propertyName The name/path of the property. + * @return The previously registered persister reference; or null. + */ + public JoinNode locateReusableJoinByProperty(String propertyName) { + return ( JoinNode ) reusableJoinsByProperty.get( propertyName ); + } + + /** + * Register a join by property as being reusable. + * + * @param propertyName The name of the property which the join represents. + * @param join The join. + */ + public void registerReusableJoinByProperty(String propertyName, JoinNode join) { + reusableJoinsByProperty.put( propertyName, join ); + } + + protected final SessionFactoryImplementor getSessionFactory() { + if ( resolutionContext == null ) { + throw new AssertionFailure( "resolution context was null on attempt to retrieve session factory reference" ); + } + return resolutionContext.getSessionFactory(); + } + + public void injectResolutionContext(ResolutionContext resolutionContext) { + this.resolutionContext = resolutionContext; + } +} Added: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PersisterReferenceBuilder.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PersisterReferenceBuilder.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PersisterReferenceBuilder.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -0,0 +1,117 @@ +package org.hibernate.hql.ast.resolve; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import org.hibernate.MappingException; +import org.hibernate.hql.antlr.ResolveTokenTypes; +import org.hibernate.persister.entity.EntityPersister; + +/** + * A helper for building {@link PersisterReference} AST structures. + * + * @author Steve Ebersole + */ +public class PersisterReferenceBuilder { + + public static final Log log = LogFactory.getLog( PersisterReferenceBuilder.class ); + + private final AliasBuilder aliasBuilder = new AliasBuilder(); + private final ResolutionContext resolutionContext; + + + public PersisterReferenceBuilder(ResolutionContext resolutionContext) { + this.resolutionContext = resolutionContext; + } + + // exposed services ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + /** + * Builds an entity persister reference + * + * @param entityName The entity name to which to build a PersisterReference. + * @param alias The alias (or null) to apply to the built PersisterReference. + * @param propertyFetching Whether lazy property fetching should be enabled. + * @return The built PersisterReference + */ + public EntityPersisterReference buildEntityPersisterReference( + String entityName, + String alias, + boolean propertyFetching) { + EntityPersister persister = lookupEntityPersister( entityName ); + alias = determineAlias( alias ); + EntityPersisterReference persisterReference = ( EntityPersisterReference ) + resolutionContext.getASTFactory().create( ResolveTokenTypes.ENTITY_PERSISTER_REF, persister.getEntityName() ); + persisterReference.initialize( persister.getEntityName(), alias, propertyFetching ); + resolutionContext.getCurrentPersisterReferenceContext().registerPersisterReference( persisterReference ); + return persisterReference; + } + + public CollectionPersisterReference buildCollectionPersisterReference(String collectionRole, String alias, boolean propertyFetching) { + alias = determineAlias( alias ); + CollectionPersisterReference persisterReference = ( CollectionPersisterReference ) + resolutionContext.getASTFactory().create( ResolveTokenTypes.COLLECTION_PERSISTER_REF, collectionRole ); + persisterReference.initialize( collectionRole, alias, propertyFetching ); + resolutionContext.getCurrentPersisterReferenceContext().registerPersisterReference( persisterReference ); + return persisterReference; + } + + public JoinNode buildJoinNode( + PersisterReference lhs, + PersisterReference rhs, + JoinType joinType, + String propertyName, + boolean fetching) { + JoinNode join = ( JoinNode ) resolutionContext.getASTFactory().create( ResolveTokenTypes.JOIN, "join" ); + join.initialize( joinType, propertyName, lhs ); + lhs.addChild( join ); + join.setFirstChild( rhs ); + if ( fetching ) { + resolutionContext.getCurrentPersisterReferenceContext().registerFetch( rhs ); + } + if ( join.getPropertyName() != null && AliasBuilder.isNonExplicitAlias( join.getRhs().getAlias() ) ) { + join.getLhs().registerReusableJoinByProperty( join.getPropertyName(), join ); + } + return join; + } + + private EntityPersister lookupEntityPersister(String name) { + // First, try to get the persister using the class name directly. + try { + return resolutionContext.getSessionFactory().getEntityPersister( name ); + } + catch ( MappingException ignore ) { + // unable to locate it using this name + } + + // If that didn't work, try using the 'import' name. + String importedClassName = resolutionContext.getSessionFactory().getImportedClassName( name ); + if ( importedClassName == null ) { + return null; + } + return resolutionContext.getSessionFactory().getEntityPersister( importedClassName ); + } + + private String determineAlias(String alias) { + if ( alias == null ) { + alias = aliasBuilder.buildUniqueImplicitAlias(); + } + return alias; + } + + public static boolean isNonExplicitAlias(String alias) { + return AliasBuilder.isNonExplicitAlias( alias ); + } + + private static class AliasBuilder { + private int unaliasedCount = 0; + + private synchronized String buildUniqueImplicitAlias() { + return "<gen:" + unaliasedCount++ + ">"; + } + + private static boolean isNonExplicitAlias(String alias) { + return alias == null || ( alias.startsWith( "<gen:" ) && alias.endsWith( ">" ) ); + } + } +} Added: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PersisterReferenceContext.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PersisterReferenceContext.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PersisterReferenceContext.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -0,0 +1,108 @@ +package org.hibernate.hql.ast.resolve; + +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.Iterator; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import org.hibernate.QueryException; +import org.hibernate.hql.ast.tree.Node; + +/** + * Defines the contract for implementors of a "context" or a "scope" for + * references to persisters. Generally speaking, this maps to the notion + * of a FROM clause in a SELECT statement. However, DML operations also + * have a notion of a persister reference. This, then, acts as the + * abstraction of these grouped references to persisters. + * + * @see PersisterReference + * + * @author Steve Ebersole + */ +public class PersisterReferenceContext extends Node { + private static final Log log = LogFactory.getLog( PersisterReferenceContext.class ); + + private List persisterReferences = new ArrayList(); + private Map aliasXref = new HashMap(); + private List fetches = new ArrayList(); + + protected PersisterReferenceContext() { + } + + public boolean isContainedAlias(String alias) { + return aliasXref.containsKey( alias ); + } + + public boolean isContainedExposedProperty(String propertyName) { + // a matching alias always takes precedence... + return ( ! isContainedAlias( propertyName ) ) + && locatePersisterReferenceExposingProperty( propertyName ) != null; + } + + public PersisterReference locatePersisterReference(String aliasOrPropertyName) { + PersisterReference pRef = locatePersisterReferenceByAlias( aliasOrPropertyName ); + if ( pRef == null ) { + pRef = locatePersisterReferenceExposingProperty( aliasOrPropertyName ); + } + return pRef; + } + + /** + * Locate a {@link PersisterReference} by alias. + * + * @param alias The alias by which to locate the persister reference. + * @return The persister reference, or null. + */ + public PersisterReference locatePersisterReferenceByAlias(String alias) { + log.trace( "attempting to resolve [" + alias + "] as persister reference alias" ); + return ( PersisterReference ) aliasXref.get( alias ); + } + + /** + * Locate an persister reference in this context which exposes the + * specified property. + * + * @param propertyName The name of the property. + * @return The persister reference, or null. + */ + public PersisterReference locatePersisterReferenceExposingProperty(String propertyName) { + log.trace( "attempting to resolve [" + propertyName + "] as unqualified property" ); + EntityPersisterReference pRef = null; + Iterator itr = persisterReferences.iterator(); + while( itr.hasNext() ) { + final EntityPersisterReference test = ( EntityPersisterReference ) itr.next(); + if ( test.containsProperty( propertyName ) ) { + if ( pRef != null ) { + throw new QueryException( "multiple persisters contained property [" + propertyName + "]" ); + } + pRef = test; + } + } + return pRef; + } + + /** + * Registers a persister reference in this context. It is + * assumed the passed persisterReference represents a "root" + * persister reference within the query. + * + * @param persisterReference The persister reference to register. + */ + public void registerPersisterReference(PersisterReference persisterReference) { + if ( persisterReference.getAlias() == null ) { + throw new IllegalArgumentException( "unexpected null persister-reference alias" ); + } + persisterReferences.add( persisterReference ); + aliasXref.put( persisterReference.getAlias(), persisterReference ); + // TODO : should we inject the persisterReference into the AST here? + } + + public void registerFetch(PersisterReference persisterReference) { + fetches.add( persisterReference ); + } + +} Modified: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PersisterReferenceContextAwareNode.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PersisterReferenceContextAwareNode.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PersisterReferenceContextAwareNode.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -1,10 +1,16 @@ package org.hibernate.hql.ast.resolve; /** - * todo: describe PersisterReferenceContextAwareNode + * Injection service contract for nodes which require access to the exact + * {@link PersisterReferenceContext} in effect at the time they were created. * * @author Steve Ebersole */ public interface PersisterReferenceContextAwareNode { - public void setPersisterReferenceContext(PersisterReferenceContext persisterReferenceContext); + /** + * Injects a reference to the current {@link PersisterReferenceContext}. + * + * @param persisterReferenceContext The current {@link PersisterReferenceContext}. + */ + public void injectPersisterReferenceContext(PersisterReferenceContext persisterReferenceContext); } Added: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PropertyReference.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PropertyReference.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PropertyReference.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -0,0 +1,66 @@ +package org.hibernate.hql.ast.resolve; + +import org.hibernate.hql.ast.tree.Node; +import org.hibernate.hql.ast.tree.DisplayableNode; +import org.hibernate.type.Type; +import org.hibernate.HibernateException; + +/** + * Represents a reference to a particular property. + * <p/> + * The sub-tree structure of this node is such that its first child is an ALIAS + * node representing an alias pointing to the specific persister reference from + * which the property reference originates. The other child is the property name, + * as an IDENT + * + * @author Steve Ebersole + */ +public class PropertyReference extends Node implements PersisterReferenceContextAwareNode, DisplayableNode { + + private PersisterReferenceContext persisterContext; + + // caches + private String alias; + private String propertyName; + private Type propertyType; + private PersisterReference origin; + + public String getOriginationAlias() { + if ( alias == null ) { + alias = getFirstChild().getText(); + } + return alias; + } + + public String getPropertyName() { + if ( propertyName == null ) { + propertyName = getFirstChild().getNextSibling().getText(); + } + return propertyName; + } + + public PersisterReference getOrigination() { + if ( origin == null ) { + if ( persisterContext == null ) { + throw new HibernateException( "PersisterReferenceContext not yet injected" ); + } + origin = persisterContext.locatePersisterReferenceByAlias( getOriginationAlias() ); + } + return origin; + } + + public Type getPropertyType() { + if ( propertyType == null ) { + propertyType = getOrigination().getPropertyType( getPropertyName() ); + } + return propertyType; + } + + public void injectPersisterReferenceContext(PersisterReferenceContext persisterContext) { + this.persisterContext = persisterContext; + } + + public String getDisplayText() { + return " {origin=" + getOrigination().getText() + ", name=" + getPropertyName() + ", type=" + getPropertyType().getName() + "}"; + } +} Deleted: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PropertyReferenceSource.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PropertyReferenceSource.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/PropertyReferenceSource.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -1,43 +0,0 @@ -package org.hibernate.hql.ast.resolve; - -import org.hibernate.type.Type; - -/** - * Contract for things which can be the source of a property reference in an - * HQL query. This contract is used to resolve dot-structures. - * - * @author Steve Ebersole - */ -public interface PropertyReferenceSource { - /** - * Retrieves the type that this source represents. - * - * @return The source's type. - */ - public Type getRootType(); - - /** - * Any path information "backing" this source. Used for componnent - * resolution, where this source represents a component value. - * - * @return The component property path - */ - public String getPropertyPath(); - - /** - * Again, used in component resolutions. The persister from which the - * {@link #getPropertyPath} is relative. - * - * @return - */ - public PersisterReference getPropertyPathRoot(); - - public Type getPropertyType(String propertyName); - - public void prepareLHS(ResolutionContext resolutionContext, String rhsPropertyName); - - public JoinNode locateImplicitJoinByProperty(String propertyName); - - public void registerImplicitJoinByProperty(String propertyName, JoinNode join); - -} Modified: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/ResolutionContext.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/ResolutionContext.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/ResolutionContext.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -1,35 +1,15 @@ package org.hibernate.hql.ast.resolve; -import antlr.ASTFactory; - -import org.hibernate.engine.SessionFactoryImplementor; import org.hibernate.hql.ast.resolve.path.PathResolutionStrategy; +import org.hibernate.hql.ast.PhaseContext; /** - * Defines the basic contract for a resolution context. - * <p/> - * Essentially used to define a series of services that components - * operating within said context can rely upon. + * Defines the basic contract for service context for the resolution phase. * * @author Steve Ebersole */ -public interface ResolutionContext { +public interface ResolutionContext extends PhaseContext { /** - * Retrieve a reference to the factory associated with this context for - * creating AST/Node instances. - * - * @return The ASTFactory. - */ - public ASTFactory getASTFactory(); - - /** - * Retrieve a reference to the session factory associated with this context. - * - * @return The session factory. - */ - public SessionFactoryImplementor getSessionFactory(); - - /** * Retrieve a reference to the {@link PersisterReference} builder associated * with this context. * Modified: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/ResolutionContextAwareNode.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/ResolutionContextAwareNode.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/ResolutionContextAwareNode.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -6,5 +6,5 @@ * @author Steve Ebersole */ public interface ResolutionContextAwareNode { - public void setResolutionContext(ResolutionContext resolutionContext); + public void injectResolutionContext(ResolutionContext resolutionContext); } Added: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/StatementNode.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/StatementNode.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/StatementNode.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -0,0 +1,65 @@ +package org.hibernate.hql.ast.resolve; + +import java.util.List; +import java.util.Iterator; +import java.util.ArrayList; + +import org.hibernate.hql.ast.tree.Node; +import org.hibernate.util.EmptyIterator; +import org.hibernate.QueryException; +import org.hibernate.hql.ast.resolve.path.PathResolutionStrategy; + +/** + * Base node class for HQL statements. + * + * @author Joshua Davis + * @author Steve Ebersole + */ +public abstract class StatementNode extends Node { + + private StatementNode parentStatement; + private List childStatements; + private PersisterReferenceContext persisterReferenceContext = new HierarchicalPersisterReferenceContext(); + + public StatementNode getParentStatement() { + return parentStatement; + } + + public boolean isTopLevelStatement() { + return parentStatement == null; + } + + public StatementNode getTopLevelStatement() { + StatementNode topLevel = this; + while ( topLevel.getParentStatement() != null ) { + topLevel = topLevel.getParentStatement(); + } + return topLevel; + } + + public Iterator iterateChildStatements() { + return childStatements == null ? EmptyIterator.INSTANCE : childStatements.iterator(); + } + + public void pushChild(StatementNode childStatement) { + childStatement.setParent( this ); + if ( childStatements == null ) { + childStatements = new ArrayList(); + } + childStatements.add( childStatement ); + } + + private void setParent(StatementNode parentStatement) { + if ( this.parentStatement != null ) { + throw new QueryException( "statement already had an associated parent" ); + } + this.parentStatement = parentStatement; + this.persisterReferenceContext = new HierarchicalPersisterReferenceContext( parentStatement.getPersisterReferenceContext() ); + } + + public PersisterReferenceContext getPersisterReferenceContext() { + return persisterReferenceContext; + } + + public abstract PathResolutionStrategy buildBasicPathResolutionStrategy(ResolutionContext resolutionContext); +} Added: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/UpdateStatementNode.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/UpdateStatementNode.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/UpdateStatementNode.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -0,0 +1,25 @@ +package org.hibernate.hql.ast.resolve; + +import org.hibernate.hql.ast.resolve.path.PathResolutionStrategy; +import org.hibernate.hql.ast.resolve.path.BasicPathResolutionStrategySupport; +import org.hibernate.HibernateException; + +/** + * Specialized statement node for representing UPDATE statements + * + * @author Steve Ebersole + */ +public class UpdateStatementNode extends StatementNode { + + /** + * {@inheritDoc} + */ + public PathResolutionStrategy buildBasicPathResolutionStrategy(ResolutionContext resolutionContext) { + return new BasicPathResolutionStrategySupport(resolutionContext) { + protected void validateJoinCreation(PersisterReference origin, String property) { + throw new HibernateException( "update statement cannot contain path expressions resolving to implicit joins" ); + } + }; + } +} + Modified: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/path/AbstractPathResolutionStrategy.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/path/AbstractPathResolutionStrategy.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/path/AbstractPathResolutionStrategy.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -60,7 +60,7 @@ } protected final void preparePropertyReference(PropertyReference propertyReferenceNode, PersisterReference persisterReference, String propertyPath) { - propertyReferenceNode.setPersisterReferenceContext( resolutionContext.getCurrentPersisterReferenceContext() ); + propertyReferenceNode.injectPersisterReferenceContext( resolutionContext.getCurrentPersisterReferenceContext() ); propertyReferenceNode.setText( persisterReference.getAlias() + "." + propertyPath ); propertyReferenceNode.setType( ResolveTokenTypes.PROPERTY_REF ); Modified: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/path/BasicPathResolutionStrategySupport.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/path/BasicPathResolutionStrategySupport.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/resolve/path/BasicPathResolutionStrategySupport.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -191,7 +191,7 @@ private JoinNode resolveLhsJoin() { EntityType type = ( EntityType ) lhs.getPropertyType( propertyName ); validateJoinCreation( lhs, propertyName ); - JoinNode join = lhs.locateImplicitJoinByProperty( propertyName ); + JoinNode join = lhs.locateReusableJoinByProperty( propertyName ); if ( join == null ) { String entityName = type.getAssociatedEntityName( resolutionContext.getSessionFactory() ); PersisterReference joinRhs = resolutionContext.getPersisterReferenceBuilder().buildEntityPersisterReference( entityName, null, false ); Deleted: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/tree/ASTFactoryAwareNode.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/tree/ASTFactoryAwareNode.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/tree/ASTFactoryAwareNode.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -1,12 +0,0 @@ -package org.hibernate.hql.ast.tree; - -import antlr.ASTFactory; - -/** - * todo: describe ASTFactoryAwareNode - * - * @author Steve Ebersole - */ -public interface ASTFactoryAwareNode { - public void setASTFactory(ASTFactory astFactory); -} Deleted: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/tree/PersisterReferenceContextAwareNode.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/tree/PersisterReferenceContextAwareNode.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/tree/PersisterReferenceContextAwareNode.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -1,12 +0,0 @@ -package org.hibernate.hql.ast.tree; - -import org.hibernate.hql.ast.resolve.PersisterReferenceContext; - -/** - * todo: describe PersisterReferenceContextAwareNode - * - * @author Steve Ebersole - */ -public interface PersisterReferenceContextAwareNode { - public void setPersisterReferenceContext(PersisterReferenceContext persisterReferenceContext); -} Added: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/tree/PhaseContextAwareNode.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/tree/PhaseContextAwareNode.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/tree/PhaseContextAwareNode.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -0,0 +1,18 @@ +package org.hibernate.hql.ast.tree; + +import org.hibernate.hql.ast.PhaseContext; + +/** + * Injection service contract for nodes which require access to the current + * phase context during their lifetime. + * + * @author Steve Ebersole + */ +public interface PhaseContextAwareNode { + /** + * Inject a reference to the current {@link PhaseContext}. + * + * @param context The current {@link PhaseContext} + */ + public void injectPhaseContext(PhaseContext context); +} Deleted: branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/tree/SessionFactoryAwareNode.java =================================================================== --- branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/tree/SessionFactoryAwareNode.java 2006-12-19 18:09:33 UTC (rev 11002) +++ branches/HQL_ANTLR_2/Hibernate3/src/org/hibernate/hql/ast/tree/SessionFactoryAwareNode.java 2006-12-19 19:08:27 UTC (rev 11003) @@ -1,13 +0,0 @@ -package org.hibernate.hql.ast.tree; - -import org.hibernate.engine.SessionFactoryImplementor; - -/** - * Marking interface for nodes which want access to the - * {@link org.hibernate.engine.SessionFactoryImplementor session factory}. - * - * @author Steve Ebersole - */ -public interface SessionFactoryAwareNode { - public void setSessionFactory(SessionFactoryImplementor sessionFactory); -}