[hibernate-commits] Hibernate SVN: r16307 - in core/branches/SQL_GEN_REDESIGN/src/main: antlr/v3 and 4 other directories.
hibernate-commits at lists.jboss.org
hibernate-commits at lists.jboss.org
Mon Apr 13 12:42:44 EDT 2009
Author: steve.ebersole at jboss.com
Date: 2009-04-13 12:42:44 -0400 (Mon, 13 Apr 2009)
New Revision: 16307
Added:
core/branches/SQL_GEN_REDESIGN/src/main/antlr/v3/
core/branches/SQL_GEN_REDESIGN/src/main/antlr/v3/order/
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/render/
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/render/TableAliasBuilder.java
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/ASTFactoryImpl.java
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/AliasRef.java
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/Column.java
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/ExpectedTypeAware.java
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/HqlResolver.java
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/Name.java
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/PersisterTableProcesser.java
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/RowValueConstructorList.java
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/Table.java
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/Typed.java
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/load/
core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/load/LoadPlan.java
Log:
Added: core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/render/TableAliasBuilder.java
===================================================================
--- core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/render/TableAliasBuilder.java (rev 0)
+++ core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/render/TableAliasBuilder.java 2009-04-13 16:42:44 UTC (rev 16307)
@@ -0,0 +1,68 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2009, 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.sql.ast.phase.hql.render;
+
+import org.hibernate.persister.entity.Queryable;
+import org.hibernate.persister.collection.QueryableCollection;
+
+/**
+ * TODO : javadoc
+ *
+ * @author Steve Ebersole
+ */
+public interface TableAliasBuilder {
+
+ public static class AliasRoot {
+ private final String base;
+
+ public AliasRoot(String base) {
+ this.base = base;
+ }
+
+ public String generate(int suffix) {
+ return base + Integer.toString( suffix ) + '_';
+ }
+
+ public boolean equals(Object o) {
+ if ( this == o ) {
+ return true;
+ }
+ if ( o == null || getClass() != o.getClass() ) {
+ return false;
+ }
+ AliasRoot aliasRoot = ( AliasRoot ) o;
+ return base.equals( aliasRoot.base );
+ }
+
+ public int hashCode() {
+ return base.hashCode();
+ }
+ }
+
+ public AliasRoot getSqlAliasRoot(Queryable persister, String alias);
+
+ public AliasRoot getSqlAliasRoot(QueryableCollection persister, String alias);
+
+ public AliasRoot getSimpleSqlAliasRoot(QueryableCollection persister);
+}
Added: core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/ASTFactoryImpl.java
===================================================================
--- core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/ASTFactoryImpl.java (rev 0)
+++ core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/ASTFactoryImpl.java 2009-04-13 16:42:44 UTC (rev 16307)
@@ -0,0 +1,50 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2009, 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.sql.ast.phase.hql.resolve;
+
+import org.hibernate.sql.ast.common.NodeFactory;
+
+/**
+ * TODO : javadoc
+ *
+ * @author Steve Ebersole
+ */
+public class ASTFactoryImpl extends NodeFactory implements HqlResolveTokenTypes {
+ public Class getASTNodeType(int tokenType) {
+ switch ( tokenType ) {
+ case TABLE :
+ return Table.class;
+ case COLUMN :
+ return Column.class;
+ case ALIAS_REF :
+ return AliasRef.class;
+ case NAME :
+ return Name.class;
+ case ROW_VALUE_CONSTRUCTOR_LIST :
+ return RowValueConstructorList.class;
+ default:
+ return determineDefaultNodeClass();
+ }
+ }
+}
Added: core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/AliasRef.java
===================================================================
--- core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/AliasRef.java (rev 0)
+++ core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/AliasRef.java 2009-04-13 16:42:44 UTC (rev 16307)
@@ -0,0 +1,41 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2009, 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.sql.ast.phase.hql.resolve;
+
+import org.hibernate.sql.ast.common.Node;
+
+/**
+ * TODO : javadoc
+ *
+ * @author Steve Ebersole
+ */
+public class AliasRef extends Node {
+ public AliasRef() {
+ }
+
+ public AliasRef(String alias) {
+ setType( HqlResolveTokenTypes.ALIAS_REF );
+ setText( alias );
+ }
+}
Added: core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/Column.java
===================================================================
--- core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/Column.java (rev 0)
+++ core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/Column.java 2009-04-13 16:42:44 UTC (rev 16307)
@@ -0,0 +1,55 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2009, 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.sql.ast.phase.hql.resolve;
+
+import org.hibernate.sql.ast.common.Node;
+
+/**
+ * TODO : javadoc
+ *
+ * @author Steve Ebersole
+ */
+public class Column extends Node {
+ private String selectAlias;
+
+ public Column() {
+ }
+
+ public Column(String tableAlias, String columnName) {
+ super();
+ setType( HqlResolveTokenTypes.COLUMN );
+ setText( '{' + tableAlias + '.' + columnName + '}' );
+ addChild( new AliasRef( tableAlias ) );
+ addChild( new Name( columnName ) );
+ }
+
+ public Column injectSelectAlias(String selectAlias) {
+ this.selectAlias = selectAlias;
+ return this;
+ }
+
+ public String getSelectAlias() {
+ return selectAlias;
+ }
+}
Added: core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/ExpectedTypeAware.java
===================================================================
--- core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/ExpectedTypeAware.java (rev 0)
+++ core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/ExpectedTypeAware.java 2009-04-13 16:42:44 UTC (rev 16307)
@@ -0,0 +1,35 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2009, 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.sql.ast.phase.hql.resolve;
+
+import org.hibernate.type.Type;
+
+/**
+ * TODO : javadoc
+ *
+ * @author Steve Ebersole
+ */
+public interface ExpectedTypeAware extends Typed {
+ public void setExpectedType(Type expectedType);
+}
Added: core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/HqlResolver.java
===================================================================
--- core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/HqlResolver.java (rev 0)
+++ core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/HqlResolver.java 2009-04-13 16:42:44 UTC (rev 16307)
@@ -0,0 +1,303 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2009, 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.sql.ast.phase.hql.resolve;
+
+import java.util.HashMap;
+
+import antlr.ASTFactory;
+import antlr.RecognitionException;
+import antlr.collections.AST;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.hibernate.MappingException;
+import org.hibernate.QueryException;
+import org.hibernate.engine.SessionFactoryImplementor;
+import org.hibernate.persister.collection.QueryableCollection;
+import org.hibernate.persister.entity.Queryable;
+import org.hibernate.sql.ast.alias.DefaultTableAliasGenerator;
+import org.hibernate.sql.ast.util.ASTPrinter;
+import org.hibernate.sql.ast.util.ErrorHandlerDelegateImpl;
+import org.hibernate.sql.ast.util.ErrorHandlerDelegate;
+import org.hibernate.sql.ast.alias.TableAliasGenerator;
+import org.hibernate.sql.ast.phase.hql.resolve.expression.ExpressionResolutionStrategyStack;
+import org.hibernate.sql.ast.phase.hql.resolve.expression.DefaultExpressionResolutionStrategy;
+import org.hibernate.sql.ast.phase.hql.resolve.expression.SelectClauseExpressionResolutionStrategy;
+import org.hibernate.sql.ast.phase.hql.resolve.expression.FunctionArgumentExpressionResolutionStrategy;
+import org.hibernate.type.AssociationType;
+import org.hibernate.util.StringHelper;
+
+/**
+ * TODO : javadoc
+ *
+ * @author Steve Ebersole
+ */
+public class HqlResolver extends GeneratedHqlResolver {
+ private static final Logger log = LoggerFactory.getLogger( HqlResolver.class );
+
+ private final SessionFactoryImplementor sessionFactory;
+ private final ErrorHandlerDelegate parseErrorHandler = new ErrorHandlerDelegateImpl();
+ private final ASTPrinter printer = new ASTPrinter( HqlResolveTokenTypes.class );
+
+ private final TableAliasGenerator tableAliasGenerator;
+ private final PersisterTableProcesser persisterTableProcesser;
+
+ private ExpressionResolutionStrategyStack expressionResolverStack = new ExpressionResolutionStrategyStack();
+
+ private AST collectionFilterCondition;
+
+ public HqlResolver(SessionFactoryImplementor sessionFactory) {
+ super();
+ super.setASTFactory( new ASTFactoryImpl() );
+ this.sessionFactory = sessionFactory;
+ // todo : make this configurable
+ this.tableAliasGenerator = new DefaultTableAliasGenerator( sessionFactory.getDialect() );
+ this.persisterTableProcesser = new PersisterTableProcesser( getASTFactory() );
+ expressionResolverStack.push( new DefaultExpressionResolutionStrategy( this ) );
+ }
+
+ public ASTPrinter getPrinter() {
+ return printer;
+ }
+
+
+ // overrides of Antlr infastructure methods ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ public void reportError(RecognitionException e) {
+ getParseErrorHandler().reportError( e );
+ }
+
+ public void reportError(String s) {
+ getParseErrorHandler().reportError( s );
+ }
+
+ public void reportWarning(String s) {
+ getParseErrorHandler().reportWarning( s );
+ }
+
+ public ErrorHandlerDelegate 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!" );
+ }
+
+
+ // handle trace logging ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ public void traceIn(String ruleName, AST tree) {
+ if ( inputState.guessing > 0 ) {
+ return;
+ }
+ String prefix = StringHelper.repeat( '-', (traceDepth++ * 2) ) + "-> ";
+ String traceText = ruleName + " (" + buildTraceNodeName(tree) + ")";
+ trace( prefix + traceText );
+ }
+
+ private String buildTraceNodeName(AST tree) {
+ return tree == null
+ ? "???"
+ : tree.getText() + " [" + printer.getTokenTypeName( tree.getType() ) + "]";
+ }
+
+ public void traceOut(String ruleName, AST tree) {
+ if ( inputState.guessing > 0 ) {
+ return;
+ }
+ String prefix = "<-" + StringHelper.repeat( '-', (--traceDepth * 2) ) + " ";
+ trace( prefix + ruleName );
+ }
+
+ private void trace(String msg) {
+ System.out.println( msg );
+// log.trace( msg );
+ }
+
+
+ // semantic action overrides ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ private HashMap aliasToTableSpaceMap = new HashMap();
+
+ public Table.TableSpace resolveTableSpaceByAlias(String alias) {
+ return ( Table.TableSpace ) aliasToTableSpaceMap.get( alias );
+ }
+
+ protected AST resolveEntityPersister(AST entityName, AST alias, AST filter) {
+ final Queryable persister = ( Queryable ) sessionFactory.getEntityPersister( entityName.getText() );
+ final String aliasText = alias.getText();
+
+ Table.EntityTableSpace tableSpace = new Table.EntityTableSpace( persister, aliasText );
+ aliasToTableSpaceMap.put( aliasText, tableSpace );
+
+ TableAliasGenerator.TableAliasRoot aliasRoot = tableAliasGenerator.generateSqlAliasRoot( persister, aliasText );
+
+ Table table = persisterTableProcesser.buildTables(
+ persister,
+ aliasRoot,
+ tableSpace
+ );
+
+ if ( filter != null ) {
+ String filteredCollectionRole = filter.getText();
+ QueryableCollection filteredCollectionPersister =
+ ( QueryableCollection ) sessionFactory.getCollectionPersister( filteredCollectionRole );
+ collectionFilterCondition = persisterTableProcesser.handleCollectionFilterConditions(
+ table,
+ aliasRoot,
+ filteredCollectionPersister
+ );
+ }
+
+ return table;
+ }
+
+ protected void postProcessQuery(AST query) {
+ if ( collectionFilterCondition != null ) {
+ AST selectClause = query.getFirstChild();
+ AST fromClause = selectClause.getNextSibling();
+ AST whereClause = fromClause.getNextSibling();
+ if ( whereClause == null ) {
+ // there was no where-clause, group-by-clause or having-clause...
+ whereClause = astFactory.create( WHERE, "where" );
+ fromClause.setNextSibling( whereClause );
+ }
+ else if ( whereClause.getType() == GROUP_BY ) {
+ // there was no where-clause, but was a group-by-clause
+ AST groupByClause = whereClause;
+ whereClause = astFactory.create( WHERE, "where" );
+ whereClause.setNextSibling( groupByClause );
+ fromClause.setNextSibling( whereClause );
+ }
+ assert whereClause.getType() == WHERE : "mis-structured AST";
+ log.trace( printer.showAsString( collectionFilterCondition, "collection-filter key condition" ) );
+ appendSearchCondition( collectionFilterCondition, whereClause );
+ collectionFilterCondition = null;
+ }
+ }
+
+ protected AST resolveCollectionPersister(AST collectionRole, AST alias) {
+ return super.resolveCollectionPersister( collectionRole, alias );
+ }
+
+ protected void applyPropertyJoin(AST lhs, AST rhs, AST propertyName, AST joinType, AST with) {
+ final AST correlation = generateAssociationJoinCondition( lhs, rhs, propertyName );
+ AST on = astFactory.create( ON, "on" );
+ if ( with == null ) {
+ on.addChild( correlation );
+ }
+ else {
+ AST and = astFactory.create( AND, "and" );
+ and.addChild( correlation );
+ and.addChild( with );
+ on.addChild( and );
+ }
+
+ AST join = astFactory.create( JOIN, "join" );
+ join.addChild( joinType );
+ join.addChild( rhs );
+ join.addChild( on );
+
+ lhs.addChild( join );
+ }
+
+ private AST generateAssociationJoinCondition(AST lhs, AST rhs, AST propertyName) {
+ final String propertyNameText = propertyName.getText();
+ Table lhsTable = ( Table ) lhs;
+ Table.TableSpace lhsTableSpace = lhsTable.getTableSpace();
+ String lhsTableAlias = lhsTableSpace.getContainingTable( propertyNameText ).getAliasText();
+ String[] lhsJoinColumns = lhsTableSpace.getPropertyColumnNames( propertyNameText );
+
+ AssociationType propertyType = ( AssociationType ) lhsTableSpace.getPropertyType( propertyNameText );
+ String rhsPropertyName = propertyType.getRHSUniqueKeyPropertyName();
+ Table.TableSpace rhsTableSpace = ( ( Table ) rhs ).getTableSpace();
+ String rhsTableAlias;
+ String[] rhsJoinColumns;
+ if ( rhsPropertyName == null ) {
+ // reference to RHS PK
+ rhsTableAlias = rhsTableSpace.getJoinIntoTable().getAliasText();
+ rhsJoinColumns = rhsTableSpace.getJoinIntoColumns();
+ }
+ else {
+ // reference to RHS property-ref
+ Table rhsTable = rhsTableSpace.getContainingTable( rhsPropertyName );
+ rhsTableAlias = rhsTable.getAliasText();
+ rhsJoinColumns = rhsTableSpace.getPropertyColumnNames( rhsPropertyName );
+ }
+
+ if ( lhsJoinColumns.length != rhsJoinColumns.length ) {
+ throw new MappingException( "Association had unequal number of columns : " + propertyType.getName() );
+ }
+
+ return persisterTableProcesser.generateJoinCorrelation( lhsTableAlias, lhsJoinColumns, rhsTableAlias, rhsJoinColumns );
+ }
+
+ protected AST generateIndexValueCondition(AST lhs, AST rhs, AST propertyName, AST selector) {
+ return super.generateIndexValueCondition( lhs, rhs, propertyName, selector );
+ }
+
+ protected void startSelectClause() {
+ expressionResolverStack.push( new SelectClauseExpressionResolutionStrategy( this ) );
+ }
+
+ protected void finishSelectClause() {
+ expressionResolverStack.pop();
+ }
+
+ protected void startFunction() {
+ expressionResolverStack.push( new FunctionArgumentExpressionResolutionStrategy( this ) );
+ }
+
+ protected void finishFunction() {
+ expressionResolverStack.pop();
+ }
+
+ protected void appendSearchCondition(AST condition, AST container) {
+ if ( container.getFirstChild() == null ) {
+ container.setFirstChild( condition );
+ }
+ else {
+ AST and = getASTFactory().create( AND, "and" );
+ and.setFirstChild( container.getFirstChild() );
+ and.addChild( condition );
+ container.setFirstChild( and );
+ }
+ }
+
+ protected AST resolvePropertyReference(AST persisterAlias, AST propertyName) {
+ final String aliasText = persisterAlias.getText();
+ final String propertyNameText = propertyName.getText();
+
+ return expressionResolverStack.getCurrent().resolvePropertyReference( aliasText, propertyNameText );
+ }
+
+ protected AST resolveAliasReference(AST aliasReference) {
+ return expressionResolverStack.getCurrent().resolveAliasReference( aliasReference.getText() );
+ }
+}
Added: core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/Name.java
===================================================================
--- core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/Name.java (rev 0)
+++ core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/Name.java 2009-04-13 16:42:44 UTC (rev 16307)
@@ -0,0 +1,41 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2009, 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.sql.ast.phase.hql.resolve;
+
+import org.hibernate.sql.ast.common.Node;
+
+/**
+ * TODO : javadoc
+ *
+ * @author Steve Ebersole
+ */
+public class Name extends Node {
+ public Name() {
+ }
+
+ public Name(String name) {
+ setType( HqlResolveTokenTypes.NAME );
+ setText( name );
+ }
+}
Added: core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/PersisterTableProcesser.java
===================================================================
--- core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/PersisterTableProcesser.java (rev 0)
+++ core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/PersisterTableProcesser.java 2009-04-13 16:42:44 UTC (rev 16307)
@@ -0,0 +1,226 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2009, 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.sql.ast.phase.hql.resolve;
+
+import antlr.ASTFactory;
+import antlr.collections.AST;
+
+import org.hibernate.persister.entity.Queryable;
+import org.hibernate.persister.entity.Joinable;
+import org.hibernate.persister.MappedTableMetadata;
+import org.hibernate.persister.collection.QueryableCollection;
+import org.hibernate.sql.ast.alias.TableAliasGenerator;
+
+/**
+ * TODO : javadoc
+ *
+ * @author Steve Ebersole
+ */
+public class PersisterTableProcesser implements HqlResolveTokenTypes {
+ private final ASTFactory astFactory;
+
+ public PersisterTableProcesser(ASTFactory astFactory) {
+ this.astFactory = astFactory;
+ }
+
+ public Table buildTables(Queryable persister, TableAliasGenerator.TableAliasRoot aliasRoot, Table.EntityTableSpace tableSpace) {
+ MappedTableMetadata tableMetadata = persister.getMappedTableMetadata();
+
+ final String drivingTableName = tableMetadata.getDrivingTableName();
+ final String[] drivingTableJoinColumns = tableMetadata.getIdentifierColumnNames();
+ final String drivingTableAlias = aliasRoot.generate( 0 );
+ final Table drivingTable = generateTableReference( drivingTableName, drivingTableAlias );
+ tableSpace.registerTable( drivingTable );
+
+ int suffix = 0;
+
+ MappedTableMetadata.JoinedTable[] tables = tableMetadata.getJoinedTables();
+ for ( int i = 0; i < tables.length; i++ ) {
+ final String joinTableAlias = aliasRoot.generate( ++suffix );
+ final Table table = generateTableReference( tables[i].getName(), joinTableAlias );
+ tableSpace.registerTable( table );
+
+ final AST join = astFactory.create( JOIN, "join" );
+ drivingTable.addChild( join );
+ join.setFirstChild( tables[i].useInnerJoin() ? astFactory.create( INNER, "inner" ) : astFactory.create( LEFT, "left outer" ) );
+ join.addChild( table );
+
+ final AST on = astFactory.create( ON, "on" );
+ join.addChild( on );
+ on.setFirstChild( generateJoinCorrelation( drivingTableAlias, drivingTableJoinColumns, joinTableAlias, tables[i].getKeyColumns() ) );
+ }
+
+ return drivingTable;
+ }
+
+ public Table buildTables(
+ QueryableCollection collectionPersister,
+ TableAliasGenerator.TableAliasRoot aliasRoot,
+ Table.CollectionTableSpace tableSpace) {
+ if ( collectionPersister.isOneToMany() ) {
+ Table table = buildTables(
+ ( Queryable ) collectionPersister.getElementPersister(),
+ aliasRoot,
+ tableSpace.getEntityElementTableSpace()
+ );
+ tableSpace.setCollectionTable( table );
+ return table;
+ }
+ else {
+ Table associationTable = generateTableReference(
+ collectionPersister.getTableName(),
+ aliasRoot.generateCollectionTableAlias()
+ );
+ tableSpace.setCollectionTable( associationTable );
+
+ if ( collectionPersister.isManyToMany() ) {
+ Queryable elementPersister = ( Queryable ) collectionPersister.getElementPersister();
+ Table drivingTable = buildTables(
+ elementPersister,
+ aliasRoot,
+ tableSpace.getEntityElementTableSpace()
+ );
+
+ AST join = astFactory.create( JOIN, "join" );
+ associationTable.addChild( join );
+ join.addChild( astFactory.create( LEFT, "left outer" ) );
+ join.addChild( drivingTable );
+
+ String[] entityFkColumnNames = collectionPersister.getElementColumnNames();
+ String[] entityPkColumnNames = elementPersister.getKeyColumnNames();
+
+ AST on = astFactory.create( ON, "on" );
+ join.addChild( on );
+ on.setFirstChild(
+ generateJoinCorrelation(
+ associationTable.getAliasText(),
+ entityFkColumnNames,
+ drivingTable.getAliasText(),
+ entityPkColumnNames
+ )
+ );
+ }
+ return associationTable;
+ }
+ }
+
+ public AST handleCollectionFilterConditions(
+ Table drivingEntityTable,
+ TableAliasGenerator.TableAliasRoot aliasRoot,
+ QueryableCollection filteredCollectionPersister) {
+ Table collectionKeyTable = drivingEntityTable;
+
+ if ( !filteredCollectionPersister.isOneToMany() ) {
+ // need to deal with the collection table, which is where the collection-key would be...
+ Table associationTable = generateTableReference(
+ filteredCollectionPersister.getTableName(),
+ aliasRoot.generateCollectionTableAlias()
+ );
+
+ String[] entityFkColumnNames = filteredCollectionPersister.getElementColumnNames();
+ String[] entityPkColumnNames = ( ( Joinable ) filteredCollectionPersister.getElementPersister() ).getKeyColumnNames();
+
+ AST join = astFactory.create( JOIN, "join" );
+ drivingEntityTable.addChild( join );
+ join.addChild( astFactory.create( LEFT, "left outer" ) );
+ join.addChild( associationTable );
+
+ AST on = astFactory.create( ON, "on" );
+ join.addChild( on );
+ on.setFirstChild(
+ generateJoinCorrelation(
+ drivingEntityTable.getAliasText(),
+ entityPkColumnNames,
+ associationTable.getAliasText(),
+ entityFkColumnNames
+ )
+ );
+
+ collectionKeyTable = associationTable;
+ }
+
+ return generateCollectionFilterRestriction(
+ collectionKeyTable.getAliasText(),
+ filteredCollectionPersister.getKeyColumnNames()
+ );
+ }
+
+ private Table generateTableReference(String tableName, String alias) {
+ Table tableReference = ( Table ) astFactory.create( TABLE, "table" );
+ tableReference.addChild( astFactory.create( NAME, tableName ) );
+ tableReference.addChild( astFactory.create( ALIAS, alias ) );
+ return tableReference;
+ }
+
+ public AST generateJoinCorrelation(
+ String lhsAlias,
+ String[] lhsColumns,
+ String rhsAlias,
+ String[] rhsColumns) {
+ AST correlation = generateJoinCorrelation( lhsAlias, lhsColumns[0], rhsAlias, rhsColumns[0] );
+ if ( lhsColumns.length > 1 ) {
+ for ( int i = 1; i < lhsColumns.length; i++ ) {
+ AST previous = correlation;
+ correlation = astFactory.create( AND, "and" );
+ correlation.setFirstChild( previous );
+ correlation.addChild( generateJoinCorrelation( lhsAlias, lhsColumns[i], rhsAlias, rhsColumns[i] ) );
+ }
+ }
+ return correlation;
+ }
+
+ public AST generateJoinCorrelation(String lhsAlias, String lhsColumn, String rhsAlias, String rhsColumn) {
+ AST lhs = astFactory.create( COLUMN, "column" );
+ lhs.addChild( astFactory.create( ALIAS_REF, lhsAlias ) );
+ lhs.addChild( astFactory.create( NAME, lhsColumn ) );
+
+ AST rhs = astFactory.create( COLUMN, "column" );
+ rhs.addChild( astFactory.create( ALIAS_REF, rhsAlias ) );
+ rhs.addChild( astFactory.create( NAME, rhsColumn ) );
+
+ AST correlation = astFactory.create( EQUALS_OP, "=" );
+ correlation.addChild( lhs );
+ correlation.addChild( rhs );
+
+ return correlation;
+ }
+
+ private AST generateCollectionFilterRestriction(String alias, String[] keyColumns) {
+ // todo : for now we restrict this to single-column FKs
+ // Looks like this is true of old code as well...
+
+ AST column = astFactory.create( COLUMN, "column" );
+ column.addChild( astFactory.create( ALIAS_REF, alias ) );
+ column.addChild( astFactory.create( NAME, keyColumns[0] ) );
+
+ AST param = astFactory.create( NAMED_PARAM, "collection-filter-key" ); // todo : put this in a well known place
+
+ AST correlation = astFactory.create( EQUALS_OP, "=" );
+ correlation.addChild( column );
+ correlation.addChild( param );
+
+ return correlation;
+ }
+
+}
Added: core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/RowValueConstructorList.java
===================================================================
--- core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/RowValueConstructorList.java (rev 0)
+++ core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/RowValueConstructorList.java 2009-04-13 16:42:44 UTC (rev 16307)
@@ -0,0 +1,75 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2009, 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.sql.ast.phase.hql.resolve;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.hibernate.sql.ast.common.Node;
+import org.hibernate.type.Type;
+import org.hibernate.type.ComponentType;
+
+import antlr.collections.AST;
+
+/**
+ * TODO : javadoc
+ *
+ * @author Steve Ebersole
+ */
+public class RowValueConstructorList extends Node implements ExpectedTypeAware {
+ private static final Logger log = LoggerFactory.getLogger( RowValueConstructorList.class );
+
+ private Type hibernateType;
+
+ public RowValueConstructorList() {
+ setType( HqlResolveTokenTypes.ROW_VALUE_CONSTRUCTOR_LIST );
+ setText( "row-value-ctor-list" );
+ }
+
+ public void setExpectedType(Type expectedType) {
+ if ( hibernateType != null ) {
+ log.info( "Over-setting expected type [{} -> {}]", hibernateType.getName(), expectedType.getName() );
+ }
+ hibernateType = expectedType;
+ if ( expectedType.isComponentType() ) {
+ final ComponentType componentType = ( ComponentType ) expectedType;
+ final Type[] subtypes = componentType.getSubtypes();
+ final int length = subtypes.length;
+ if ( length == getNumberOfChildren() ) {
+ AST child = getFirstChild();
+ for ( int i = 0, max = subtypes.length; i < max; i++ ) {
+ if ( child instanceof ExpectedTypeAware ) {
+ log.debug( "propogating expected type info for component sub-property [{}]", componentType.getPropertyNames()[i] );
+ ( ( ExpectedTypeAware ) child ).setExpectedType( subtypes[i] );
+ }
+ child = child.getNextSibling();
+ }
+ }
+ }
+ }
+
+ public Type getHibernateType() {
+ return hibernateType;
+ }
+}
Added: core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/Table.java
===================================================================
--- core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/Table.java (rev 0)
+++ core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/Table.java 2009-04-13 16:42:44 UTC (rev 16307)
@@ -0,0 +1,237 @@
+package org.hibernate.sql.ast.phase.hql.resolve;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.hibernate.sql.ast.common.Node;
+import org.hibernate.sql.ast.alias.ImplicitAliasGenerator;
+import org.hibernate.sql.ast.util.DisplayableNode;
+import org.hibernate.persister.entity.Queryable;
+import org.hibernate.persister.collection.QueryableCollection;
+import org.hibernate.util.StringHelper;
+import org.hibernate.type.Type;
+
+/**
+ * TODO : javadoc
+ *
+ * @author Steve Ebersole
+ */
+public class Table extends Node implements DisplayableNode {
+ private TableSpace tableSpace;
+
+ public Table() {
+ setType( HqlResolveTokenTypes.TABLE );
+ setText( "table" );
+ }
+
+ public TableSpace getTableSpace() {
+ return tableSpace;
+ }
+
+ public Node getTableName() {
+ return ( Node ) getFirstChild();
+ }
+
+ public String getTableNameText() {
+ return getTableName().getText();
+ }
+
+ public Node getAlias() {
+ return ( Node ) getFirstChild().getNextSibling();
+ }
+
+ public String getAliasText() {
+ return getAlias().getText();
+ }
+
+ public String getText() {
+ return getTableNameText() + " (" + getAliasText() + ")";
+ }
+
+ public String getDisplayText() {
+ return "[source-alias=" + tableSpace.getSourceAlias() + "]";
+ }
+
+ public static interface TableSpace {
+ /**
+ * Used as a unique identification since each table space originates from a single source alias (persister reference).
+ *
+ * @return The source alias.
+ */
+ public String getSourceAlias();
+
+ /**
+ * Get the table reference that should act as the RHS for this table space whenever we join to into it.
+ *
+ * @return The RHS table for joining into this table space structure.
+ */
+ public Table getJoinIntoTable();
+
+ public String[] getJoinIntoColumns();
+
+ /**
+ * Get the table reference that contains the columns to which the given property is mapped.
+ *
+ * @param propertyName The name of the property for which to locate the containing table.
+ *
+ * @return The containing table.
+ */
+ public Table getContainingTable(String propertyName);
+
+ public Type getPropertyType(String propertyName);
+
+ public String[] getPropertyColumnNames(String propertyName);
+
+ public List buildIdentifierColumnReferences();
+
+ public List buildCompleteColumnReferences();
+ }
+
+ public static abstract class AbstractTableSpace implements Table.TableSpace {
+ private final String sourceAlias;
+ private final String sqlAliasBaseRoot;
+
+ private AbstractTableSpace(String sourceAlias, String persisterName) {
+ this.sourceAlias = sourceAlias;
+ this.sqlAliasBaseRoot = ImplicitAliasGenerator.isImplicitAlias( sourceAlias ) ? persisterName : sourceAlias;
+ }
+
+ public String getSourceAlias() {
+ return sourceAlias;
+ }
+
+ public String getSqlAliasBaseRoot() {
+ return sqlAliasBaseRoot;
+ }
+ }
+
+ public static class EntityTableSpace extends AbstractTableSpace {
+ private final Queryable entityPersister;
+ private final ArrayList tables;
+
+ public EntityTableSpace(Queryable entityPersister, String sourecAlias) {
+ super( sourecAlias, StringHelper.unqualifyEntityName( entityPersister.getEntityName() ) );
+ this.entityPersister = entityPersister;
+ int numberOfTables = entityPersister.getMappedTableMetadata().getJoinedTables().length + 1;
+ int listSize = numberOfTables + (int) ( numberOfTables * .75 ) + 1;
+ this.tables = new ArrayList( listSize );
+ }
+
+ public Queryable getEntityPersister() {
+ return entityPersister;
+ }
+
+ public void registerTable(Table table) {
+ table.tableSpace = this;
+ tables.add( table );
+ }
+
+ public Table getDrivingTable() {
+ return ( Table ) tables.get( 0 );
+ }
+
+ public Table getJoinIntoTable() {
+ return getDrivingTable();
+ }
+
+ public String[] getJoinIntoColumns() {
+ return entityPersister.getIdentifierColumnNames();
+ }
+
+ public Table getContainingTable(String propertyName) {
+ return ( Table ) tables.get( entityPersister.getSubclassPropertyTableNumber( propertyName ) );
+ }
+
+ public Type getPropertyType(String propertyName) {
+ return entityPersister.getPropertyType( propertyName );
+ }
+
+ public String[] getPropertyColumnNames(String propertyName) {
+ int index = entityPersister.getEntityMetamodel().getPropertyIndex( propertyName );
+ return entityPersister.getPropertyColumnNames( index );
+ }
+
+ public List buildIdentifierColumnReferences() {
+ String[] identifierColumnsNames = entityPersister.getIdentifierColumnNames();
+ ArrayList columnsReferences = new ArrayList( collectionSizeWithoutRehashing( identifierColumnsNames.length ) );
+ for ( int i = 0; i < identifierColumnsNames.length; i++ ) {
+ columnsReferences.add( new Column( getDrivingTable().getAliasText(), identifierColumnsNames[i] ) );
+ }
+ return columnsReferences;
+ }
+
+ public List buildCompleteColumnReferences() {
+ // todo : implement
+ return null;
+ }
+ }
+
+ private static int collectionSizeWithoutRehashing(int elements) {
+ // usually collection load factors are .75
+ return collectionSizeWithoutRehashing( elements, .75 );
+ }
+
+ private static int collectionSizeWithoutRehashing(int elements, double factor) {
+ return elements + ( (int) ( elements * factor ) + 1 );
+ }
+
+ public static class CollectionTableSpace extends AbstractTableSpace {
+ private final QueryableCollection persister;
+ private final boolean areElementsEntities;
+
+ private Table collectionTable;
+ private EntityTableSpace entityElementTableSpace;
+
+ public CollectionTableSpace(QueryableCollection persister, String sourceAlias) {
+ super( sourceAlias, StringHelper.unqualify( persister.getRole() ) );
+ this.persister = persister;
+ this.areElementsEntities = persister.getElementType().isEntityType();
+ if ( areElementsEntities ) {
+ entityElementTableSpace = new EntityTableSpace( ( Queryable ) persister.getElementPersister(), sourceAlias );
+ }
+ }
+
+ public QueryableCollection getPersister() {
+ return persister;
+ }
+
+ public void setCollectionTable(Table collectionTable) {
+ this.collectionTable = collectionTable;
+ }
+
+ public EntityTableSpace getEntityElementTableSpace() {
+ return entityElementTableSpace;
+ }
+
+ public Table getJoinIntoTable() {
+ return collectionTable;
+ }
+
+ public String[] getJoinIntoColumns() {
+ return persister.getKeyColumnNames();
+ }
+
+ public Table getContainingTable(String propertyName) {
+ // todo : are we needing to handle "collection properties" (SIZE, etc) here still?
+ return getEntityElementTableSpace().getContainingTable( propertyName );
+ }
+
+ public Type getPropertyType(String propertyName) {
+ return getEntityElementTableSpace().getPropertyType( propertyName );
+ }
+
+ public String[] getPropertyColumnNames(String propertyName) {
+ return getEntityElementTableSpace().getPropertyColumnNames( propertyName );
+ }
+
+ public List buildIdentifierColumnReferences() {
+ // todo : implement
+ return null;
+ }
+
+ public List buildCompleteColumnReferences() {
+ // todo : implement
+ return null;
+ }
+ }
+}
Added: core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/Typed.java
===================================================================
--- core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/Typed.java (rev 0)
+++ core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/Typed.java 2009-04-13 16:42:44 UTC (rev 16307)
@@ -0,0 +1,35 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2009, 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.sql.ast.phase.hql.resolve;
+
+import org.hibernate.type.Type;
+
+/**
+ * TODO : javadoc
+ *
+ * @author Steve Ebersole
+ */
+public interface Typed {
+ public Type getHibernateType();
+}
Added: core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/load/LoadPlan.java
===================================================================
--- core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/load/LoadPlan.java (rev 0)
+++ core/branches/SQL_GEN_REDESIGN/src/main/java/org/hibernate/sql/ast/phase/hql/resolve/load/LoadPlan.java 2009-04-13 16:42:44 UTC (rev 16307)
@@ -0,0 +1,38 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2009, 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.sql.ast.phase.hql.resolve.load;
+
+import org.hibernate.type.Type;
+
+/**
+ * I want this to be an encapsulation of the information needed by Loader. Stuff like the persisters, the aliases, etc...
+ *
+ * @author Steve Ebersole
+ */
+public class LoadPlan {
+ // todo : distinguish (interfaces/impls?) between dynamic-instantiation, scalar, and entity load plans
+
+ private Type[] queryReturnTypes;
+
+}
More information about the hibernate-commits
mailing list