@Override public <T> QueryImplementor<T> createQuery( String jpaqlString, Class<T> resultClass, Selection selection, QueryOptions queryOptions) { return delegate.createQuery( jpaqlString,resultClass, selection, queryOptions ); }
@Override public QueryImplementor createQuery(CriteriaDelete deleteQuery) { return delegate.createQuery( deleteQuery ); }
@Override public <T> QueryImplementor<T> createQuery(CriteriaQuery<T> criteriaQuery) { return delegate.createQuery( criteriaQuery ); }
@Override public QueryImplementor createQuery(CriteriaUpdate updateQuery) { return delegate.createQuery( updateQuery ); }
@Override public QueryImplementor createQuery(String queryString) { return delegate.createQuery( queryString ); }
@Override public <T> QueryImplementor<T> createQuery(String queryString, Class<T> resultType) { return delegate.createQuery( queryString, resultType ); }
@Test public void testCollectionFetch() { inTransaction( session -> { final List nonDistinctResult = session.createQuery( "select c from Customer c join fetch c.orders" ).list(); assertThat( nonDistinctResult.size(), CoreMatchers.is( 2 ) ); final List distinctResult = session.createQuery( "select distinct c from Customer c join fetch c.orders" ).list(); assertThat( distinctResult.size(), CoreMatchers.is( 1 ) ); final List distinctViaTransformerResult = session.createQuery( "select c from Customer c join fetch c.orders" ) .setResultTransformer( DistinctRootEntityResultTransformer.INSTANCE ).list(); assertThat( distinctResult.size(), CoreMatchers.is( 1 ) ); } ); }
@After public void cleanUpTestData() { inTransaction( entityManagerFactory(), session -> { session.createQuery( "delete from Comment" ).executeUpdate(); session.createQuery( "delete from Issue" ).executeUpdate(); session.createQuery( "delete from User" ).executeUpdate(); } ); }
@After public void delete() { inTransaction( s -> { s.createQuery( "delete from EntityA" ).executeUpdate(); s.createQuery( "delete from EntityB" ).executeUpdate(); } ); }
@After public void cleanupData() { inTransaction( s -> s.createQuery( "delete from Person" ).executeUpdate() ); }
@After public void cleanupData() { inTransaction( s -> s.createQuery( "delete from Person" ).executeUpdate() ); }
@Test public void testPositionalParameters() { TransactionUtil2.inTransaction( sessionFactory(), session -> { Query query = session.createQuery( "select i from Item i where name = ?1 or name = ?2" ); for ( Parameter<?> parameter : query.getParameters() ) { assertThat( parameter.getPosition(), notNullValue() ); assertThat( parameter.getPosition(), either( is(1) ).or( is(2) ) ); } } ); } }
@After public void cleanupData() { if ( sessionFactory == null ) { return; } inTransaction( sessionFactory, s -> { s.createQuery( "delete from Person" ).executeUpdate(); } ); sessionFactory.close(); }
@Test public void testSetInvalidFirstResult() { inTransaction( session -> { try { // Query session.createQuery( "select p from Person p" ).setFirstResult( -3 ); fail( "expecting failure" ); } catch (IllegalArgumentException expected) { // expected condition } } ); }
@Test public void testGetParameterValueByUnknownName() { inTransaction( session -> { try { // Query final QueryImplementor query1 = session.createQuery( "select p from Person p where name = :name1" ); query1.getParameterValue( "name2" ); fail( "expecting failure" ); } catch (IllegalArgumentException expected) { // expected condition } } ); }
@Test public void testSetInvalidMaxResults() { inTransaction( session -> { try { // Query session.createQuery( "select p from Person p where name = ?1" ).setMaxResults( -3 ); fail( "expecting failure" ); } catch (IllegalArgumentException expected) { // expected condition } } ); }
@Test public void testGetParameterValueByUnknownPosition() { inTransaction( session -> { try { // Query final QueryImplementor query1 = session.createQuery( "select p from Person p" ); query1.getParameterValue( 2 ); fail( "expecting failure" ); } catch (IllegalArgumentException expected) { // expected condition } } ); }
@Test public void testUpdateOnImplicitJoinFails() { inTransaction( s -> { try { s.createQuery( "update Human set mother.name.initial = :initial" ).setString( "initial", "F" ).executeUpdate(); fail( "update allowed across implicit join" ); } catch (IllegalArgumentException e) { assertTyping( QueryException.class, e.getCause() ); } catch( QueryException e ) { } } ); }
@Test public void testUpdateRequiresTxn() { inSession( session -> { try { assertFalse( session.getTransaction().isActive() ); // Query session.createQuery( "update Person set name = 'steve'" ).executeUpdate(); fail( "expecting failure" ); } catch (TransactionRequiredException expected) { // expected condition } } ); }
@Test public void testInsertThenUpdate() { sessionFactory().getCache().evictEntityRegions(); sessionFactory().getStatistics().clear(); inTransaction( sessionFactory, s -> { CacheableItem item = new CacheableItem( "data" ); s.save( item ); s.flush(); item.setName( "new data" ); } ); assertTrue( sessionFactory().getCache().containsEntity( CacheableItem.class, 1L ) ); inTransaction( sessionFactory, s -> s.createQuery( "delete CacheableItem" ).executeUpdate() ); }