From 346d958c20d9727a32ebfa8253a128d13bc1136f Mon Sep 17 00:00:00 2001 From: Steve Ebersole Date: Wed, 18 Sep 2013 14:17:59 -0500 Subject: [PATCH] HHH-8518 - Validate EMF#addNamedQuery transfers all query settings --- .../engine/spi/SessionDelegatorBaseImpl.java | 10 + .../engine/spi/SessionImplementor.java | 19 ++ .../internal/AbstractSessionImpl.java | 50 ++-- .../jpa/spi/AbstractEntityManagerImpl.java | 239 ++++++++++++------ .../hibernate/jpa/spi/AbstractQueryImpl.java | 11 +- .../jpa/test/query/AddNamedQueryTest.java | 66 ++++- 6 files changed, 296 insertions(+), 99 deletions(-) diff --git a/hibernate-core/src/main/java/org/hibernate/engine/spi/SessionDelegatorBaseImpl.java b/hibernate-core/src/main/java/org/hibernate/engine/spi/SessionDelegatorBaseImpl.java index d9c1908465..54801c58fc 100644 --- a/hibernate-core/src/main/java/org/hibernate/engine/spi/SessionDelegatorBaseImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/engine/spi/SessionDelegatorBaseImpl.java @@ -378,6 +378,16 @@ public class SessionDelegatorBaseImpl implements SessionImplementor, Session { return sessionImplementor.getLoadQueryInfluencers(); } + @Override + public Query createQuery(NamedQueryDefinition namedQueryDefinition) { + return sessionImplementor.createQuery( namedQueryDefinition ); + } + + @Override + public SQLQuery createSQLQuery(NamedSQLQueryDefinition namedQueryDefinition) { + return sessionImplementor.createSQLQuery( namedQueryDefinition ); + } + // Delegates to Session @Override diff --git a/hibernate-core/src/main/java/org/hibernate/engine/spi/SessionImplementor.java b/hibernate-core/src/main/java/org/hibernate/engine/spi/SessionImplementor.java index 498a838f37..15cb520d31 100644 --- a/hibernate-core/src/main/java/org/hibernate/engine/spi/SessionImplementor.java +++ b/hibernate-core/src/main/java/org/hibernate/engine/spi/SessionImplementor.java @@ -35,6 +35,7 @@ import org.hibernate.FlushMode; import org.hibernate.HibernateException; import org.hibernate.Interceptor; import org.hibernate.Query; +import org.hibernate.SQLQuery; import org.hibernate.ScrollMode; import org.hibernate.ScrollableResults; import org.hibernate.cache.spi.CacheKey; @@ -389,4 +390,22 @@ public interface SessionImplementor extends Serializable, LobCreationContext { * should never be null. */ public LoadQueryInfluencers getLoadQueryInfluencers(); + + /** + * Used from EntityManager + * + * @param namedQueryDefinition The named query definition + * + * @return The basic HQL/JPQL query (without saved settings applied) + */ + Query createQuery(NamedQueryDefinition namedQueryDefinition); + + /** + * Used from EntityManager + * + * @param namedQueryDefinition The named query definition + * + * @return The basic SQL query (without saved settings applied) + */ + SQLQuery createSQLQuery(NamedSQLQueryDefinition namedQueryDefinition); } diff --git a/hibernate-core/src/main/java/org/hibernate/internal/AbstractSessionImpl.java b/hibernate-core/src/main/java/org/hibernate/internal/AbstractSessionImpl.java index 8ba88d7655..4252a21824 100755 --- a/hibernate-core/src/main/java/org/hibernate/internal/AbstractSessionImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/internal/AbstractSessionImpl.java @@ -133,36 +133,50 @@ public abstract class AbstractSessionImpl } } + @Override + public Query createQuery(NamedQueryDefinition namedQueryDefinition) { + String queryString = namedQueryDefinition.getQueryString(); + final Query query = new QueryImpl( + queryString, + namedQueryDefinition.getFlushMode(), + this, + getHQLQueryPlan( queryString, false ).getParameterMetadata() + ); + query.setComment( "named HQL query " + namedQueryDefinition.getName() ); + if ( namedQueryDefinition.getLockOptions() != null ) { + query.setLockOptions( namedQueryDefinition.getLockOptions() ); + } + + return query; + } + + @Override + public SQLQuery createSQLQuery(NamedSQLQueryDefinition namedQueryDefinition) { + final ParameterMetadata parameterMetadata = factory.getQueryPlanCache().getSQLParameterMetadata( namedQueryDefinition.getQueryString() ); + final SQLQuery query = new SQLQueryImpl( + namedQueryDefinition, + this, + parameterMetadata + ); + query.setComment( "named native SQL query " + namedQueryDefinition.getName() ); + return query; + } + @Override public Query getNamedQuery(String queryName) throws MappingException { errorIfClosed(); NamedQueryDefinition nqd = factory.getNamedQuery( queryName ); final Query query; if ( nqd != null ) { - String queryString = nqd.getQueryString(); - query = new QueryImpl( - queryString, - nqd.getFlushMode(), - this, - getHQLQueryPlan( queryString, false ).getParameterMetadata() - ); - query.setComment( "named HQL query " + queryName ); - if ( nqd.getLockOptions() != null ) { - query.setLockOptions( nqd.getLockOptions() ); - } + query = createQuery( nqd ); } else { NamedSQLQueryDefinition nsqlqd = factory.getNamedSQLQuery( queryName ); if ( nsqlqd==null ) { throw new MappingException( "Named query not known: " + queryName ); } - ParameterMetadata parameterMetadata = factory.getQueryPlanCache().getSQLParameterMetadata( nsqlqd.getQueryString() ); - query = new SQLQueryImpl( - nsqlqd, - this, - parameterMetadata - ); - query.setComment( "named native SQL query " + queryName ); + + query = createSQLQuery( nsqlqd ); nqd = nsqlqd; } initQuery( query, nqd ); diff --git a/hibernate-entitymanager/src/main/java/org/hibernate/jpa/spi/AbstractEntityManagerImpl.java b/hibernate-entitymanager/src/main/java/org/hibernate/jpa/spi/AbstractEntityManagerImpl.java index c9c1ca4acf..8f2837071f 100755 --- a/hibernate-entitymanager/src/main/java/org/hibernate/jpa/spi/AbstractEntityManagerImpl.java +++ b/hibernate-entitymanager/src/main/java/org/hibernate/jpa/spi/AbstractEntityManagerImpl.java @@ -86,14 +86,18 @@ import org.hibernate.StaleStateException; import org.hibernate.TransientObjectException; import org.hibernate.TypeMismatchException; import org.hibernate.UnresolvableObjectException; +import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; +import org.hibernate.boot.registry.classloading.spi.ClassLoadingException; import org.hibernate.cfg.Environment; import org.hibernate.dialect.lock.LockingStrategyException; import org.hibernate.dialect.lock.OptimisticEntityLockException; import org.hibernate.dialect.lock.PessimisticEntityLockException; import org.hibernate.engine.ResultSetMappingDefinition; import org.hibernate.engine.query.spi.HQLQueryPlan; +import org.hibernate.engine.query.spi.sql.NativeSQLQueryConstructorReturn; import org.hibernate.engine.query.spi.sql.NativeSQLQueryReturn; import org.hibernate.engine.query.spi.sql.NativeSQLQueryRootReturn; +import org.hibernate.engine.spi.NamedQueryDefinition; import org.hibernate.engine.spi.NamedSQLQueryDefinition; import org.hibernate.engine.spi.SessionFactoryImplementor; import org.hibernate.engine.spi.SessionImplementor; @@ -763,93 +767,178 @@ public abstract class AbstractEntityManagerImpl implements HibernateEntityManage @Override public Query createNamedQuery(String name) { + return buildQueryFromName( name, null ); + } + + private QueryImpl buildQueryFromName(String name, Class resultType) { checkOpen(); - try { - org.hibernate.Query namedQuery = internalGetSession().getNamedQuery( name ); - try { - return new QueryImpl( namedQuery, this ); - } - catch ( RuntimeException e ) { - throw convert( e ); + + // we can't just call Session#getNamedQuery because we need to apply stored setting at the JPA Query + // level too + + final SessionFactoryImplementor sfi = entityManagerFactory.getSessionFactory(); + + // first try as hql/jpql query + { + final NamedQueryDefinition namedQueryDefinition = sfi.getNamedQueryRepository().getNamedQueryDefinition( name ); + if ( namedQueryDefinition != null ) { + return createNamedJpqlQuery( namedQueryDefinition, resultType ); } } - catch ( MappingException e ) { - throw convert(new IllegalArgumentException( "Named query not found: " + name )); + + // then as a native (SQL) query + { + final NamedSQLQueryDefinition namedQueryDefinition = sfi.getNamedQueryRepository().getNamedSQLQueryDefinition( name ); + if ( namedQueryDefinition != null ) { + return createNamedSqlQuery( namedQueryDefinition, resultType ); + } + } + + throw convert( new IllegalArgumentException( "No query defined for that name [" + name + "]" ) ); + } + + protected QueryImpl createNamedJpqlQuery(NamedQueryDefinition namedQueryDefinition, Class resultType) { + final org.hibernate.Query hibQuery = ( (SessionImplementor) internalGetSession() ).createQuery( namedQueryDefinition ); + if ( resultType != null ) { + resultClassChecking( resultType, hibQuery ); + } + + return wrapAsJpaQuery( namedQueryDefinition, hibQuery ); + } + + protected QueryImpl wrapAsJpaQuery(NamedQueryDefinition namedQueryDefinition, org.hibernate.Query hibQuery) { + try { + final QueryImpl jpaQuery = new QueryImpl( hibQuery, this ); + applySavedSettings( namedQueryDefinition, jpaQuery ); + return jpaQuery; + } + catch ( RuntimeException e ) { + throw convert( e ); + } + } + + protected void applySavedSettings(NamedQueryDefinition namedQueryDefinition, QueryImpl jpaQuery) { + if ( namedQueryDefinition.isCacheable() ) { + jpaQuery.setHint( QueryHints.HINT_CACHEABLE, true ); + if ( namedQueryDefinition.getCacheRegion() != null ) { + jpaQuery.setHint( QueryHints.HINT_CACHE_REGION, namedQueryDefinition.getCacheRegion() ); + } + } + + if ( namedQueryDefinition.getCacheMode() != null ) { + jpaQuery.setHint( QueryHints.HINT_CACHE_MODE, namedQueryDefinition.getCacheMode() ); + } + + if ( namedQueryDefinition.isReadOnly() ) { + jpaQuery.setHint( QueryHints.HINT_READONLY, true ); + } + + if ( namedQueryDefinition.getTimeout() != null ) { + jpaQuery.setHint( QueryHints.SPEC_HINT_TIMEOUT, namedQueryDefinition.getTimeout() * 1000 ); + } + + if ( namedQueryDefinition.getFetchSize() != null ) { + jpaQuery.setHint( QueryHints.HINT_FETCH_SIZE, namedQueryDefinition.getFetchSize() ); + } + + if ( namedQueryDefinition.getComment() != null ) { + jpaQuery.setHint( QueryHints.HINT_COMMENT, namedQueryDefinition.getComment() ); + } + + if ( namedQueryDefinition.getFirstResult() != null ) { + jpaQuery.setFirstResult( namedQueryDefinition.getFirstResult() ); + } + + if ( namedQueryDefinition.getMaxResults() != null ) { + jpaQuery.setMaxResults( namedQueryDefinition.getMaxResults() ); + } + + if ( namedQueryDefinition.getLockOptions() != null ) { + if ( namedQueryDefinition.getLockOptions().getLockMode() != null ) { + jpaQuery.setLockMode( + LockModeTypeHelper.getLockModeType( namedQueryDefinition.getLockOptions().getLockMode() ) + ); + } + } + + if ( namedQueryDefinition.getFlushMode() != null ) { + if ( namedQueryDefinition.getFlushMode() == FlushMode.COMMIT ) { + jpaQuery.setFlushMode( FlushModeType.COMMIT ); + } + else { + jpaQuery.setFlushMode( FlushModeType.AUTO ); + } + } + } + + protected QueryImpl createNamedSqlQuery(NamedSQLQueryDefinition namedQueryDefinition, Class resultType) { + if ( resultType != null ) { + resultClassChecking( resultType, namedQueryDefinition ); + } + return wrapAsJpaQuery( + namedQueryDefinition, + ( (SessionImplementor) internalGetSession() ).createSQLQuery( namedQueryDefinition ) + ); + } + + protected void resultClassChecking(Class resultType, NamedSQLQueryDefinition namedQueryDefinition) { + final SessionFactoryImplementor sfi = entityManagerFactory.getSessionFactory(); + + final NativeSQLQueryReturn[] queryReturns; + if ( namedQueryDefinition.getQueryReturns() != null ) { + queryReturns = namedQueryDefinition.getQueryReturns(); + } + else if ( namedQueryDefinition.getResultSetRef() != null ) { + final ResultSetMappingDefinition rsMapping = sfi.getResultSetMapping( namedQueryDefinition.getResultSetRef() ); + queryReturns = rsMapping.getQueryReturns(); + } + else { + throw new AssertionFailure( "Unsupported named query model. Please report the bug in Hibernate EntityManager"); + } + + if ( queryReturns.length > 1 ) { + throw new IllegalArgumentException( "Cannot create TypedQuery for query with more than one return" ); + } + + final NativeSQLQueryReturn nativeSQLQueryReturn = queryReturns[0]; + + if ( nativeSQLQueryReturn instanceof NativeSQLQueryRootReturn ) { + final Class actualReturnedClass; + final String entityClassName = ( (NativeSQLQueryRootReturn) nativeSQLQueryReturn ).getReturnEntityName(); + try { + actualReturnedClass = sfi.getServiceRegistry().getService( ClassLoaderService.class ).classForName( entityClassName ); + } + catch ( ClassLoadingException e ) { + throw new AssertionFailure( + "Unable to load class [" + entityClassName + "] declared on named native query [" + + namedQueryDefinition.getName() + "]" + ); + } + if ( !resultType.isAssignableFrom( actualReturnedClass ) ) { + throw buildIncompatibleException( resultType, actualReturnedClass ); + } + } + else if ( nativeSQLQueryReturn instanceof NativeSQLQueryConstructorReturn ) { + final NativeSQLQueryConstructorReturn ctorRtn = (NativeSQLQueryConstructorReturn) nativeSQLQueryReturn; + if ( !resultType.isAssignableFrom( ctorRtn.getTargetClass() ) ) { + throw buildIncompatibleException( resultType, ctorRtn.getTargetClass() ); + } + } + else { + //TODO support other NativeSQLQueryReturn type. For now let it go. } } @Override public TypedQuery createNamedQuery(String name, Class resultClass) { - checkOpen(); - try { - /* - * Get the named query. - * If the named query is a SQL query, get the expected returned type from the query definition - * or its associated result set mapping - * If the named query is a HQL query, use getReturnType() - */ - org.hibernate.Query namedQuery = internalGetSession().getNamedQuery( name ); - //TODO clean this up to avoid downcasting - final SessionFactoryImplementor factoryImplementor = entityManagerFactory.getSessionFactory(); - final NamedSQLQueryDefinition queryDefinition = factoryImplementor.getNamedSQLQuery( name ); - try { - if ( queryDefinition != null ) { - Class actualReturnedClass; - - final NativeSQLQueryReturn[] queryReturns; - if ( queryDefinition.getQueryReturns() != null ) { - queryReturns = queryDefinition.getQueryReturns(); - } - else if ( queryDefinition.getResultSetRef() != null ) { - final ResultSetMappingDefinition rsMapping = factoryImplementor.getResultSetMapping( - queryDefinition.getResultSetRef() - ); - queryReturns = rsMapping.getQueryReturns(); - } - else { - throw new AssertionFailure( "Unsupported named query model. Please report the bug in Hibernate EntityManager"); - } - if ( queryReturns.length > 1 ) { - throw new IllegalArgumentException( "Cannot create TypedQuery for query with more than one return" ); - } - final NativeSQLQueryReturn nativeSQLQueryReturn = queryReturns[0]; - if ( nativeSQLQueryReturn instanceof NativeSQLQueryRootReturn ) { - final String entityClassName = ( ( NativeSQLQueryRootReturn ) nativeSQLQueryReturn ).getReturnEntityName(); - try { - actualReturnedClass = ReflectHelper.classForName( entityClassName, AbstractEntityManagerImpl.class ); - } - catch ( ClassNotFoundException e ) { - throw new AssertionFailure( "Unable to instantiate class declared on named native query: " + name + " " + entityClassName ); - } - if ( !resultClass.isAssignableFrom( actualReturnedClass ) ) { - throw buildIncompatibleException( resultClass, actualReturnedClass ); - } - } - else { - //TODO support other NativeSQLQueryReturn type. For now let it go. - } - } - else { - resultClassChecking( resultClass, namedQuery ); - } - return new QueryImpl( namedQuery, this ); - } - catch ( RuntimeException e ) { - throw convert( e ); - } - } - catch ( MappingException e ) { - throw convert(new IllegalArgumentException( "Named query not found: " + name )); - } + return buildQueryFromName( name, resultClass ); } private IllegalArgumentException buildIncompatibleException(Class resultClass, Class actualResultClass) { return new IllegalArgumentException( - "Type specified for TypedQuery [" + - resultClass.getName() + - "] is incompatible with query return type [" + - actualResultClass + "]" - ); + "Type specified for TypedQuery [" + resultClass.getName() + + "] is incompatible with query return type [" + actualResultClass + "]" + ); } @Override diff --git a/hibernate-entitymanager/src/main/java/org/hibernate/jpa/spi/AbstractQueryImpl.java b/hibernate-entitymanager/src/main/java/org/hibernate/jpa/spi/AbstractQueryImpl.java index ead3788b6e..1143fb2a56 100644 --- a/hibernate-entitymanager/src/main/java/org/hibernate/jpa/spi/AbstractQueryImpl.java +++ b/hibernate-entitymanager/src/main/java/org/hibernate/jpa/spi/AbstractQueryImpl.java @@ -24,6 +24,7 @@ package org.hibernate.jpa.spi; import javax.persistence.FlushModeType; +import javax.persistence.LockModeType; import javax.persistence.Parameter; import javax.persistence.TemporalType; import javax.persistence.TransactionRequiredException; @@ -118,12 +119,18 @@ public abstract class AbstractQueryImpl extends BaseQueryImpl implements Type @SuppressWarnings({ "unchecked" }) public TypedQuery setLockMode(javax.persistence.LockModeType lockModeType) { checkOpen( true ); - if (! getEntityManager().isTransactionInProgress()) { - throw new TransactionRequiredException( "no transaction is in progress" ); + + // todo : technically this check should be on execution of the query, not here : HHH-8521 + if ( lockModeType != LockModeType.NONE ) { + if (! getEntityManager().isTransactionInProgress()) { + throw new TransactionRequiredException( "no transaction is in progress" ); + } } + if ( ! canApplyAliasSpecificLockModeHints() ) { throw new IllegalStateException( "Not a JPAQL/Criteria query" ); } + this.jpaLockMode = lockModeType; internalApplyLockMode( lockModeType ); return this; diff --git a/hibernate-entitymanager/src/test/java/org/hibernate/jpa/test/query/AddNamedQueryTest.java b/hibernate-entitymanager/src/test/java/org/hibernate/jpa/test/query/AddNamedQueryTest.java index 1cfd552ebb..1bc39d04d5 100644 --- a/hibernate-entitymanager/src/test/java/org/hibernate/jpa/test/query/AddNamedQueryTest.java +++ b/hibernate-entitymanager/src/test/java/org/hibernate/jpa/test/query/AddNamedQueryTest.java @@ -24,6 +24,8 @@ package org.hibernate.jpa.test.query; import javax.persistence.EntityManager; +import javax.persistence.FlushModeType; +import javax.persistence.LockModeType; import javax.persistence.Query; import org.hibernate.CacheMode; @@ -31,6 +33,8 @@ import org.hibernate.FlushMode; import org.hibernate.LockMode; import org.hibernate.ejb.HibernateQuery; import org.hibernate.ejb.QueryHints; +import org.hibernate.engine.spi.NamedQueryDefinition; +import org.hibernate.engine.spi.SessionFactoryImplementor; import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase; import org.hibernate.jpa.test.Distributor; import org.hibernate.jpa.test.Item; @@ -69,6 +73,60 @@ public class AddNamedQueryTest extends BaseEntityManagerFunctionalTestCase { em.close(); } + @Test + public void testLockModeHandling() { + final String name = "lock-mode-handling"; + + EntityManager em = getOrCreateEntityManager(); + em.getTransaction().begin(); + + Query q = em.createQuery( "from Item" ); + assertEquals( LockModeType.NONE, q.getLockMode() ); + q.setLockMode( LockModeType.OPTIMISTIC ); + assertEquals( LockModeType.OPTIMISTIC, q.getLockMode() ); + em.getEntityManagerFactory().addNamedQuery( name, q ); + + // first, lets check the underlying stored query def + SessionFactoryImplementor sfi = entityManagerFactory().unwrap( SessionFactoryImplementor.class ); + NamedQueryDefinition def = sfi.getNamedQueryRepository().getNamedQueryDefinition( name ); + assertEquals( LockMode.OPTIMISTIC, def.getLockOptions().getLockMode() ); + + // then lets create a query by name and check its setting + q = em.createNamedQuery( name ); + assertEquals( LockMode.OPTIMISTIC, q.unwrap( org.hibernate.Query.class ).getLockOptions().getLockMode() ); + assertEquals( LockModeType.OPTIMISTIC, q.getLockMode() ); + + em.getTransaction().commit(); + em.close(); + } + + @Test + public void testFlushModeHandling() { + final String name = "flush-mode-handling"; + + EntityManager em = getOrCreateEntityManager(); + em.getTransaction().begin(); + + Query q = em.createQuery( "from Item" ); + assertEquals( FlushModeType.AUTO, q.getFlushMode() ); + q.setFlushMode( FlushModeType.COMMIT ); + assertEquals( FlushModeType.COMMIT, q.getFlushMode() ); + em.getEntityManagerFactory().addNamedQuery( name, q ); + + // first, lets check the underlying stored query def + SessionFactoryImplementor sfi = entityManagerFactory().unwrap( SessionFactoryImplementor.class ); + NamedQueryDefinition def = sfi.getNamedQueryRepository().getNamedQueryDefinition( name ); + assertEquals( FlushMode.COMMIT, def.getFlushMode() ); + + // then lets create a query by name and check its setting + q = em.createNamedQuery( name ); + assertEquals( FlushMode.COMMIT, q.unwrap( org.hibernate.Query.class ).getFlushMode() ); + assertEquals( FlushModeType.COMMIT, q.getFlushMode() ); + + em.getTransaction().commit(); + em.close(); + } + @Test public void testConfigValueHandling() { final String name = "itemJpaQueryWithLockModeAndHints"; @@ -78,7 +136,7 @@ public class AddNamedQueryTest extends BaseEntityManagerFunctionalTestCase { // assert the state of the query config settings based on the initial named query assertNull( hibernateQuery.getFirstResult() ); assertNull( hibernateQuery.getMaxResults() ); - assertEquals( FlushMode.MANUAL, hibernateQuery.getFlushMode() ); // todo : we need to fix this to stick to AUTO/COMMIT when used from JPA + assertEquals( FlushMode.AUTO, hibernateQuery.getFlushMode() ); assertEquals( CacheMode.IGNORE, hibernateQuery.getCacheMode() ); assertEquals( LockMode.PESSIMISTIC_WRITE, hibernateQuery.getLockOptions().getLockMode() ); assertEquals( (Integer) 3, hibernateQuery.getTimeout() ); // jpa timeout is in milliseconds, whereas Hibernate's is in seconds @@ -91,7 +149,7 @@ public class AddNamedQueryTest extends BaseEntityManagerFunctionalTestCase { // assert the state of the query config settings based on the initial named query assertNull( hibernateQuery.getFirstResult() ); assertNull( hibernateQuery.getMaxResults() ); - assertEquals( FlushMode.MANUAL, hibernateQuery.getFlushMode() ); + assertEquals( FlushMode.AUTO, hibernateQuery.getFlushMode() ); assertEquals( CacheMode.IGNORE, hibernateQuery.getCacheMode() ); assertEquals( LockMode.PESSIMISTIC_WRITE, hibernateQuery.getLockOptions().getLockMode() ); assertEquals( (Integer) 10, hibernateQuery.getTimeout() ); @@ -104,7 +162,7 @@ public class AddNamedQueryTest extends BaseEntityManagerFunctionalTestCase { // assert the state of the query config settings based on the initial named query assertNull( hibernateQuery.getFirstResult() ); assertNull( hibernateQuery.getMaxResults() ); - assertEquals( FlushMode.MANUAL, hibernateQuery.getFlushMode() ); + assertEquals( FlushMode.AUTO, hibernateQuery.getFlushMode() ); assertEquals( CacheMode.IGNORE, hibernateQuery.getCacheMode() ); assertEquals( LockMode.PESSIMISTIC_WRITE, hibernateQuery.getLockOptions().getLockMode() ); assertEquals( (Integer) 10, hibernateQuery.getTimeout() ); @@ -117,7 +175,7 @@ public class AddNamedQueryTest extends BaseEntityManagerFunctionalTestCase { // assert the state of the query config settings based on the initial named query assertEquals( (Integer) 51, hibernateQuery.getFirstResult() ); assertNull( hibernateQuery.getMaxResults() ); - assertEquals( FlushMode.MANUAL, hibernateQuery.getFlushMode() ); + assertEquals( FlushMode.AUTO, hibernateQuery.getFlushMode() ); assertEquals( CacheMode.IGNORE, hibernateQuery.getCacheMode() ); assertEquals( LockMode.PESSIMISTIC_WRITE, hibernateQuery.getLockOptions().getLockMode() ); assertEquals( (Integer) 10, hibernateQuery.getTimeout() );