Refine search
@SuppressWarnings("unchecked") public List<String> findContextIdForEvent(String eventType, String ownerId) { EntityManager em = emf.createEntityManager(); Query findQuery = em.createNamedQuery("FindProcessInstanceWaitingForEvent") .setParameter("eventType", eventType).setParameter("ownerId", ownerId); return findQuery.getResultList(); }
protected void deleteAllPeopleUsingEntityManager(EntityManager em) { em.createQuery("delete from Person p").executeUpdate(); }
private static boolean hasData(EntityManager entityManager) { return (((Long) entityManager.createQuery( "select count(a) from Address a" ).getSingleResult()) + ((Long) entityManager.createQuery( "select count(p) from Person p" ).getSingleResult())) > 0; } }
// SQL: SELECT * FROM table LIMIT start, maxRows; Query q = session.createQuery("FROM table"); q.setFirstResult(start); q.setMaxResults(maxRows);
String sql = "SELECT t FROM table t"; Query query = em.createQuery(sql); query.setFirstResult(firstPosition); query.setMaxResults(numberOfRecords); List result = query.getResultList();
Query empQuery = session.createQuery(hqlQuery); empQuery.setMaxResults(maxResult); employees = (List<Employee>) empQuery.list(); for (Employee emp : employees) { Hibernate.initialize(emp.address); }
/** * Test positional query. */ private void testPositionalQuery() { String queryString = "Select min(p.salary) from PersonES p where p.personName = ?1"; Query query = em.createQuery(queryString); query.setParameter(1, "amit"); List resultList = query.getResultList(); Assert.assertEquals(1, resultList.size()); Assert.assertEquals(100.0, resultList.get(0)); }
@Override @SuppressWarnings("unchecked") public List<Employee> findSubordinates(Employee manager) { return entityManager.createQuery("SELECT u from User u where u.manager = :manager") // .setParameter("manager", manager) // .getResultList(); } }
@SuppressWarnings("unchecked") public static List<LoanShark> findLoanSharkEntries(int firstResult, int maxResults) { return entityManager().createQuery("select o from LoanShark o").setFirstResult(firstResult).setMaxResults(maxResults).getResultList(); }
@Test @SuppressWarnings("unchecked") public void testEntityManagerProxyIsProxy() { assertTrue(Proxy.isProxyClass(sharedEntityManager.getClass())); Query q = sharedEntityManager.createQuery("select p from Person as p"); q.getResultList(); assertTrue("Should be open to start with", sharedEntityManager.isOpen()); sharedEntityManager.close(); assertTrue("Close should have been silently ignored", sharedEntityManager.isOpen()); }
/** * Test max aggregation. */ private void testMaxAggregation() { String queryString = "Select max(p.age) from PersonES p"; Query query = em.createQuery(queryString); List resultList = query.getResultList(); Assert.assertEquals(1, resultList.size()); Assert.assertEquals(40.0, resultList.get(0)); }
final EntityManagerFactory emf = persistenceProvider.createEntityManagerFactory( "hibernate-osgi-test", null ); EntityManager em = emf.createEntityManager(); em.getTransaction().begin(); em.persist( new DataPoint( "Brett" ) ); em.getTransaction().commit(); em.close(); em = emf.createEntityManager(); em.getTransaction().begin(); DataPoint dp = em.find( DataPoint.class, 1 ); em.close(); em = emf.createEntityManager(); em.getTransaction().begin(); dp = em.find( DataPoint.class, 1 ); em = emf.createEntityManager(); em.getTransaction().begin(); em.createQuery( "delete from DataPoint" ).executeUpdate(); em.getTransaction().commit(); em.close();
@SuppressWarnings("unchecked") @Override public List<FulfillmentGroup> readUnprocessedFulfillmentGroups(int start, int maxResults) { Query query = em.createNamedQuery("BC_READ_UNPROCESSED_FULFILLMENT_GROUP_ASC"); query.setFirstResult(start); query.setMaxResults(maxResults); return query.getResultList(); }
@Override protected int getProcessInstancesCount() { boolean txOwner = false; if( useTransactions ) { txOwner = txm.begin(); } int size = emf.createEntityManager().createQuery( "FROM ProcessInstanceInfo" ).getResultList().size(); if( useTransactions ) { txm.commit(txOwner); } return size; }
@Test @SuppressWarnings("unchecked") public void testQueryNoPersons() { EntityManager em = entityManagerFactory.createEntityManager(); Query q = em.createQuery("select p from Person as p"); List<Person> people = q.getResultList(); assertEquals(0, people.size()); try { assertNull(q.getSingleResult()); fail("Should have thrown NoResultException"); } catch (NoResultException ex) { // expected } }
/** * Test delete all. */ private void testDeleteAll() { persistBooks(); int result = em.createQuery("delete from Book b").executeUpdate(); Assert.assertEquals(4, result); assertDeleted(T, T, T, T); }
@Test public void test() { doInJPA( this::sessionFactory, entityManager -> { Thing thing = new Thing(); entityManager.persist( thing ); entityManager .createQuery( "update thing set special = :s, version = version + 1" ) .setParameter( "s", "new" ) .executeUpdate(); thing.special = "If I'm flush to the DB you get an OptimisticLockException"; } ); }
/** * @param b */ private void testNativeQuery(boolean b) { String s = "Select * From " + "\"StudentUUID\""; EntityManager em = emf.createEntityManager(); Query q = em.createNativeQuery(s, StudentUUID.class); List<StudentUUID> results = q.getResultList(); Assert.assertNotNull(results); }
@Test public void deferredQueryWithSingleResult() { EntityManagerFactory emf = mock(EntityManagerFactory.class); EntityManager targetEm = mock(EntityManager.class); Query query = mock(Query.class); given(emf.createEntityManager()).willReturn(targetEm); given(targetEm.createQuery("x")).willReturn(query); given(targetEm.isOpen()).willReturn(true); EntityManager em = SharedEntityManagerCreator.createSharedEntityManager(emf); em.createQuery("x").getSingleResult(); verify(query).getSingleResult(); verify(targetEm).close(); }
@Test public void deferredQueryWithUpdate() { EntityManagerFactory emf = mock(EntityManagerFactory.class); EntityManager targetEm = mock(EntityManager.class); Query query = mock(Query.class); given(emf.createEntityManager()).willReturn(targetEm); given(targetEm.createQuery("x")).willReturn(query); given(targetEm.isOpen()).willReturn(true); EntityManager em = SharedEntityManagerCreator.createSharedEntityManager(emf); em.createQuery("x").executeUpdate(); verify(query).executeUpdate(); verify(targetEm).close(); }