@Override public Spell findByName(String name) { Transaction tx = null; Spell result = null; try (Session session = getSessionFactory().openSession()) { tx = session.beginTransaction(); Criteria criteria = session.createCriteria(persistentClass); criteria.add(Restrictions.eq("name", name)); result = (Spell) criteria.uniqueResult(); tx.commit(); } catch (Exception e) { if (tx != null) { tx.rollback(); } throw e; } return result; } }
Criteria crit = session.createCriteria(Person.class); crit.add( Restrictions.isNotNull("birthDate")); crit.add( Restrictions.eq("isStudent", true)); crit.setProjection(Projections.rowCount()); Integer count = (Integer)crit.uniqueResult();
@Override public Object doInTransaction(TransactionStatus transactionStatus) { return sessionFactory.getCurrentSession() .createCriteria(PipelineState.class) .add(Restrictions.eq("pipelineName", pipelineName)) .setCacheable(false).uniqueResult(); } });
@Test public void shouldNotRetrieveSubSubSubEntityWithCriteria() { session = openSession(); try { SubSubSubEntity loaded = (SubSubSubEntity) session.createCriteria( SubSubSubEntity.class ) .add( Restrictions.idEq( subSubEntityId ) ) .uniqueResult(); assertNull( loaded ); } finally { session.close(); } }
c = ( Contract ) s.createCriteria( Contract.class ).uniqueResult(); assertEquals( 0, c.getParties().size() ); party = ( Party ) s.createCriteria( Party.class ).uniqueResult(); assertNull( party ); s.delete( c ); assertEquals( Long.valueOf( 0 ), s.createCriteria(Contract.class).setProjection( Projections.rowCount() ).uniqueResult() ); assertEquals( Long.valueOf( 0 ), s.createCriteria(Party.class).setProjection( Projections.rowCount() ).uniqueResult() ); t.commit(); s.close();
@Test public void testCriteriaCollection() throws Exception { Session s = openSession(); s.beginTransaction(); Baz bb = (Baz) s.createCriteria(Baz.class).uniqueResult(); assertTrue( bb == null ); Baz baz = new Baz(); s.save( baz ); s.getTransaction().commit(); s.close(); s = openSession(); s.beginTransaction(); Baz b = (Baz) s.createCriteria(Baz.class).uniqueResult(); assertTrue( Hibernate.isInitialized( b.getTopGlarchez() ) ); assertTrue( b.getTopGlarchez().size() == 0 ); s.delete( b ); s.getTransaction().commit(); s.close(); }
@Override public LogSchema findLatestLogSchemaByAppId(String applicationId) { LOG.debug("Searching latest log schema by application id [{}]", applicationId); LogSchema logSchema = null; if (isNotBlank(applicationId)) { Criteria criteria = getCriteria(); criteria.createAlias(APPLICATION_PROPERTY, APPLICATION_ALIAS); Criterion criterion = Restrictions.eq(APPLICATION_REFERENCE, Long.valueOf(applicationId)); logSchema = (LogSchema) criteria.add(criterion).addOrder(Order.desc(VERSION_PROPERTY)) .setMaxResults(FIRST).uniqueResult(); } if (LOG.isTraceEnabled()) { LOG.trace("[{}] Search result: {}.", applicationId, logSchema); } else { LOG.debug("[{}] Search result: {}.", applicationId, logSchema != null); } return logSchema; }
protected T findOneByCriterion(Criterion criterion) { String className = getSimpleClassName(); LOG.trace("Searching {} entity by criterion [{}] ", className, criterion); Criteria criteria = getCriteria(); criteria.add(criterion); return (T) criteria.uniqueResult(); }
@Override public Long countContentItems(Criteria c) { c.setProjection(Projections.rowCount()); return (Long) c.uniqueResult(); }
@Override public boolean validateApplicationEventFamilyMap(String appId, String ecfId, int version) { LOG.debug("Validating application event family map by application id [{}], ecf id [{}], " + "version [{}]", appId, ecfId, version); Criteria criteria = getCriteria(); criteria.createAlias(APPLICATION_PROPERTY, APPLICATION_ALIAS); criteria.createAlias(ECF_PROPERTY, ECF_ALIAS); criteria.add(Restrictions.and( Restrictions.eq(APPLICATION_REFERENCE, Long.valueOf(appId)), Restrictions.eq(ECF_REFERENCE, Long.valueOf(ecfId)), Restrictions.eq(VERSION_PROPERTY, version))); Long count = (Long) criteria.setProjection(Projections.rowCount()).uniqueResult(); boolean result = count != null ? count == 0 : false; LOG.debug("[{},{},{}] Validation result: {}.", appId, ecfId, version, result); return result; }
@Test public void shouldRetrieveSubSubEntityWithCriteria() { session = openSession(); try { SubSubEntity loaded = (SubSubEntity) session.createCriteria( SubSubEntity.class ) .add( Restrictions.idEq( subSubEntityId ) ) .uniqueResult(); assertNotNull( loaded ); } finally { session.close(); } }
@Test public void testSaveOrUpdateManaged() { Session s = openSession(); Transaction tx = s.beginTransaction(); NumberedNode root = new NumberedNode( "root" ); s.saveOrUpdate( root ); tx.commit(); tx = s.beginTransaction(); NumberedNode child = new NumberedNode( "child" ); root.addChild( child ); s.saveOrUpdate( root ); assertFalse( s.contains( child ) ); s.flush(); assertTrue( s.contains( child ) ); tx.commit(); assertTrue( root.getChildren().contains( child ) ); assertEquals( root.getChildren().size(), 1 ); tx = s.beginTransaction(); assertEquals( Long.valueOf( 2 ), s.createCriteria( NumberedNode.class ) .setProjection( Projections.rowCount() ) .uniqueResult() ); s.delete( root ); s.delete( child ); tx.commit(); s.close(); }
/** * Find user by password reset hash. * * @param passwordResetHash the password reset hash * @return user */ public User findByPasswordResetHash(String passwordResetHash) { Criteria criteria = getCriteria(); criteria.add(Restrictions.eq(PASSWORD_RESET_HASH_PROPERTY, passwordResetHash)); return (User) criteria.uniqueResult(); }
@Test public void testLegacyCriteriaAliasSpecific() { // open a session, begin a transaction and lock row doInHibernate( this::sessionFactory, session -> { A it = (A) session.createCriteria( A.class ) .setLockMode( "this", LockMode.PESSIMISTIC_WRITE ) .uniqueResult(); // make sure we got it assertNotNull( it ); // that initial transaction is still active and so the lock should still be held. // Lets open another session/transaction and verify that we cannot update the row nowAttemptToUpdateRow(); } ); }
criteria.createAlias(ENDPOINT_GROUP_PROPERTY, ENDPOINT_GROUP_ALIAS); Criterion crit = Restrictions.and( Restrictions.eq(ENDPOINT_GROUP_REFERENCE, Long.valueOf(groupId)), buildEqIdCriterion(ENDPOINT_PROFILE_SCHEMA_REFERENCE, endpointProfileSchemaId), buildEqIdCriterion(SERVER_PROFILE_SCHEMA_REFERENCE, serverProfileSchemaId), Restrictions.eq(STATUS_PROPERTY, UpdateStatus.DEPRECATED)); filter = (ProfileFilter) criteria.add(crit).addOrder(Order.desc(SEQUENCE_NUMBER_PROPERTY)) .setMaxResults(FIRST).uniqueResult();
Criteria criteria=session.createCriteria(Student.class); criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY); criteria.add(Restrictions.ne("enquiryStatus", ENQUIRY.JOINED)); criteria.setProjection(Projections.rowCount()) Long resultCount = (Long)criteria.uniqueResult();
protected T findOneByCriterionWithLock(Criterion criterion, LockMode lockMode) { String className = getSimpleClassName(); LOG.trace("Searching {} entity by criterion [{}] ", className, criterion); Criteria criteria = getCriteria(); criteria.setLockMode(lockMode); criteria.add(criterion); return (T) criteria.uniqueResult(); }
public long enabledUserCount() { Long value = (Long) goCache.get(ENABLED_USER_COUNT_CACHE_KEY); if (value != null) { return value; } synchronized (ENABLED_USER_COUNT_CACHE_KEY) { value = (Long) goCache.get(ENABLED_USER_COUNT_CACHE_KEY); if (value == null) { value = hibernateTemplate().execute(session -> (Long) session.createCriteria(User.class).add(Restrictions.eq("enabled", true)).setProjection(Projections.rowCount()).setCacheable(true).uniqueResult()); goCache.put(ENABLED_USER_COUNT_CACHE_KEY, value); } return value; } }
@Test public void testNaturalIdCriteria() { Session s = openSession(); s.beginTransaction(); Account u = new Account(new AccountId(1), "testAcct" ); s.persist( u ); s.getTransaction().commit(); s.close(); s = openSession(); s.beginTransaction(); u = ( Account ) s.createCriteria( Account.class ) .add( Restrictions.naturalId().set( "shortCode", "testAcct" ) ) .setCacheable( true ) .uniqueResult(); assertNotNull( u ); s.getTransaction().commit(); s.close(); s = openSession(); s.beginTransaction(); s.createQuery( "delete Account" ).executeUpdate(); s.getTransaction().commit(); s.close(); }
@Test public void testCreateWithNonEmptyOneToManyCollectionOfNew() { clearCounts(); Contract c = new Contract( null, "gail", "phone"); c.addParty( new Party( "party" ) ); Session s = openSession(); Transaction t = s.beginTransaction(); s.persist(c); t.commit(); s.close(); assertInsertCount( 2 ); assertUpdateCount( 0 ); clearCounts(); s = openSession(); t = s.beginTransaction(); c = (Contract) s.createCriteria( Contract.class ).uniqueResult(); assertEquals( 1, c.getParties().size() ); Party party = ( Party ) c.getParties().iterator().next(); assertEquals( "party", party.getName() ); if ( isContractPartiesBidirectional ) { assertSame( c, party.getContract() ); } s.delete(c); assertEquals( Long.valueOf( 0 ), s.createCriteria( Contract.class ).setProjection( Projections.rowCount() ).uniqueResult() ); assertEquals( Long.valueOf( 0 ), s.createCriteria( Party.class ).setProjection( Projections.rowCount() ).uniqueResult() ); t.commit(); s.close(); assertUpdateCount( 0 ); assertDeleteCount( 2 ); }