Author: steve.ebersole(a)jboss.com Date: 2009-07-31 13:53:18 -0400 (Fri, 31 Jul 2009) New Revision: 17222 Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/AbstractNode.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/CriteriaQueryImpl.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/CriteriaSubqueryImpl.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/FromImpl.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/OrderImpl.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/PathImpl.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/QueryBuilderImpl.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/QueryStructure.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/RootImpl.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/AbstractExpression.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/AbstractTupleElement.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/CompoundSelectionImpl.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/EntityTypeExpression.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/FunctionExpressionImpl.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/LiteralExpression.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/ParameterExpressionImpl.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/SelectionImpl.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/function/ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/AbstractPredicateImpl.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/AbstractSimplePredicate.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/BetweenPredicate.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/BooleanExpressionPredicate.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/ComparisonPredicate.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/CompoundPredicate.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/ExplicitTruthValueCheck.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/InPredicate.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/NullnessPredicate.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/TruthValue.java core/trunk/entitymanager/src/test/java/org/hibernate/ejb/criteria/ core/trunk/entitymanager/src/test/java/org/hibernate/ejb/criteria/basic/ core/trunk/entitymanager/src/test/java/org/hibernate/ejb/criteria/basic/BasicCriteriaUsageTest.java core/trunk/entitymanager/src/test/java/org/hibernate/ejb/criteria/basic/Wall.java Modified: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/AbstractEntityManagerImpl.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/CurrentEntityManagerImpl.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/EntityManagerFactoryImpl.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/EntityManagerImpl.java Log: EJB-455 : Implement EntityManager#getEntityManagerFactory; EJB-447 : Implement JPA 2.0 criteria apis Modified: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/AbstractEntityManagerImpl.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/AbstractEntityManagerImpl.java 2009-07-30 21:30:58 UTC (rev 17221) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/AbstractEntityManagerImpl.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -69,6 +69,7 @@ public abstract class AbstractEntityManagerImpl implements HibernateEntityManagerImplementor, Serializable { private static final Logger log = LoggerFactory.getLogger( AbstractEntityManagerImpl.class ); + private EntityManagerFactoryImpl entityManagerFactory; protected transient TransactionImpl tx = new TransactionImpl( this ); protected PersistenceContextType persistenceContextType; private FlushModeType flushModeType = FlushModeType.AUTO; @@ -76,7 +77,11 @@ private Map properties; protected AbstractEntityManagerImpl( - PersistenceContextType type, PersistenceUnitTransactionType transactionType, Map properties) { + EntityManagerFactoryImpl entityManagerFactory, + PersistenceContextType type, + PersistenceUnitTransactionType transactionType, + Map properties) { + this.entityManagerFactory = entityManagerFactory; this.persistenceContextType = type; this.transactionType = transactionType; this.properties = properties != null ? properties : CollectionHelper.EMPTY_MAP; @@ -106,7 +111,20 @@ } public Query createQuery(CriteriaQuery criteriaQuery) { - return null; //To change body of implemented methods use File | Settings | File Templates. + // TODO-STEVE : here is the interpretation/compilation portion. + // One option is to build on top of the existing + // org.hibernate.loader.custom.CustomQuery infastructure + // (which is how native sql queries are implemented e.g.). + // If so, then here we could interpret the criteria into + // a CustomQuery instance which is passed into the + // Query instance returned here. We would then call into + // the various SessionImplementor methods for execution + // such as #listCustomQuery and #scrollCustomQuery. + // + // The drawback to this (^^) approach is that CustomQuery + + // SessionImplementor combo does not support #executeUpdate + // processing... + throw new UnsupportedOperationException( "Not yet implemented!" ); } public Query createNamedQuery(String name) { @@ -388,14 +406,18 @@ return tx; } - public EntityManagerFactory getEntityManagerFactory() { - //FIXME - return null; //To change body of implemented methods use File | Settings | File Templates. + /** + * {@inheritDoc} + */ + public EntityManagerFactoryImpl getEntityManagerFactory() { + return entityManagerFactory; } + /** + * {@inheritDoc} + */ public QueryBuilder getQueryBuilder() { - //FIXME - return null; //To change body of implemented methods use File | Settings | File Templates. + return getEntityManagerFactory().getQueryBuilder(); } public Metamodel getMetamodel() { Modified: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/CurrentEntityManagerImpl.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/CurrentEntityManagerImpl.java 2009-07-30 21:30:58 UTC (rev 17221) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/CurrentEntityManagerImpl.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -18,11 +18,11 @@ */ public class CurrentEntityManagerImpl extends AbstractEntityManagerImpl { - private SessionFactory sessionFactory; - - public CurrentEntityManagerImpl(SessionFactory sessionFactory, PersistenceUnitTransactionType transactionType, Map properties) { - super( PersistenceContextType.TRANSACTION, transactionType, properties ); - this.sessionFactory = sessionFactory; + public CurrentEntityManagerImpl( + EntityManagerFactoryImpl entityManagerFactory, + PersistenceUnitTransactionType transactionType, + Map properties) { + super( entityManagerFactory, PersistenceContextType.TRANSACTION, transactionType, properties ); postInit(); } @@ -33,14 +33,14 @@ * sure the conenctions are released. Be aware that the session will not be closed explicitly. */ + SessionFactoryImplementor sfi = (SessionFactoryImplementor) getEntityManagerFactory().getSessionFactory(); Session s; - SessionFactoryImplementor sfi = (SessionFactoryImplementor) sessionFactory; if ( !JTAHelper.isTransactionInProgress( sfi ) ) { s = sfi.openTemporarySession(); ( (SessionImplementor) s ).setAutoClear( true ); } else { - s = sessionFactory.getCurrentSession(); + s = sfi.getCurrentSession(); } return s; } Modified: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/EntityManagerFactoryImpl.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/EntityManagerFactoryImpl.java 2009-07-30 21:30:58 UTC (rev 17221) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/EntityManagerFactoryImpl.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -12,17 +12,18 @@ import javax.persistence.spi.PersistenceUnitTransactionType; import org.hibernate.SessionFactory; +import org.hibernate.ejb.criteria.QueryBuilderImpl; /** * @author Gavin King * @author Emmanuel Bernard */ public class EntityManagerFactoryImpl implements HibernateEntityManagerFactory { - private SessionFactory sessionFactory; private PersistenceUnitTransactionType transactionType; private boolean discardOnClose; private Class sessionInterceptorClass; + private QueryBuilderImpl criteriaQueryBuilder; public EntityManagerFactoryImpl( SessionFactory sessionFactory, @@ -33,6 +34,7 @@ this.transactionType = transactionType; this.discardOnClose = discardOnClose; this.sessionInterceptorClass = sessionInterceptorClass; + this.criteriaQueryBuilder = new QueryBuilderImpl( this ); } public EntityManager createEntityManager() { @@ -42,14 +44,13 @@ public EntityManager createEntityManager(Map map) { //TODO support discardOnClose, persistencecontexttype?, interceptor, return new EntityManagerImpl( - sessionFactory, PersistenceContextType.EXTENDED, transactionType, + this, PersistenceContextType.EXTENDED, transactionType, discardOnClose, sessionInterceptorClass, map ); } public QueryBuilder getQueryBuilder() { - //FIXME - return null; //To change body of implemented methods use File | Settings | File Templates. + return criteriaQueryBuilder; } public Metamodel getMetamodel() { @@ -72,6 +73,7 @@ } public Cache getCache() { + // TODO : cache the cache reference? return new JPACache( sessionFactory ); } Modified: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/EntityManagerImpl.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/EntityManagerImpl.java 2009-07-30 21:30:58 UTC (rev 17221) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/EntityManagerImpl.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -9,7 +9,6 @@ import org.hibernate.HibernateException; import org.hibernate.Session; -import org.hibernate.SessionFactory; import org.hibernate.Interceptor; import org.hibernate.annotations.common.util.ReflectHelper; import org.hibernate.cfg.Environment; @@ -21,21 +20,22 @@ * @author Gavin King */ public class EntityManagerImpl extends AbstractEntityManagerImpl { - private static final Logger log = LoggerFactory.getLogger( EntityManagerImpl.class ); + protected Session session; - protected SessionFactory sessionFactory; protected boolean open; protected boolean discardOnClose; private Class sessionInterceptorClass; public EntityManagerImpl( - SessionFactory sessionFactory, PersistenceContextType pcType, + EntityManagerFactoryImpl entityManagerFactory, + PersistenceContextType pcType, PersistenceUnitTransactionType transactionType, - boolean discardOnClose, Class sessionInterceptorClass, Map properties + boolean discardOnClose, + Class sessionInterceptorClass, + Map properties ) { - super( pcType, transactionType, properties ); - this.sessionFactory = sessionFactory; + super( entityManagerFactory, pcType, transactionType, properties ); this.open = true; this.discardOnClose = discardOnClose; Object localSessionInterceptor = null; @@ -62,7 +62,6 @@ } public Session getSession() { - if ( !open ) throw new IllegalStateException( "EntityManager is closed" ); return getRawSession(); } @@ -84,7 +83,7 @@ throw new PersistenceException("Session interceptor does not implement Interceptor: " + sessionInterceptorClass, e); } } - session = sessionFactory.openSession( interceptor ); + session = getEntityManagerFactory().getSessionFactory().openSession( interceptor ); if ( persistenceContextType == PersistenceContextType.TRANSACTION ) { ( (SessionImplementor) session ).setAutoClear( true ); } Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/AbstractNode.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/AbstractNode.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/AbstractNode.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,45 @@ +/* + * 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.ejb.criteria; + +/** + * All nodes in a criteria query tree will generally need access to the {@link QueryBuilderImpl} from which they + * come. This base class provides convenient, consistent support for that. + * + * @author Steve Ebersole + */ +public class AbstractNode { + private final QueryBuilderImpl queryBuilder; + + public AbstractNode(QueryBuilderImpl queryBuilder) { + this.queryBuilder = queryBuilder; + } + + /** + * Provides protected access to the underlying {@link QueryBuilderImpl}. + * + * @return The underlying {@link QueryBuilderImpl} instance. + */ + protected QueryBuilderImpl queryBuilder() { + return queryBuilder; + } +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/CriteriaQueryImpl.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/CriteriaQueryImpl.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/CriteriaQueryImpl.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,240 @@ +/* + * 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.ejb.criteria; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Set; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Expression; +import javax.persistence.criteria.Order; +import javax.persistence.criteria.ParameterExpression; +import javax.persistence.criteria.Predicate; +import javax.persistence.criteria.Root; +import javax.persistence.criteria.Selection; +import javax.persistence.Tuple; +import javax.persistence.criteria.Subquery; +import javax.persistence.metamodel.EntityType; + +/** + * The Hibernate implementation of the JPA {@link CriteriaQuery} + * contract. + * + * @author Steve Ebersole + */ +public class CriteriaQueryImpl<T> extends AbstractNode implements CriteriaQuery<T> { + private final Class<T> returnType; + + private final QueryStructure<T> queryStructure; + private List<Order> orderSpecs = Collections.emptyList(); + + + public CriteriaQueryImpl( + QueryBuilderImpl queryBuilder, + Class<T> returnType) { + super( queryBuilder ); + this.returnType = returnType; + this.queryStructure = new QueryStructure<T>( this, queryBuilder ); + } + + public Class<T> getResultType() { + return returnType; + } + + + // SELECTION ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + public CriteriaQuery<T> distinct(boolean applyDistinction) { + queryStructure.setDistinction( applyDistinction ); + return this; + } + + public boolean isDistinct() { + return queryStructure.isDistinction(); + } + + @SuppressWarnings({ "unchecked" }) + public Selection<T> getSelection() { + return ( Selection<T> ) queryStructure.getSelection(); + } + + public void applySelection(Selection<? extends T> selection) { + queryStructure.setSelection( selection ); + } + + public CriteriaQuery<T> select(Selection<? extends T> selection) { + applySelection( selection ); + return this; + } + + @SuppressWarnings({ "unchecked" }) + public CriteriaQuery<T> multiselect(Selection<?>... selections) { + return multiselect( Arrays.asList( selections ) ); + } + + @SuppressWarnings({ "unchecked" }) + public CriteriaQuery<T> multiselect(List<Selection<?>> selections) { + final Selection<? extends T> selection; + + if ( Tuple.class.isAssignableFrom( getResultType() ) ) { + selection = ( Selection<? extends T> ) queryBuilder().tuple( selections ); + } + else if ( getResultType().isArray() ) { + selection = ( Selection<? extends T> ) queryBuilder().array( + ( Class<? extends Object[]> ) getResultType(), + selections + ); + } + else if ( Object.class.equals( getResultType() ) ) { + switch ( selections.size() ) { + case 0: { + throw new IllegalArgumentException( + "empty selections passed to criteria query typed as Object" + ); + } + case 1: { + selection = ( Selection<? extends T> ) selections.get( 0 ); + break; + } + default: { + selection = ( Selection<? extends T> ) queryBuilder().array( selections ); + } + } + } + else { + selection = queryBuilder().construct( getResultType(), selections ); + } + applySelection( selection ); + return this; + } + + + // ROOTS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + public Set<Root<?>> getRoots() { + return queryStructure.getRoots(); + } + + public <X> Root<X> from(EntityType<X> entityType) { + return queryStructure.from( entityType ); + } + + public <X> Root<X> from(Class<X> entityClass) { + return queryStructure.from( entityClass ); + } + + + // RESTRICTION ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + /** + * {@inheritDoc} + */ + public Predicate getRestriction() { + return queryStructure.getRestriction(); + } + + /** + * {@inheritDoc} + */ + public CriteriaQuery<T> where(Expression<Boolean> expression) { + queryStructure.setRestriction( queryBuilder().wrap( expression ) ); + return this; + } + + /** + * {@inheritDoc} + */ + public CriteriaQuery<T> where(Predicate... predicates) { + // TODO : assuming this should be a conjuntion, but the spec does not say specifically... + queryStructure.setRestriction( queryBuilder().and( predicates ) ); + return this; + } + + + // GROUPING ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + /** + * {@inheritDoc} + */ + public List<Expression<?>> getGroupList() { + return queryStructure.getGroupings(); + } + + /** + * {@inheritDoc} + */ + public CriteriaQuery<T> groupBy(Expression<?>... groupings) { + queryStructure.setGroupings( groupings ); + return this; + } + + /** + * {@inheritDoc} + */ + public Predicate getGroupRestriction() { + return queryStructure.getHaving(); + } + + /** + * {@inheritDoc} + */ + public CriteriaQuery<T> having(Expression<Boolean> expression) { + queryStructure.setHaving( queryBuilder().wrap( expression ) ); + return this; + } + + /** + * {@inheritDoc} + */ + public CriteriaQuery<T> having(Predicate... predicates) { + queryStructure.setHaving( queryBuilder().and( predicates ) ); + return this; + } + + + // ORDERING ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + public List<Order> getOrderList() { + return orderSpecs; + } + + public CriteriaQuery<T> orderBy(Order... orders) { + if ( orders != null && orders.length > 0 ) { + orderSpecs = Arrays.asList( orders ); + } + else { + orderSpecs = Collections.emptyList(); + } + return this; + } + + public Set<ParameterExpression<?>> getParameters() { + // TODO-STEVE : implement + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + public <U> Subquery<U> subquery(Class<U> subqueryType) { + return queryStructure.subquery( subqueryType ); + } + +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/CriteriaSubqueryImpl.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/CriteriaSubqueryImpl.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/CriteriaSubqueryImpl.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,205 @@ +/* + * 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.ejb.criteria; + +import java.util.List; +import java.util.Set; +import javax.persistence.criteria.AbstractQuery; +import javax.persistence.criteria.CollectionJoin; +import javax.persistence.criteria.Expression; +import javax.persistence.criteria.Join; +import javax.persistence.criteria.ListJoin; +import javax.persistence.criteria.MapJoin; +import javax.persistence.criteria.Predicate; +import javax.persistence.criteria.Root; +import javax.persistence.criteria.SetJoin; +import javax.persistence.criteria.Subquery; +import javax.persistence.metamodel.EntityType; +import org.hibernate.ejb.criteria.expression.AbstractExpression; + +/** + * TODO : javadoc + * + * @author Steve Ebersole + */ +public class CriteriaSubqueryImpl<T> extends AbstractExpression<T> implements Subquery<T> { + private final AbstractQuery<?> parent; + private final QueryStructure<T> queryStructure; + + private Expression<T> selection; + private Set<Join<?, ?>> joins; + + public CriteriaSubqueryImpl( + QueryBuilderImpl queryBuilder, + Class<T> javaType, + AbstractQuery<?> parent) { + super(queryBuilder, javaType); + this.parent = parent; + this.queryStructure = new QueryStructure<T>( this, queryBuilder ); + } + + public AbstractQuery<?> getParent() { + return parent; + } + + + // ROOTS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + public Set<Root<?>> getRoots() { + return queryStructure.getRoots(); + } + + public <X> Root<X> from(EntityType<X> entityType) { + return queryStructure.from( entityType ); + } + + public <X> Root<X> from(Class<X> entityClass) { + return queryStructure.from( entityClass ); + } + + + // SELECTION ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + public Subquery<T> distinct(boolean applyDistinction) { + queryStructure.setDistinction( applyDistinction ); + return this; + } + + public boolean isDistinct() { + return queryStructure.isDistinction(); + } + + public Expression<T> getSelection() { + return selection; + } + + public Subquery<T> select(Expression<T> expression) { + queryStructure.setSelection( selection ); + this.selection = expression; + return this; + } + + + // RESTRICTION ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + /** + * {@inheritDoc} + */ + public Predicate getRestriction() { + return queryStructure.getRestriction(); + } + + /** + * {@inheritDoc} + */ + public Subquery<T> where(Expression<Boolean> expression) { + queryStructure.setRestriction( queryBuilder().wrap( expression ) ); + return this; + } + + /** + * {@inheritDoc} + */ + public Subquery<T> where(Predicate... predicates) { + // TODO : assuming this should be a conjuntion, but the spec does not say specifically... + queryStructure.setRestriction( queryBuilder().and( predicates ) ); + return this; + } + + + + // GROUPING ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + /** + * {@inheritDoc} + */ + public List<Expression<?>> getGroupList() { + return queryStructure.getGroupings(); + } + + /** + * {@inheritDoc} + */ + public Subquery<T> groupBy(Expression<?>... groupings) { + queryStructure.setGroupings( groupings ); + return this; + } + + /** + * {@inheritDoc} + */ + public Predicate getGroupRestriction() { + return queryStructure.getHaving(); + } + + /** + * {@inheritDoc} + */ + public Subquery<T> having(Expression<Boolean> expression) { + queryStructure.setHaving( queryBuilder().wrap( expression ) ); + return this; + } + + /** + * {@inheritDoc} + */ + public Subquery<T> having(Predicate... predicates) { + queryStructure.setHaving( queryBuilder().and( predicates ) ); + return this; + } + + + // CORRELATIONS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + public Set<Join<?, ?>> getJoins() { + return joins; + } + + public <Y> Root<Y> correlate(Root<Y> arg0) { + throw new UnsupportedOperationException("Not supported yet."); + } + + public <X, Y> Join<X, Y> correlate(Join<X, Y> arg0) { + throw new UnsupportedOperationException("Not supported yet."); + } + + public <X, Y> CollectionJoin<X, Y> correlate(CollectionJoin<X, Y> arg0) { + throw new UnsupportedOperationException("Not supported yet."); + } + + public <X, Y> SetJoin<X, Y> correlate(SetJoin<X, Y> arg0) { + throw new UnsupportedOperationException("Not supported yet."); + } + + public <X, Y> ListJoin<X, Y> correlate(ListJoin<X, Y> arg0) { + throw new UnsupportedOperationException("Not supported yet."); + } + + public <X, K, V> MapJoin<X, K, V> correlate(MapJoin<X, K, V> arg0) { + throw new UnsupportedOperationException("Not supported yet."); + } + + public <U> Subquery<U> subquery(Class<U> subqueryType) { + return queryStructure.subquery( subqueryType ); + } + +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/FromImpl.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/FromImpl.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/FromImpl.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,338 @@ +/* + * 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.ejb.criteria; + +import java.util.Set; +import java.util.Collection; +import java.util.Map; +import java.util.LinkedHashSet; +import javax.persistence.criteria.From; +import javax.persistence.criteria.Join; +import javax.persistence.criteria.JoinType; +import javax.persistence.criteria.CollectionJoin; +import javax.persistence.criteria.SetJoin; +import javax.persistence.criteria.ListJoin; +import javax.persistence.criteria.MapJoin; +import javax.persistence.criteria.Path; +import javax.persistence.criteria.Expression; +import javax.persistence.criteria.Fetch; +import javax.persistence.metamodel.Attribute; +import javax.persistence.metamodel.SingularAttribute; +import javax.persistence.metamodel.CollectionAttribute; +import javax.persistence.metamodel.SetAttribute; +import javax.persistence.metamodel.ListAttribute; +import javax.persistence.metamodel.MapAttribute; +import javax.persistence.metamodel.Bindable; +import javax.persistence.metamodel.EntityType; +import javax.persistence.metamodel.ManagedType; +import javax.persistence.metamodel.PluralAttribute; + +import javax.persistence.metamodel.Type.PersistenceType; +import org.hibernate.ejb.criteria.expression.AbstractExpression; +import org.hibernate.ejb.criteria.expression.EntityTypeExpression; + +/** + * TODO : javadoc + * + * @author Steve Ebersole + */ +public abstract class FromImpl<Z,X> extends PathImpl<X> implements From<Z,X> { + public static final JoinType DEFAULT_JOIN_TYPE = JoinType.INNER; + + private final Expression<Class<? extends X>> type; + private Set<Join<X, ?>> joins; + private Set<Fetch<X, ?>> fetches; + + /** + * Special constructor for {@link RootImpl}. + * + * @param queryBuilder + * @param entityType + */ + protected FromImpl(QueryBuilderImpl queryBuilder, EntityType<X> entityType) { + super( queryBuilder, entityType.getBindableJavaType(), null, entityType ); + this.type = new EntityTypeExpression( queryBuilder, entityType.getBindableJavaType() ); + } + + public FromImpl( + QueryBuilderImpl queryBuilder, + Class<X> javaType, + PathImpl<Z> origin, + Bindable<X> model, + Expression<Class<? extends X>> type) { + super( queryBuilder, javaType, origin, model ); + this.type = type; + } + + @Override + public Expression<Class<? extends X>> type() { + return type; + } + + + // JOINS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + /** + * {@inheritDoc} + */ + public Set<Join<X, ?>> getJoins() { + return joins; + } + + /** + * Retrieve the collection of joins, imnplementing delayed creations. Calls on this method + * assume the set is physically needed, and the result is the set being built if not already. + * + * @return The set of joins. + */ + public Set<Join<X, ?>> getJoinsInternal() { + if ( joins == null ) { + joins = new LinkedHashSet<Join<X,?>>(); + } + return joins; + } + + /** + * {@inheritDoc} + */ + public <Y> Join<X, Y> join(SingularAttribute<? super X, Y> singularAttribute) { + return join( singularAttribute, DEFAULT_JOIN_TYPE ); + } + + /** + * {@inheritDoc} + */ + public <Y> Join<X, Y> join(SingularAttribute<? super X, Y> attribute, JoinType jt) { + if ( PersistenceType.BASIC.equals( attribute.getType().getPersistenceType() ) ) { + throw new IllegalStateException( "Cannot join to basic type" ); + } + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + /** + * {@inheritDoc} + */ + public <Y> CollectionJoin<X, Y> join(CollectionAttribute<? super X, Y> collection) { + return join( collection, DEFAULT_JOIN_TYPE ); + } + + /** + * {@inheritDoc} + */ + public <Y> CollectionJoin<X, Y> join(CollectionAttribute<? super X, Y> collection, JoinType jt) { + // TODO : implement + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + /** + * {@inheritDoc} + */ + public <Y> SetJoin<X, Y> join(SetAttribute<? super X, Y> set) { + return join( set, DEFAULT_JOIN_TYPE ); + } + + /** + * {@inheritDoc} + */ + public <Y> SetJoin<X, Y> join(SetAttribute<? super X, Y> set, JoinType jt) { + // TODO : implement + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + /** + * {@inheritDoc} + */ + public <Y> ListJoin<X, Y> join(ListAttribute<? super X, Y> list) { + return join( list, DEFAULT_JOIN_TYPE ); + } + + /** + * {@inheritDoc} + */ + public <Y> ListJoin<X, Y> join(ListAttribute<? super X, Y> list, JoinType jt) { + // TODO : implement + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + /** + * {@inheritDoc} + */ + public <K, V> MapJoin<X, K, V> join(MapAttribute<? super X, K, V> map) { + return join( map, DEFAULT_JOIN_TYPE ); + } + + /** + * {@inheritDoc} + */ + public <K, V> MapJoin<X, K, V> join(MapAttribute<? super X, K, V> map, JoinType jt) { + // TODO : implement + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + /** + * {@inheritDoc} + */ + public <X, Y> Join<X, Y> join(String attributeName) { + return join( attributeName, DEFAULT_JOIN_TYPE ); + } + + /** + * {@inheritDoc} + */ + public <X, Y> Join<X, Y> join(String attributeName, JoinType jt) { + // TODO : implement + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + /** + * {@inheritDoc} + */ + public <X, Y> CollectionJoin<X, Y> joinCollection(String attributeName) { + return joinCollection( attributeName, DEFAULT_JOIN_TYPE ); + } + + /** + * {@inheritDoc} + */ + public <X, Y> CollectionJoin<X, Y> joinCollection(String attributeName, JoinType jt) { + // TODO : implement + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + /** + * {@inheritDoc} + */ + public <X, Y> SetJoin<X, Y> joinSet(String attributeName) { + return joinSet( attributeName, DEFAULT_JOIN_TYPE ); + } + + /** + * {@inheritDoc} + */ + public <X, Y> SetJoin<X, Y> joinSet(String attributeName, JoinType jt) { + // TODO : implement + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + /** + * {@inheritDoc} + */ + public <X, Y> ListJoin<X, Y> joinList(String attributeName) { + return joinList( attributeName, DEFAULT_JOIN_TYPE ); + } + + /** + * {@inheritDoc} + */ + public <X, Y> ListJoin<X, Y> joinList(String attributeName, JoinType jt) { + // TODO : implement + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + /** + * {@inheritDoc} + */ + public <X, K, V> MapJoin<X, K, V> joinMap(String attributeName) { + return joinMap( attributeName, DEFAULT_JOIN_TYPE ); + } + + /** + * {@inheritDoc} + */ + public <X, K, V> MapJoin<X, K, V> joinMap(String attributeName, JoinType jt) { + // TODO : implement + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + + // FETCHES ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + /** + * {@inheritDoc} + */ + public Set<Fetch<X, ?>> getFetches() { + return fetches; + } + + /** + * Retrieve the collection of fetches, imnplementing delayed creations. Calls on this method + * assume the set is physically needed, and the result is the set being built if not already. + * + * @return The set of fetches. + */ + public Set<Fetch<X, ?>> getFetchesInternal() { + if ( fetches == null ) { + fetches = new LinkedHashSet<Fetch<X,?>>(); + } + return fetches; + } + + public <Y> Fetch<X, Y> fetch(SingularAttribute<? super X, Y> singularAttribute) { + return fetch( singularAttribute, DEFAULT_JOIN_TYPE ); + } + + public <Y> Fetch<X, Y> fetch(SingularAttribute<? super X, Y> singularAttribute, JoinType jt) { + // TODO : implement + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + public <Y> Fetch<X, Y> fetch(PluralAttribute<? super X, ?, Y> pluralAttribute) { + return fetch( pluralAttribute, DEFAULT_JOIN_TYPE ); + } + + public <Y> Fetch<X, Y> fetch(PluralAttribute<? super X, ?, Y> pluralAttribute, JoinType jt) { + // TODO : implement + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + public <Y> Fetch<X, Y> fetch(String attributeName) { + return fetch( attributeName, DEFAULT_JOIN_TYPE ); + } + + public <Y> Fetch<X, Y> fetch(String attributeName, JoinType jt) { + // TODO : implement + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + + // PATH HANDLING ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + public <Y> Path<Y> get(SingularAttribute<? super X, Y> ySingularAttribute) { + // TODO : implement + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + public <E, C extends Collection<E>> Expression<C> get(PluralAttribute<X, C, E> collection) { + // TODO : implement + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + public <K, V, M extends Map<K, V>> Expression<M> get(MapAttribute<X, K, V> map) { + // TODO : implement + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + public <Y> Path<Y> get(String attributeName) { + // TODO : implement + throw new UnsupportedOperationException( "Not yet implemented!" ); + } +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/OrderImpl.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/OrderImpl.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/OrderImpl.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,57 @@ +/* + * 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.ejb.criteria; + +import javax.persistence.criteria.Order; +import javax.persistence.criteria.Expression; + +/** + * TODO : javadoc + * + * @author Steve Ebersole + */ +public class OrderImpl implements Order { + private final Expression<?> expression; + private boolean ascending; + + public OrderImpl(Expression<?> expression) { + this( expression, true ); + } + + public OrderImpl(Expression<?> expression, boolean ascending) { + this.expression = expression; + this.ascending = ascending; + } + + public Order reverse() { + ascending = !ascending; + return this; + } + + public boolean isAscending() { + return ascending; + } + + public Expression<?> getExpression() { + return expression; + } +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/PathImpl.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/PathImpl.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/PathImpl.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,121 @@ +/* + * 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.ejb.criteria; + +import java.util.Collection; +import java.util.Map; +import javax.persistence.criteria.Expression; +import javax.persistence.criteria.Path; + +import javax.persistence.metamodel.Bindable; +import javax.persistence.metamodel.EntityType; +import javax.persistence.metamodel.MapAttribute; +import javax.persistence.metamodel.PluralAttribute; +import javax.persistence.metamodel.SingularAttribute; +import org.hibernate.ejb.criteria.expression.AbstractExpression; + +/** + * A {@link Path} models an individual portion of a join expression. + * + * @author Steve Ebersole + */ +public class PathImpl<X> extends AbstractExpression<X> implements Path<X> { + private final PathImpl<?> origin; + private Bindable<X> model; + + protected PathImpl( + QueryBuilderImpl queryBuilder, + Class<X> javaType, + PathImpl<?> origin, + Bindable<X> model) { + super( queryBuilder, javaType ); + this.origin = origin; + this.model = model; + } + + /** + * {@inheritDoc} + */ + public PathImpl<?> getParentPath() { + return origin; + } + + /** + * {@inheritDoc} + */ + public Bindable<X> getModel() { + if ( model == null ) { + throw new IllegalStateException( this + " represents a basic path and not a bindable" ); + } + return model; + } + + /** + * {@inheritDoc} + * <p/> + * Subclasses override this appropriately, but here we simply throw + * an {@link IllegalStateException} + */ + public Expression<Class<? extends X>> type() { + throw new IllegalStateException( "type() is not applicable to a primitive path node." ); } + + /** + * {@inheritDoc} + * <p/> + * Subclasses override this appropriately, but here we simply throw + * an {@link IllegalStateException} + */ + public <Y> Path<Y> get(SingularAttribute<? super X, Y> attribute) { + throw new IllegalStateException( this + " is a primitive path node." ); + } + + /** + * {@inheritDoc} + * <p/> + * Subclasses override this appropriately, but here we simply throw + * an {@link IllegalStateException} + */ + public <E, C extends Collection<E>> Expression<C> get(PluralAttribute<X, C, E> collection) { + throw new IllegalStateException( this + " is a primitive path node." ); + } + + /** + * {@inheritDoc} + * <p/> + * Subclasses override this appropriately, but here we simply throw + * an {@link IllegalStateException} + */ + public <K, V, M extends Map<K, V>> Expression<M> get(MapAttribute<X, K, V> map) { + throw new IllegalStateException( this + " is a primitive path node." ); + } + + /** + * {@inheritDoc} + * <p/> + * Subclasses override this appropriately, but here we simply throw + * an {@link IllegalStateException} + */ + public <Y> Path<Y> get(String attributeName) { + throw new IllegalStateException( this + " is a primitive path node." ); + } + +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/QueryBuilderImpl.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/QueryBuilderImpl.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/QueryBuilderImpl.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,948 @@ +/* + * 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.ejb.criteria; + +import java.io.Serializable; +import java.util.List; +import java.util.Arrays; +import java.util.Collection; +import java.util.Map; +import java.util.Set; +import java.math.BigDecimal; +import java.math.BigInteger; +import javax.persistence.criteria.QueryBuilder; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Selection; +import javax.persistence.criteria.CompoundSelection; +import javax.persistence.criteria.Order; +import javax.persistence.criteria.Expression; +import javax.persistence.criteria.Predicate; +import javax.persistence.criteria.ParameterExpression; +import javax.persistence.criteria.Subquery; +import javax.persistence.Tuple; + +import org.hibernate.ejb.EntityManagerFactoryImpl; +import org.hibernate.ejb.criteria.expression.CompoundSelectionImpl; +import org.hibernate.ejb.criteria.expression.ParameterExpressionImpl; +import org.hibernate.ejb.criteria.expression.LiteralExpression; +import org.hibernate.ejb.criteria.expression.function.AverageAggregrateFunction; +import org.hibernate.ejb.criteria.expression.function.SumAggregateFunction; +import org.hibernate.ejb.criteria.predicate.BooleanExpressionPredicate; +import org.hibernate.ejb.criteria.predicate.ExplicitTruthValueCheck; +import org.hibernate.ejb.criteria.predicate.TruthValue; +import org.hibernate.ejb.criteria.predicate.NullnessPredicate; +import org.hibernate.ejb.criteria.predicate.CompoundPredicate; +import org.hibernate.ejb.criteria.predicate.ComparisonPredicate; +import org.hibernate.ejb.criteria.predicate.InPredicate; +import org.hibernate.ejb.criteria.predicate.BetweenPredicate; +import static org.hibernate.ejb.criteria.predicate.ComparisonPredicate.ComparisonOperator; + +/** + * TODO : javadoc + * + * @author Steve Ebersole + */ +public class QueryBuilderImpl implements QueryBuilder, Serializable { + private final EntityManagerFactoryImpl entityManagerFactory; + + public QueryBuilderImpl(EntityManagerFactoryImpl entityManagerFactory) { + this.entityManagerFactory = entityManagerFactory; + } + + /** + * Provides protected access to the underlying {@link EntityManagerFactoryImpl}. + * + * @return The underlying {@link EntityManagerFactoryImpl} + */ + protected EntityManagerFactoryImpl getEntityManagerFactory() { + return entityManagerFactory; + } + + /** + * {@inheritDoc} + */ + public CriteriaQuery<Object> createQuery() { + return new CriteriaQueryImpl<Object>( this, Object.class ); + } + + /** + * {@inheritDoc} + */ + public <T> CriteriaQuery<T> createQuery(Class<T> resultClass) { + return new CriteriaQueryImpl<T>( this, resultClass ); + } + + /** + * {@inheritDoc} + */ + public CriteriaQuery<Tuple> createTupleQuery() { + return new CriteriaQueryImpl<Tuple>( this, Tuple.class ); + } + + /** + * Package-protected method to centralize checking of criteria query + * multiselects as defined by the + * {@link CriteriaQuery#multiselect(List)} method. + * + * @param selections The selection varargs to check + * + * @throws IllegalArgumentException If, as per + * {@link CriteriaQuery#multiselect(List)} documentation, + * <i>&quot;An argument to the multiselect method must not be a tuple- + * or array-valued compound selection item.&quot;</i> + */ + void checkMultiselect(List<Selection<?>> selections) { + for ( Selection<?> selection : selections ) { + if ( selection.isCompoundSelection() ) { + if ( selection.getJavaType().isArray() ) { + throw new IllegalArgumentException( + "multiselect selections cannot contain " + + "compound array-valued elements" + ); + } + if ( Tuple.class.isAssignableFrom( selection.getJavaType() ) ) { + throw new IllegalArgumentException( + "multiselect selections cannot contain " + + "compound tuple-valued elements" + ); + } + } + } + } + + /** + * {@inheritDoc} + */ + public CompoundSelection<Tuple> tuple(Selection<?>... selections) { + return tuple( Arrays.asList( selections ) ); + } + + /** + * Version of {@link #tuple(Selection[])} taking a list. + * + * @param selections List of selections. + * + * @return The tuple compound selection + */ + public CompoundSelection<Tuple> tuple(List<Selection<?>> selections) { + checkMultiselect( selections ); + return new CompoundSelectionImpl<Tuple>( this, Tuple.class, selections ); + } + + /** + * {@inheritDoc} + */ + public CompoundSelection<Object[]> array(Selection<?>... selections) { + return array( Arrays.asList( selections ) ); + } + + /** + * Version of {@link #array(Selection[])} taking a list of selections. + * + * @param selections List of selections. + * + * @return The array compound selection + */ + public CompoundSelection<Object[]> array(List<Selection<?>> selections) { + return array( Object[].class, selections ); + } + + /** + * Version of {@link #array(Selection[])} taking a list of selections, + * as well as the type of array. + * + * @param type The type of array + * @param selections List of selections. + * + * @return The array compound selection + */ + public <Y> CompoundSelection<Y> array(Class<Y> type, List<Selection<?>> selections) { + checkMultiselect( selections ); + return new CompoundSelectionImpl<Y>( this, type, selections ); + } + + /** + * {@inheritDoc} + */ + public <Y> CompoundSelection<Y> construct(Class<Y> result, Selection<?>... selections) { + return construct( result, Arrays.asList( selections ) ); + } + + /** + * Version of {@link #construct(Class,Selection[])} taking the + * to-be-constructed type as well as a list of selections. + * + * @param result The result class to be constructed. + * @param selections The selections to use in the constructor call. + * + * @return The <b>view</b> compound selection. + */ + public <Y> CompoundSelection<Y> construct(Class<Y> result, List<Selection<?>> selections) { + checkMultiselect( selections ); + return new CompoundSelectionImpl<Y>( this, result, selections ); + } + + + // ordering ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + /** + * {@inheritDoc} + */ + public Order asc(Expression<?> x) { + return new OrderImpl( x, true ); + } + + /** + * {@inheritDoc} + */ + public Order desc(Expression<?> x) { + return new OrderImpl( x, false ); + } + + + // predicates ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + public Predicate wrap(Expression<Boolean> expression) { + if ( Predicate.class.isInstance( expression ) ) { + return ( ( Predicate ) expression ); + } + else { + return new BooleanExpressionPredicate( this, expression ); + } + } + + /** + * {@inheritDoc} + */ + public Predicate not(Expression<Boolean> expression) { + return wrap( expression ).negate(); + } + + /** + * {@inheritDoc} + */ + public Predicate and(Expression<Boolean> x, Expression<Boolean> y) { + return new CompoundPredicate( this, Predicate.BooleanOperator.AND, x, y ); + } + + /** + * {@inheritDoc} + */ + public Predicate or(Expression<Boolean> x, Expression<Boolean> y) { + return new CompoundPredicate( this, Predicate.BooleanOperator.OR, x, y ); + } + + /** + * {@inheritDoc} + */ + public Predicate and(Predicate... restrictions) { + return new CompoundPredicate( this, Predicate.BooleanOperator.AND, restrictions ); + } + + /** + * {@inheritDoc} + */ + public Predicate or(Predicate... restrictions) { + return new CompoundPredicate( this, Predicate.BooleanOperator.OR, restrictions ); + } + + /** + * {@inheritDoc} + */ + public Predicate conjunction() { + return new CompoundPredicate( this, Predicate.BooleanOperator.AND ); + } + + /** + * {@inheritDoc} + */ + public Predicate disjunction() { + return new CompoundPredicate( this, Predicate.BooleanOperator.OR ); + } + + /** + * {@inheritDoc} + */ + public Predicate isTrue(Expression<Boolean> x) { + return new ExplicitTruthValueCheck( this, x, TruthValue.TRUE ); + } + + /** + * {@inheritDoc} + */ + public Predicate isFalse(Expression<Boolean> x) { + return new ExplicitTruthValueCheck( this, x, TruthValue.FALSE ); + } + + /** + * {@inheritDoc} + */ + public Predicate isNull(Expression<?> x) { + return new NullnessPredicate( this, x ); + } + + /** + * {@inheritDoc} + */ + public Predicate isNotNull(Expression<?> x) { + return isNull( x ).negate(); + } + + /** + * {@inheritDoc} + */ + public Predicate equal(Expression<?> x, Expression<?> y) { + //noinspection SuspiciousNameCombination + return new ComparisonPredicate( this, ComparisonOperator.EQUAL, x, y ); + } + + /** + * {@inheritDoc} + */ + public Predicate notEqual(Expression<?> x, Expression<?> y) { + //noinspection SuspiciousNameCombination + return new ComparisonPredicate( this, ComparisonOperator.NOT_EQUAL, x, y ); + } + + /** + * {@inheritDoc} + */ + public Predicate equal(Expression<?> x, Object y) { + //noinspection SuspiciousNameCombination + return new ComparisonPredicate( this, ComparisonOperator.EQUAL, x, y ); + } + + /** + * {@inheritDoc} + */ + public Predicate notEqual(Expression<?> x, Object y) { + //noinspection SuspiciousNameCombination + return new ComparisonPredicate( this, ComparisonOperator.NOT_EQUAL, x, y ).negate(); + } + + /** + * {@inheritDoc} + */ + public <Y extends Comparable<Y>> Predicate greaterThan(Expression<? extends Y> x, Expression<? extends Y> y) { + //noinspection SuspiciousNameCombination + return new ComparisonPredicate( this, ComparisonOperator.GREATER_THAN, x, y ); + } + + /** + * {@inheritDoc} + */ + public <Y extends Comparable<Y>> Predicate lessThan( + Expression<? extends Y> x, + Expression<? extends Y> y) { + //noinspection SuspiciousNameCombination + return new ComparisonPredicate( this, ComparisonOperator.LESS_THAN, x, y ); + } + + /** + * {@inheritDoc} + */ + public <Y extends Comparable<Y>> Predicate greaterThanOrEqualTo( + Expression<? extends Y> x, + Expression<? extends Y> y) { + //noinspection SuspiciousNameCombination + return new ComparisonPredicate( this, ComparisonOperator.GREATER_THAN_OR_EQUAL, x, y ); + } + + /** + * {@inheritDoc} + */ + public <Y extends Comparable<Y>> Predicate lessThanOrEqualTo( + Expression<? extends Y> x, + Expression<? extends Y> y) { + //noinspection SuspiciousNameCombination + return new ComparisonPredicate( this, ComparisonOperator.LESS_THAN_OR_EQUAL, x, y ); + } + + /** + * {@inheritDoc} + */ + public <Y extends Comparable<Y>> Predicate greaterThan( + Expression<? extends Y> x, + Y y) { + //noinspection SuspiciousNameCombination + return new ComparisonPredicate( this, ComparisonOperator.GREATER_THAN, x, y ); + } + + /** + * {@inheritDoc} + */ + public <Y extends Comparable<Y>> Predicate lessThan( + Expression<? extends Y> x, + Y y) { + //noinspection SuspiciousNameCombination + return new ComparisonPredicate( this, ComparisonOperator.LESS_THAN, x, y ); + } + + /** + * {@inheritDoc} + */ + public <Y extends Comparable<Y>> Predicate greaterThanOrEqualTo( + Expression<? extends Y> x, + Y y) { + //noinspection SuspiciousNameCombination + return new ComparisonPredicate( this, ComparisonOperator.GREATER_THAN_OR_EQUAL, x, y ); + } + + /** + * {@inheritDoc} + */ + public <Y extends Comparable<Y>> Predicate lessThanOrEqualTo( + Expression<? extends Y> x, + Y y) { + //noinspection SuspiciousNameCombination + return new ComparisonPredicate( this, ComparisonOperator.LESS_THAN_OR_EQUAL, x, y ); + } + + /** + * {@inheritDoc} + */ + public Predicate gt(Expression<? extends Number> x, Expression<? extends Number> y) { + //noinspection SuspiciousNameCombination + return new ComparisonPredicate( this, ComparisonOperator.GREATER_THAN, x, y ); + } + + /** + * {@inheritDoc} + */ + public Predicate lt(Expression<? extends Number> x, Expression<? extends Number> y) { + //noinspection SuspiciousNameCombination + return new ComparisonPredicate( this, ComparisonOperator.LESS_THAN, x, y ); + } + + /** + * {@inheritDoc} + */ + public Predicate ge(Expression<? extends Number> x, Expression<? extends Number> y) { + //noinspection SuspiciousNameCombination + return new ComparisonPredicate( this, ComparisonOperator.GREATER_THAN_OR_EQUAL, x, y ); + } + + /** + * {@inheritDoc} + */ + public Predicate le(Expression<? extends Number> x, Expression<? extends Number> y) { + //noinspection SuspiciousNameCombination + return new ComparisonPredicate( this, ComparisonOperator.LESS_THAN_OR_EQUAL, x, y ); + } + + /** + * {@inheritDoc} + */ + public Predicate gt(Expression<? extends Number> x, Number y) { + //noinspection SuspiciousNameCombination + return new ComparisonPredicate( this, ComparisonOperator.GREATER_THAN, x, y ); + } + + /** + * {@inheritDoc} + */ + public Predicate lt(Expression<? extends Number> x, Number y) { + //noinspection SuspiciousNameCombination + return new ComparisonPredicate( this, ComparisonOperator.LESS_THAN, x, y ); + } + + /** + * {@inheritDoc} + */ + public Predicate ge(Expression<? extends Number> x, Number y) { + //noinspection SuspiciousNameCombination + return new ComparisonPredicate( this, ComparisonOperator.GREATER_THAN_OR_EQUAL, x, y ); + } + + /** + * {@inheritDoc} + */ + public Predicate le(Expression<? extends Number> x, Number y) { + //noinspection SuspiciousNameCombination + return new ComparisonPredicate( this, ComparisonOperator.LESS_THAN_OR_EQUAL, x, y ); + } + + /** + * {@inheritDoc} + */ + public <Y extends Comparable<Y>> Predicate between( + Expression<? extends Y> expression, + Y lowerBound, + Y upperBound) { + return new BetweenPredicate<Y>( this, expression, lowerBound, upperBound ); + } + + /** + * {@inheritDoc} + */ + public <Y extends Comparable<Y>> Predicate between( + Expression<? extends Y> expression, + Expression<? extends Y> lowerBound, + Expression<? extends Y> upperBound) { + return new BetweenPredicate<Y>( this, expression, lowerBound, upperBound ); + } + + /** + * {@inheritDoc} + */ + public <T> In<T> in(Expression<? extends T> expression) { + return new InPredicate<T>( this, expression ); + } + + public <T> In<T> in(Expression<? extends T> expression, Expression<? extends T>... values) { + return new InPredicate<T>( this, expression, values ); + } + + public <T> In<T> in(Expression<? extends T> expression, T... values) { + return new InPredicate<T>( this, expression, values ); + } + + public <T> In<T> in(Expression<? extends T> expression, Collection<T> values) { + return new InPredicate<T>( this, expression, values ); + } + + + // parameters ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + /** + * {@inheritDoc} + */ + public <T> ParameterExpression<T> parameter(Class<T> paramClass) { + // TODO : AFAICT there is really no way to implement this one correctly. + // the problem is the need to report getPosition... + throw new UnsupportedOperationException( "Note yet implemented!" ); +// return new ParameterExpressionImpl( this, paramClass, ??? ); + } + + /** + * {@inheritDoc} + */ + public <T> ParameterExpression<T> parameter(Class<T> paramClass, String name) { + return new ParameterExpressionImpl<T>( this, paramClass, name ); + } + + /** + * {@inheritDoc} + */ + public <T> Expression<T> literal(T value) { + return new LiteralExpression<T>( this, value ); + } + + + // aggregate functions ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + /** + * {@inheritDoc} + */ + public <N extends Number> Expression<Double> avg(Expression<N> x) { + return new AverageAggregrateFunction( this, x ); + } + + /** + * {@inheritDoc} + */ + public <N extends Number> Expression<N> sum(Expression<N> x) { + return new SumAggregateFunction<N>( this, x ); + } + + /** + * {@inheritDoc} + */ + public <N extends Number> Expression<N> max(Expression<N> x) { + // TODO : requires a MaxAggregrateFunction + throw new UnsupportedOperationException( "Note yet implemented!" ); + } + + /** + * {@inheritDoc} + */ + public <N extends Number> Expression<N> min(Expression<N> x) { + // TODO : requires a MaxAggregrateFunction + throw new UnsupportedOperationException( "Note yet implemented!" ); + } + + /** + * {@inheritDoc} + */ + public <X extends Comparable<X>> Expression<X> greatest(Expression<X> x) { + // TODO : not exactly sure what this should be returning, same as #max ? + throw new UnsupportedOperationException( "Note yet implemented!" ); + } + + /** + * {@inheritDoc} + */ + public <X extends Comparable<X>> Expression<X> least(Expression<X> x) { + // TODO : not exactly sure what this should be returning, same as #min ? + throw new UnsupportedOperationException( "Note yet implemented!" ); + } + + /** + * {@inheritDoc} + */ + public Expression<Long> count(Expression<?> x) { + // TODO : CountAggregateFunction + throw new UnsupportedOperationException( "Note yet implemented!" ); + } + + /** + * {@inheritDoc} + */ + public Expression<Long> countDistinct(Expression<?> x) { + // TODO : CountDistinctAggregateFunction or CountAggregateFunction w/ distinct parameterization + throw new UnsupportedOperationException( "Note yet implemented!" ); + } + + + + // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + public Predicate exists(Subquery<?> subquery) { + return null; + } + + public <Y> Expression<Y> all(Subquery<Y> ySubquery) { + return null; + } + + public <Y> Expression<Y> some(Subquery<Y> ySubquery) { + return null; + } + + public <Y> Expression<Y> any(Subquery<Y> ySubquery) { + return null; + } + + public <N extends Number> Expression<N> neg(Expression<N> nExpression) { + return null; + } + + public <N extends Number> Expression<N> abs(Expression<N> nExpression) { + return null; + } + + public <N extends Number> Expression<N> sum(Expression<? extends N> expression, Expression<? extends N> expression1) { + return null; + } + + public <N extends Number> Expression<N> prod(Expression<? extends N> expression, Expression<? extends N> expression1) { + return null; + } + + public <N extends Number> Expression<N> diff(Expression<? extends N> expression, Expression<? extends N> expression1) { + return null; + } + + public <N extends Number> Expression<N> sum(Expression<? extends N> expression, N n) { + return null; + } + + public <N extends Number> Expression<N> prod(Expression<? extends N> expression, N n) { + return null; + } + + public <N extends Number> Expression<N> diff(Expression<? extends N> expression, N n) { + return null; + } + + public <N extends Number> Expression<N> sum(N n, Expression<? extends N> expression) { + return null; + } + + public <N extends Number> Expression<N> prod(N n, Expression<? extends N> expression) { + return null; + } + + public <N extends Number> Expression<N> diff(N n, Expression<? extends N> expression) { + return null; + } + + public Expression<Number> quot(Expression<? extends Number> expression, Expression<? extends Number> expression1) { + return null; + } + + public Expression<Number> quot(Expression<? extends Number> expression, Number number) { + return null; + } + + public Expression<Number> quot(Number number, Expression<? extends Number> expression) { + return null; + } + + public Expression<Integer> mod(Expression<Integer> integerExpression, Expression<Integer> integerExpression1) { + return null; + } + + public Expression<Integer> mod(Expression<Integer> integerExpression, Integer integer) { + return null; + } + + public Expression<Integer> mod(Integer integer, Expression<Integer> integerExpression) { + return null; + } + + public Expression<Double> sqrt(Expression<? extends Number> expression) { + return null; + } + + public Expression<Long> toLong(Expression<? extends Number> expression) { + return null; + } + + public Expression<Integer> toInteger(Expression<? extends Number> expression) { + return null; + } + + public Expression<Float> toFloat(Expression<? extends Number> expression) { + return null; + } + + public Expression<Double> toDouble(Expression<? extends Number> expression) { + return null; + } + + public Expression<BigDecimal> toBigDecimal(Expression<? extends Number> expression) { + return null; + } + + public Expression<BigInteger> toBigInteger(Expression<? extends Number> expression) { + return null; + } + + public Expression<String> toString(Expression<Character> characterExpression) { + return null; + } + + public <C extends Collection<?>> Predicate isEmpty(Expression<C> cExpression) { + return null; + } + + public <C extends Collection<?>> Predicate isNotEmpty(Expression<C> cExpression) { + return null; + } + + public <C extends Collection<?>> Expression<Integer> size(C c) { + return null; + } + + public <C extends Collection<?>> Expression<Integer> size(Expression<C> cExpression) { + return null; + } + + public <E, C extends Collection<E>> Predicate isMember(E e, Expression<C> cExpression) { + return null; + } + + public <E, C extends Collection<E>> Predicate isNotMember(E e, Expression<C> cExpression) { + return null; + } + + public <E, C extends Collection<E>> Predicate isMember(Expression<E> eExpression, Expression<C> cExpression) { + return null; + } + + public <E, C extends Collection<E>> Predicate isNotMember(Expression<E> eExpression, Expression<C> cExpression) { + return null; + } + + public <V, M extends Map<?, V>> Expression<Collection<V>> values(M map) { + return null; + } + + public <K, M extends Map<K, ?>> Expression<Set<K>> keys(M m) { + return null; + } + + public Predicate like(Expression<String> stringExpression, Expression<String> stringExpression1) { + return null; + } + + public Predicate like(Expression<String> stringExpression, Expression<String> stringExpression1, Expression<Character> characterExpression) { + return null; + } + + public Predicate like(Expression<String> stringExpression, Expression<String> stringExpression1, char c) { + return null; + } + + public Predicate like(Expression<String> stringExpression, String s) { + return null; + } + + public Predicate like(Expression<String> stringExpression, String s, Expression<Character> characterExpression) { + return null; + } + + public Predicate like(Expression<String> stringExpression, String s, char c) { + return null; + } + + public Predicate notLike(Expression<String> stringExpression, Expression<String> stringExpression1) { + return null; + } + + public Predicate notLike(Expression<String> stringExpression, Expression<String> stringExpression1, Expression<Character> characterExpression) { + return null; + } + + public Predicate notLike(Expression<String> stringExpression, Expression<String> stringExpression1, char c) { + return null; + } + + public Predicate notLike(Expression<String> stringExpression, String s) { + return null; + } + + public Predicate notLike(Expression<String> stringExpression, String s, Expression<Character> characterExpression) { + return null; + } + + public Predicate notLike(Expression<String> stringExpression, String s, char c) { + return null; + } + + public Expression<String> concat(Expression<String> stringExpression, Expression<String> stringExpression1) { + return null; + } + + public Expression<String> concat(Expression<String> stringExpression, String s) { + return null; + } + + public Expression<String> concat(String s, Expression<String> stringExpression) { + return null; + } + + public Expression<String> substring(Expression<String> stringExpression, Expression<Integer> integerExpression) { + return null; + } + + public Expression<String> substring(Expression<String> stringExpression, int i) { + return null; + } + + public Expression<String> substring(Expression<String> stringExpression, Expression<Integer> integerExpression, Expression<Integer> integerExpression1) { + return null; + } + + public Expression<String> substring(Expression<String> stringExpression, int i, int i1) { + return null; + } + + public Expression<String> trim(Expression<String> stringExpression) { + return null; + } + + public Expression<String> trim(Trimspec trimspec, Expression<String> stringExpression) { + return null; + } + + public Expression<String> trim(Expression<Character> characterExpression, Expression<String> stringExpression) { + return null; + } + + public Expression<String> trim(Trimspec trimspec, Expression<Character> characterExpression, Expression<String> stringExpression) { + return null; + } + + public Expression<String> trim(char c, Expression<String> stringExpression) { + return null; + } + + public Expression<String> trim(Trimspec trimspec, char c, Expression<String> stringExpression) { + return null; + } + + public Expression<String> lower(Expression<String> stringExpression) { + return null; + } + + public Expression<String> upper(Expression<String> stringExpression) { + return null; + } + + public Expression<Integer> length(Expression<String> stringExpression) { + return null; + } + + public Expression<Integer> locate(Expression<String> stringExpression, Expression<String> stringExpression1) { + return null; + } + + public Expression<Integer> locate(Expression<String> stringExpression, Expression<String> stringExpression1, Expression<Integer> integerExpression) { + return null; + } + + public Expression<Integer> locate(Expression<String> stringExpression, String s) { + return null; + } + + public Expression<Integer> locate(Expression<String> stringExpression, String s, int i) { + return null; + } + + public Expression<java.sql.Date> currentDate() { + return null; + } + + public Expression<java.sql.Timestamp> currentTimestamp() { + return null; + } + + public Expression<java.sql.Time> currentTime() { + return null; + } + + public <Y> Expression<Y> coalesce(Expression<? extends Y> expression, Expression<? extends Y> expression1) { + return null; + } + + public <Y> Expression<Y> coalesce(Expression<? extends Y> expression, Y y) { + return null; + } + + public <Y> Expression<Y> nullif(Expression<Y> yExpression, Expression<?> expression) { + return null; + } + + public <Y> Expression<Y> nullif(Expression<Y> yExpression, Y y) { + return null; + } + + public <T> Coalesce<T> coalesce() { + return null; + } + + public <C, R> SimpleCase<C, R> selectCase(Expression<? extends C> expression) { + return null; + } + + public <R> Case<R> selectCase() { + return null; + } + + public <T> Expression<T> function(String s, Class<T> tClass, Expression<?>... expressions) { + return null; + } +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/QueryStructure.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/QueryStructure.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/QueryStructure.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,158 @@ +/* + * 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.ejb.criteria; + +import java.util.Arrays; +import java.util.Set; +import java.util.HashSet; +import java.util.List; +import java.util.Collections; +import javax.persistence.criteria.AbstractQuery; +import javax.persistence.criteria.Root; +import javax.persistence.criteria.Predicate; +import javax.persistence.criteria.Expression; +import javax.persistence.criteria.Selection; +import javax.persistence.criteria.Subquery; +import javax.persistence.metamodel.EntityType; + +/** + * Models basic query structure. Used as a delegate in implementing both + * {@link org.hibernate.criterion.CriteriaQuery} and + * {@link javax.persistence.criteria.Subquery}. + * <p/> + * Note the <tt>ORDER BY</tt> specs are neglected here. That's because it is not valid + * for a subquery to define an <tt>ORDER BY</tt> clause. So we just handle them on the + * root query directly... + * + * @author Steve Ebersole + */ +public class QueryStructure<T> { + private final AbstractQuery<T> owner; + private final QueryBuilderImpl queryBuilder; + + public QueryStructure(AbstractQuery<T> owner, QueryBuilderImpl queryBuilder) { + this.owner = owner; + this.queryBuilder = queryBuilder; + } + + private boolean distinction; + private Selection<? extends T> selection; + private Set<Root<?>> roots = new HashSet<Root<?>>(); + private Predicate restriction; + private List<Expression<?>> groupings = Collections.emptyList(); + private Predicate having; + private List<Subquery<?>> subqueries; + + + // SELECTION ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + public boolean isDistinction() { + return distinction; + } + + public void setDistinction(boolean distinction) { + this.distinction = distinction; + } + + public Selection<? extends T> getSelection() { + return selection; + } + + public void setSelection(Selection<? extends T> selection) { + this.selection = selection; + } + + + // ROOTS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + public Set<Root<?>> getRoots() { + return roots; + } + + public <X> Root<X> from(Class<X> entityClass) { + EntityType<X> entityType = queryBuilder.getEntityManagerFactory() + .getMetamodel() + .entity( entityClass ); + if ( entityType == null ) { + throw new IllegalArgumentException( entityClass + " is not an entity" ); + } + return from( entityType ); + } + + public <X> Root<X> from(EntityType<X> entityType) { + RootImpl<X> root = new RootImpl( queryBuilder, entityType ); + roots.add( root ); + return root; + } + + + // RESTRICTIONS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + public Predicate getRestriction() { + return restriction; + } + + public void setRestriction(Predicate restriction) { + this.restriction = restriction; + } + + + // GROUPINGS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + public List<Expression<?>> getGroupings() { + return groupings; + } + + public void setGroupings(List<Expression<?>> groupings) { + this.groupings = groupings; + } + + public void setGroupings(Expression<?>... groupings) { + if ( groupings != null && groupings.length > 0 ) { + this.groupings = Arrays.asList( groupings ); + } + else { + this.groupings = Collections.emptyList(); + } + } + + public Predicate getHaving() { + return having; + } + + public void setHaving(Predicate having) { + this.having = having; + } + + + // SUBQUERIES ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + public List<Subquery<?>> getSubqueries() { + return subqueries; + } + + public <U> Subquery<U> subquery(Class<U> subqueryType) { + CriteriaSubqueryImpl<U> subquery = new CriteriaSubqueryImpl<U>( queryBuilder, subqueryType, owner ); + subqueries.add( subquery ); + return subquery; + } +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/RootImpl.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/RootImpl.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/RootImpl.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,44 @@ +/* + * 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.ejb.criteria; + +import javax.persistence.criteria.Root; +import javax.persistence.metamodel.EntityType; + +/** + * Defines a <tt>query root</tt>. + * + * @author Steve Ebersole + */ +public class RootImpl<X> extends FromImpl<X,X> implements Root<X> { + public RootImpl( + QueryBuilderImpl queryBuilder, + EntityType<X> model) { + super( queryBuilder, model ); + } + + @Override + public EntityType<X> getModel(){ + return ( EntityType<X> ) super.getModel(); + } + +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/AbstractExpression.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/AbstractExpression.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/AbstractExpression.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,89 @@ +/* + * 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.ejb.criteria.expression; + +import java.util.Collection; +import javax.persistence.criteria.Expression; +import javax.persistence.criteria.Predicate; + +import org.hibernate.ejb.criteria.QueryBuilderImpl; + +/** + * TODO : javadoc + * + * @author Steve Ebersole + */ +public class AbstractExpression<T> extends SelectionImpl<T> implements Expression<T> { + protected AbstractExpression(QueryBuilderImpl queryBuilder, Class<T> javaType) { + super( queryBuilder, javaType ); + } + + /** + * {@inheritDoc} + */ + public <X> Expression<X> as(Class<X> type) { + // TODO-STEVE : implement - needs a cast expression + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + /** + * {@inheritDoc} + */ + public Predicate isNull() { + return queryBuilder().isNull( this ); + } + + /** + * {@inheritDoc} + */ + public Predicate isNotNull() { + return queryBuilder().isNotNull( this ); + } + + /** + * {@inheritDoc} + */ + public Predicate in(Object... values) { + return queryBuilder().in( this, values ); + } + + /** + * {@inheritDoc} + */ + public Predicate in(Expression<?>... values) { + return queryBuilder().in( this, values ); + } + + /** + * {@inheritDoc} + */ + public Predicate in(Collection<?> values) { + return queryBuilder().in( this, values ); + } + + /** + * {@inheritDoc} + */ + public Predicate in(Expression<Collection<?>> values) { + return queryBuilder().in( this, values ); + } +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/AbstractTupleElement.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/AbstractTupleElement.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/AbstractTupleElement.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,65 @@ +/* + * 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.ejb.criteria.expression; + +import javax.persistence.TupleElement; + +import org.hibernate.ejb.criteria.AbstractNode; +import org.hibernate.ejb.criteria.QueryBuilderImpl; + +/** + * TODO : javadoc + * + * @author Steve Ebersole + */ +public abstract class AbstractTupleElement<X> extends AbstractNode implements TupleElement<X> { + private final Class<X> javaType; + private String alias; + + protected AbstractTupleElement(QueryBuilderImpl queryBuilder, Class<X> javaType) { + super( queryBuilder ); + this.javaType = javaType; + } + + /** + * {@inheritDoc} + */ + public Class<X> getJavaType() { + return javaType; + } + + /** + * {@inheritDoc} + */ + public String getAlias() { + return alias; + } + + /** + * Protected access to define the alias. + * + * @param alias The alias to use. + */ + protected void setAlias(String alias) { + this.alias = alias; + } +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/CompoundSelectionImpl.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/CompoundSelectionImpl.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/CompoundSelectionImpl.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,56 @@ +/* + * 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.ejb.criteria.expression; + +import java.util.List; +import javax.persistence.criteria.CompoundSelection; +import javax.persistence.criteria.Selection; + +import org.hibernate.ejb.criteria.QueryBuilderImpl; + +/** + * The Hibernate implementation of the JPA {@link CompoundSelection} + * contract. + * + * @author Steve Ebersole + */ +public class CompoundSelectionImpl<X> extends SelectionImpl<X> implements CompoundSelection<X> { + private List<Selection<?>> selectionItems; + + public CompoundSelectionImpl( + QueryBuilderImpl queryBuilder, + Class<X> javaType, + List<Selection<?>> selectionItems) { + super( queryBuilder, javaType ); + this.selectionItems = selectionItems; + } + + @Override + public boolean isCompoundSelection() { + return true; + } + + @Override + public List<Selection<?>> getCompoundSelectionItems() { + return selectionItems; + } +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/EntityTypeExpression.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/EntityTypeExpression.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/EntityTypeExpression.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,35 @@ +/* + * 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.ejb.criteria.expression; + +import org.hibernate.ejb.criteria.QueryBuilderImpl; + +/** + * TODO : javadoc + * + * @author Steve Ebersole + */ +public class EntityTypeExpression<T> extends AbstractExpression<T> { + public EntityTypeExpression(QueryBuilderImpl queryBuilder, Class<T> javaType) { + super( queryBuilder, javaType ); + } +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/FunctionExpressionImpl.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/FunctionExpressionImpl.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/FunctionExpressionImpl.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,66 @@ +/* + * 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.ejb.criteria.expression; + +import java.util.List; +import java.util.Arrays; +import javax.persistence.criteria.Expression; + +import org.hibernate.ejb.criteria.QueryBuilderImpl; + +/** + * TODO : javadoc + * + * @author Steve Ebersole + */ +public class FunctionExpressionImpl<X> extends AbstractExpression<X> implements Expression<X> { + private final String functionName; + private final List<Expression<?>> argumentExpressions; + + public FunctionExpressionImpl( + QueryBuilderImpl queryBuilder, + Class<X> javaType, + String functionName, + List<Expression<?>> argumentExpressions) { + super( queryBuilder, javaType ); + this.functionName = functionName; + this.argumentExpressions = argumentExpressions; + } + + public FunctionExpressionImpl( + QueryBuilderImpl queryBuilder, + Class<X> javaType, + String functionName, + Expression<?>... argumentExpressions) { + super( queryBuilder, javaType ); + this.functionName = functionName; + this.argumentExpressions = Arrays.asList( argumentExpressions ); + } + + public String getFunctionName() { + return functionName; + } + + public List<Expression<?>> getArgumentExpressions() { + return argumentExpressions; + } +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/LiteralExpression.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/LiteralExpression.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/LiteralExpression.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,45 @@ +/* + * 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.ejb.criteria.expression; + +import org.hibernate.ejb.criteria.QueryBuilderImpl; + +/** + * TODO : javadoc + * + * @author Steve Ebersole + */ +public class LiteralExpression<T> extends AbstractExpression<T> { + private final T literal; + + public LiteralExpression( + QueryBuilderImpl queryBuilder, + T literal) { + //noinspection unchecked + super( queryBuilder, ( Class<T> ) literal.getClass() ); + this.literal = literal; + } + + public T getLiteral() { + return literal; + } +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/ParameterExpressionImpl.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/ParameterExpressionImpl.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/ParameterExpressionImpl.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,63 @@ +/* + * 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.ejb.criteria.expression; + +import javax.persistence.criteria.ParameterExpression; + +import org.hibernate.ejb.criteria.QueryBuilderImpl; + +/** + * Defines a parameter specification, or the information about a parameter (where it occurs, what is + * its type, etc). + * + * @author Steve Ebersole + */ +public class ParameterExpressionImpl<T> extends AbstractExpression<T> implements ParameterExpression<T> { + private final String name; + private final Integer position; + + public ParameterExpressionImpl( + QueryBuilderImpl queryBuilder, + Class<T> javaType, + String name) { + super( queryBuilder, javaType ); + this.name = name; + this.position = null; + } + + public ParameterExpressionImpl( + QueryBuilderImpl queryBuilder, + Class<T> javaType, + Integer position) { + super( queryBuilder, javaType ); + this.name = null; + this.position = position; + } + + public String getName() { + return name; + } + + public Integer getPosition() { + return position; + } +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/SelectionImpl.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/SelectionImpl.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/expression/SelectionImpl.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,52 @@ +/* + * 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.ejb.criteria.expression; + +import java.util.List; +import javax.persistence.criteria.Selection; + +import org.hibernate.ejb.criteria.QueryBuilderImpl; + +/** + * The Hibernate implementation of the JPA {@link Selection} + * contract. + * + * @author Steve Ebersole + */ +public class SelectionImpl<X> extends AbstractTupleElement<X> implements Selection<X> { + public SelectionImpl(QueryBuilderImpl queryBuilder, Class<X> javaType) { + super( queryBuilder, javaType ); + } + + public Selection<X> alias(String alias) { + setAlias( alias ); + return this; + } + + public boolean isCompoundSelection() { + return false; + } + + public List<Selection<?>> getCompoundSelectionItems() { + throw new IllegalStateException( "Not a compund selection" ); + } +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/AbstractPredicateImpl.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/AbstractPredicateImpl.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/AbstractPredicateImpl.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,66 @@ +/* + * 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.ejb.criteria.predicate; + +import java.util.List; +import javax.persistence.criteria.Predicate; +import javax.persistence.criteria.Selection; + +import org.hibernate.ejb.criteria.expression.AbstractExpression; +import org.hibernate.ejb.criteria.QueryBuilderImpl; + +/** + * Basic template support for {@link Predicate} implementors providing + * expression handling, negation and conjunction/disjunction handling. + * + * @author Steve Ebersole + */ +public abstract class AbstractPredicateImpl extends AbstractExpression<Boolean> implements Predicate { + private boolean negated; + + protected AbstractPredicateImpl(QueryBuilderImpl queryBuilder) { + super( queryBuilder, Boolean.class ); + } + + public boolean isNegated() { + return negated; + } + + public Predicate negate() { + negated = !negated; + return this; + } + + + // Selection ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + public final boolean isCompoundSelection() { + // Should always be false for predicates + return super.isCompoundSelection(); + } + + public final List<Selection<?>> getCompoundSelectionItems() { + // Should never have sub selection items for predicates + return super.getCompoundSelectionItems(); + } + +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/AbstractSimplePredicate.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/AbstractSimplePredicate.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/AbstractSimplePredicate.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,50 @@ +/* + * 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.ejb.criteria.predicate; + +import java.util.List; +import java.util.Collections; +import javax.persistence.criteria.Expression; + +import org.hibernate.ejb.criteria.QueryBuilderImpl; + +/** + * TODO : javadoc + * + * @author Steve Ebersole + */ +public class AbstractSimplePredicate extends AbstractPredicateImpl { + private static final List<Expression<Boolean>> NO_EXPRESSIONS = Collections.emptyList(); + + public AbstractSimplePredicate(QueryBuilderImpl queryBuilder) { + super( queryBuilder ); + } + + public BooleanOperator getOperator() { + return BooleanOperator.AND; + } + + public List<Expression<Boolean>> getExpressions() { + return NO_EXPRESSIONS; + } + +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/BetweenPredicate.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/BetweenPredicate.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/BetweenPredicate.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,73 @@ +/* + * 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.ejb.criteria.predicate; + +import javax.persistence.criteria.Expression; + +import org.hibernate.ejb.criteria.QueryBuilderImpl; + +/** + * Models a <tt>BETWEEN</tt> {@link javax.persistence.criteria.Predicate}. + * + * @author Steve Ebersole + */ +public class BetweenPredicate<Y> extends AbstractSimplePredicate { + private final Expression<? extends Y> expression; + private final Expression<? extends Y> lowerBound; + private final Expression<? extends Y> upperBound; + + public BetweenPredicate( + QueryBuilderImpl queryBuilder, + Expression<? extends Y> expression, + Y lowerBound, + Y upperBound) { + this( + queryBuilder, + expression, + queryBuilder.literal( lowerBound ), + queryBuilder.literal( upperBound ) + ); + } + + public BetweenPredicate( + QueryBuilderImpl queryBuilder, + Expression<? extends Y> expression, + Expression<? extends Y> lowerBound, + Expression<? extends Y> upperBound) { + super( queryBuilder ); + this.expression = expression; + this.lowerBound = lowerBound; + this.upperBound = upperBound; + } + + public Expression<? extends Y> getExpression() { + return expression; + } + + public Expression<? extends Y> getLowerBound() { + return lowerBound; + } + + public Expression<? extends Y> getUpperBound() { + return upperBound; + } +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/BooleanExpressionPredicate.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/BooleanExpressionPredicate.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/BooleanExpressionPredicate.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,50 @@ +/* + * 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.ejb.criteria.predicate; + +import javax.persistence.criteria.Expression; +import javax.persistence.criteria.Predicate; + +import org.hibernate.ejb.criteria.QueryBuilderImpl; + +/** + * Defines a {@link Predicate} used to wrap an {@link Expression Expression&lt;Boolean&gt;}. + * + * @author Steve Ebersole + */ +public class BooleanExpressionPredicate extends AbstractSimplePredicate { + private final Expression<Boolean> expression; + + public BooleanExpressionPredicate(QueryBuilderImpl queryBuilder, Expression<Boolean> expression) { + super( queryBuilder ); + this.expression = expression; + } + + /** + * Get the boolean expression defining the predicate. + * + * @return The underlying boolean expression. + */ + public Expression<Boolean> getExpression() { + return expression; + } +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/ComparisonPredicate.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/ComparisonPredicate.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/ComparisonPredicate.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,112 @@ +/* + * 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.ejb.criteria.predicate; + +import javax.persistence.criteria.Expression; + +import org.hibernate.ejb.criteria.QueryBuilderImpl; + +/** + * TODO : javadoc + * + * @author Steve Ebersole + */ +public class ComparisonPredicate extends AbstractSimplePredicate { + private final ComparisonOperator comparisonOperator; + private final Expression<?> leftHandSide; + private final Expression<?> rightHandSide; + + public ComparisonPredicate( + QueryBuilderImpl queryBuilder, + ComparisonOperator comparisonOperator, + Expression<?> leftHandSide, + Expression<?> rightHandSide) { + super( queryBuilder ); + this.comparisonOperator = comparisonOperator; + this.leftHandSide = leftHandSide; + this.rightHandSide = rightHandSide; + } + + public ComparisonPredicate( + QueryBuilderImpl queryBuilder, + ComparisonOperator comparisonOperator, + Expression<?> leftHandSide, + Object rightHandSide) { + super( queryBuilder ); + this.comparisonOperator = comparisonOperator; + this.leftHandSide = leftHandSide; + // TODO : generate a parameter expression once those are ready... + this.rightHandSide = null; + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + public ComparisonOperator getComparisonOperator() { + return comparisonOperator; + } + + public Expression<?> getLeftHandSide() { + return leftHandSide; + } + + public Expression<?> getRightHandSide() { + return rightHandSide; + } + + /** + * Defines the comparison operators. We could also get away with + * only 3 and use negation... + */ + public static enum ComparisonOperator { + EQUAL { + public ComparisonOperator negated() { + return NOT_EQUAL; + } + }, + NOT_EQUAL { + public ComparisonOperator negated() { + return EQUAL; + } + }, + LESS_THAN { + public ComparisonOperator negated() { + return GREATER_THAN_OR_EQUAL; + } + }, + LESS_THAN_OR_EQUAL { + public ComparisonOperator negated() { + return GREATER_THAN; + } + }, + GREATER_THAN { + public ComparisonOperator negated() { + return LESS_THAN_OR_EQUAL; + } + }, + GREATER_THAN_OR_EQUAL { + public ComparisonOperator negated() { + return LESS_THAN; + } + }; + + public abstract ComparisonOperator negated(); + } +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/CompoundPredicate.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/CompoundPredicate.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/CompoundPredicate.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,102 @@ +/* + * 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.ejb.criteria.predicate; + +import java.util.List; +import java.util.ArrayList; +import java.util.Arrays; +import javax.persistence.criteria.Predicate; +import javax.persistence.criteria.Expression; + +import org.hibernate.ejb.criteria.QueryBuilderImpl; + +/** + * A compound {@link Predicate predicate} is a grouping of other {@link Predicate predicates} in order to apply + * either a conjunction (logical AND) or a disjunction (logical OR). + * + * @author Steve Ebersole + */ +public class CompoundPredicate extends AbstractPredicateImpl { + private final BooleanOperator operator; + private final List<Expression<Boolean>> expressions = new ArrayList<Expression<Boolean>>(); + + /** + * Constructs an empty conjunction or disjunction. + * + * @param queryBuilder The query builder from whcih this originates. + * @param operator Indicates whether this predicate will funtion + * as a conjunction or disjuntion. + */ + public CompoundPredicate(QueryBuilderImpl queryBuilder, BooleanOperator operator) { + super( queryBuilder ); + this.operator = operator; + } + + /** + * Constructs a conjunction or disjunction over the given expressions. + * + * @param queryBuilder The query builder from which this originates. + * @param operator Indicates whether this predicate will funtion + * as a conjunction or disjuntion. + * @param expressions The expressions to be grouped. + */ + public CompoundPredicate( + QueryBuilderImpl queryBuilder, + BooleanOperator operator, + Expression<Boolean>... expressions) { + this( queryBuilder, operator ); + applyExpressions( expressions ); + } + + /** + * Constructs a conjunction or disjunction over the given expressions. + * + * @param queryBuilder The query builder from whcih this originates. + * @param operator Indicates whether this predicate will funtion + * as a conjunction or disjuntion. + * @param expressions The expressions to be grouped. + */ + public CompoundPredicate( + QueryBuilderImpl queryBuilder, + BooleanOperator operator, + List<Expression<Boolean>> expressions) { + this( queryBuilder, operator ); + applyExpressions( expressions ); + } + + private void applyExpressions(Expression<Boolean>... expressions) { + applyExpressions( Arrays.asList( expressions ) ); + } + + private void applyExpressions(List<Expression<Boolean>> expressions) { + this.expressions.clear(); + this.expressions.addAll( expressions ); + } + + public BooleanOperator getOperator() { + return operator; + } + + public List<Expression<Boolean>> getExpressions() { + return expressions; + } +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/ExplicitTruthValueCheck.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/ExplicitTruthValueCheck.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/ExplicitTruthValueCheck.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,57 @@ +/* + * 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.ejb.criteria.predicate; + +import javax.persistence.criteria.Expression; + +import org.hibernate.ejb.criteria.QueryBuilderImpl; + +/** + * ANSI-SQL defines <tt>TRUE</tt>, <tt>FALSE</tt> and <tt>UNKNOWN</tt> as <i>truth values</i>. These + * <i>truth values</i> are used to explicitly check the result of a boolean expression (the syntax is like + * <tt>a > b IS TRUE</tt>. <tt>IS TRUE</tt> is the assumed default. + * <p/> + * JPA defines support for only <tt>IS TRUE</tt> and <tt>IS FALSE</tt>, not <tt>IS UNKNOWN</tt> (<tt>a > NULL</tt> + * is an example where the result would be UNKNOWN. + * + * @author Steve Ebersole + */ +public class ExplicitTruthValueCheck extends AbstractSimplePredicate { + // TODO : given that JPA supports only TRUE and FALSE, can this be handled just with negation? + private final Expression<Boolean> booleanExpression; + private final TruthValue truthValue; + + public ExplicitTruthValueCheck(QueryBuilderImpl queryBuilder, Expression<Boolean> booleanExpression, TruthValue truthValue) { + super( queryBuilder ); + this.booleanExpression = booleanExpression; + this.truthValue = truthValue; + } + + public Expression<Boolean> getBooleanExpression() { + return booleanExpression; + } + + public TruthValue getTruthValue() { + return truthValue; + } +} + Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/InPredicate.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/InPredicate.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/InPredicate.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,137 @@ +/* + * 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.ejb.criteria.predicate; + +import java.util.List; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import javax.persistence.criteria.Expression; + +import org.hibernate.ejb.criteria.QueryBuilderImpl; + +/** + * TODO : javadoc + * + * @author Steve Ebersole + */ +public class InPredicate<T> extends AbstractSimplePredicate implements QueryBuilderImpl.In<T> { + private final Expression<? extends T> expression; + private final List<Expression<? extends T>> values; + + /** + * Constructs an <tt>IN</tt> predicate against a given expression with an empty list of values. + * + * @param queryBuilder The query builder from which this originates. + * @param expression The expression. + */ + public InPredicate( + QueryBuilderImpl queryBuilder, + Expression<? extends T> expression) { + this( queryBuilder, expression, new ArrayList<Expression<? extends T>>() ); + } + + /** + * Constructs an <tt>IN</tt> predicate against a given expression with the given list of expression values. + * + * @param queryBuilder The query builder from which this originates. + * @param expression The expression. + * @param values The value list. + */ + public InPredicate( + QueryBuilderImpl queryBuilder, + Expression<? extends T> expression, + Expression<? extends T>... values) { + this( queryBuilder, expression, Arrays.asList( values ) ); + } + + /** + * Constructs an <tt>IN</tt> predicate against a given expression with the given list of expression values. + * + * @param queryBuilder The query builder from which this originates. + * @param expression The expression. + * @param values The value list. + */ + public InPredicate( + QueryBuilderImpl queryBuilder, + Expression<? extends T> expression, + List<Expression<? extends T>> values) { + super( queryBuilder ); + this.expression = expression; + this.values = values; + } + + /** + * Constructs an <tt>IN</tt> predicate against a given expression with the given given literal value list. + * + * @param queryBuilder The query builder from which this originates. + * @param expression The expression. + * @param values The value list. + */ + public InPredicate( + QueryBuilderImpl queryBuilder, + Expression<? extends T> expression, + T... values) { + super( queryBuilder ); + // TODO : implements - needs parameter expressions + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + /** + * Constructs an <tt>IN</tt> predicate against a given expression with the given literal value list. + * + * @param queryBuilder The query builder from which this originates. + * @param expression The expression. + * @param values The value list. + */ + public InPredicate( + QueryBuilderImpl queryBuilder, + Expression<? extends T> expression, + Collection<T> values) { + super( queryBuilder ); + // TODO : implements - needs parameter expressions + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + public Expression<T> getExpression() { + //noinspection unchecked + return ( Expression<T> ) expression; + } + + public Expression<? extends T> getExpressionInternal() { + return expression; + } + + public List<Expression<? extends T>> getValues() { + return values; + } + + public InPredicate<T> value(T value) { + // TODO : implements - needs parameter expressions + throw new UnsupportedOperationException( "Not yet implemented!" ); + } + + public InPredicate<T> value(Expression<? extends T> value) { + values.add( value ); + return this; + } +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/NullnessPredicate.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/NullnessPredicate.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/NullnessPredicate.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,56 @@ +/* + * 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.ejb.criteria.predicate; + +import javax.persistence.criteria.Expression; + +import org.hibernate.ejb.criteria.QueryBuilderImpl; + +/** + * Defines a {@link javax.persistence.criteria.Predicate} for checking the + * nullness state of an expression, aka an <tt>IS (NOT?) NULL</tt> predicate. + * <p/> + * The <tt>NOT NULL</tt> form can be built by calling the constructor and then + * calling {@link #negate}. + * + * @author Steve Ebersole + */ +public class NullnessPredicate extends AbstractSimplePredicate{ + private final Expression<?> nullnessCheckExpression; + + /** + * Constructs the affirmitive form of nullness checking (<i>IS NULL</i>). To + * construct the negative form (<i>IS NOT NULL</i>) call {@link #negate} on the + * constructed instance. + * + * @param queryBuilder The query builder from whcih this originates. + * @param expression The expression to check. + */ + public NullnessPredicate(QueryBuilderImpl queryBuilder, Expression<?> expression) { + super( queryBuilder ); + this.nullnessCheckExpression = expression; + } + + public Expression<?> getNullnessCheckExpression() { + return nullnessCheckExpression; + } +} Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/TruthValue.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/TruthValue.java (rev 0) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/criteria/predicate/TruthValue.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,38 @@ +/* + * 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.ejb.criteria.predicate; + +/** + * Models what ANSI-SQL terms a <i>truth value</i>. Specifically, ANSI-SQL defines <tt>TRUE</tt>, <tt>FALSE</tt> and + * <tt>UNKNOWN</tt> as <i>truth values</i>. These <i>truth values</i> are used to explicitly check the result of a + * boolean expression (the syntax is like <tt>a > b IS TRUE</tt>. <tt>IS TRUE</tt> is the assumed default. + * <p/> + * JPA defines support for only <tt>IS TRUE</tt> and <tt>IS FALSE</tt>, not <tt>IS UNKNOWN</tt> (<tt>a > NULL</tt> + * is an example where the result would be UNKNOWN). All 3 are provided here for completness. + * + * @author Steve Ebersole + */ +public enum TruthValue { + TRUE, + FALSE, + UNKNOWN +} Added: core/trunk/entitymanager/src/test/java/org/hibernate/ejb/criteria/basic/BasicCriteriaUsageTest.java =================================================================== --- core/trunk/entitymanager/src/test/java/org/hibernate/ejb/criteria/basic/BasicCriteriaUsageTest.java (rev 0) +++ core/trunk/entitymanager/src/test/java/org/hibernate/ejb/criteria/basic/BasicCriteriaUsageTest.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,48 @@ +/* + * 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.ejb.criteria.basic; + +import javax.persistence.EntityManager; +import javax.persistence.criteria.CriteriaQuery; + +import org.hibernate.ejb.test.TestCase; + +/** + * TODO : javadoc + * + * @author Steve Ebersole + */ +public class BasicCriteriaUsageTest extends TestCase { + + public Class[] getAnnotatedClasses() { + return new Class[] { Wall.class }; + } + + public void testSimpliestCriterias() { + EntityManager em = getOrCreateEntityManager(); + em.getTransaction().begin(); + CriteriaQuery criteria = em.getQueryBuilder().createQuery(); + criteria.from( Wall.class ); + em.getTransaction().commit(); + em.close(); + } +} Added: core/trunk/entitymanager/src/test/java/org/hibernate/ejb/criteria/basic/Wall.java =================================================================== --- core/trunk/entitymanager/src/test/java/org/hibernate/ejb/criteria/basic/Wall.java (rev 0) +++ core/trunk/entitymanager/src/test/java/org/hibernate/ejb/criteria/basic/Wall.java 2009-07-31 17:53:18 UTC (rev 17222) @@ -0,0 +1,99 @@ +/* + * 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.ejb.criteria.basic; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.GeneratedValue; +import javax.persistence.ManyToOne; +import javax.persistence.JoinColumn; +import javax.persistence.Table; + +/** + * TODO : javadoc + * + * @author Steve Ebersole + */ +@Entity +@Table( name = "crit_basic_wall" ) +public class Wall { + private Long id; + private long width; + private long height; + private String color; + private Wall left; + private Wall right; + + @Id + @GeneratedValue + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public long getWidth() { + return width; + } + + public void setWidth(long width) { + this.width = width; + } + + public long getHeight() { + return height; + } + + public void setHeight(long height) { + this.height = height; + } + + public String getColor() { + return color; + } + + public void setColor(String color) { + this.color = color; + } + + @ManyToOne + @JoinColumn(name = "left_id") + public Wall getLeft() { + return left; + } + + public void setLeft(Wall left) { + this.left = left; + } + + @ManyToOne + @JoinColumn(name = "right_id") + public Wall getRight() { + return right; + } + + public void setRight(Wall right) { + this.right = right; + } +}