@Test @Priority(10) public void initData() { // Revision 1 EntityManager em = getEntityManager(); em.getTransaction().begin(); StrTestEntity fe = new StrTestEntity( "x" ); em.persist( fe ); em.flush(); em.remove( em.find( StrTestEntity.class, fe.getId() ) ); em.flush(); em.getTransaction().commit(); // id = fe.getId(); }
@Test public void test_criteria_typedquery_expression_example() { doInJPA( this::entityManagerFactory, entityManager -> { //tag::criteria-typedquery-expression-example[] CriteriaBuilder builder = entityManager.getCriteriaBuilder(); CriteriaQuery<String> criteria = builder.createQuery( String.class ); Root<Person> root = criteria.from( Person.class ); criteria.select( root.get( Person_.nickName ) ); criteria.where( builder.equal( root.get( Person_.name ), "John Doe" ) ); List<String> nickNames = entityManager.createQuery( criteria ).getResultList(); //end::criteria-typedquery-expression-example[] assertEquals(1, nickNames.size()); }); }
@Stateless public class CommentService { @PersistenceContext(unitName = "pu") private EntityManager em; public void create(Comment t) { em.merge(t); } public Collection<Comment> getAll() { Query q = em.createNamedQuery("Comment.findAll"); Collection<Comment> entities = q.getResultList(); return entities; } }
public List<User> myCustomBatchOperation() { CriteriaQuery<User> criteriaQuery = em.getCriteriaBuilder().createQuery(User.class); criteriaQuery.select(criteriaQuery.from(User.class)); return em.createQuery(criteriaQuery).getResultList(); } }
@Transactional public void remove() { if (this.entityManager == null) { this.entityManager = entityManager(); } if (this.entityManager.contains(this)) { this.entityManager.remove(this); } else { LoanShark attached = this.entityManager.find(this.getClass(), this.id); this.entityManager.remove(attached); } }
private void findByNameAndAgeGTAndLT() { EntityManager em; String query; Query q; List<StudentBooleanPrimitive> students; em = emf.createEntityManager(); query = "Select s From StudentBooleanPrimitive s where s.name = Amresh and s.age > " + getMinValue(short.class) + " and s.age < " + getMaxValue(short.class); q = em.createQuery(query); students = q.getResultList(); Assert.assertNotNull(students); Assert.assertTrue(students.isEmpty()); em.close(); }
/** * Test avg aggregation. */ private void testAvgAggregation() { String queryString = "Select avg(i.quantity) from Item i"; Query query = em.createQuery(queryString); List resultList = query.getResultList(); Assert.assertEquals(1, resultList.size()); Assert.assertEquals(25.0, resultList.get(0)); }
private List<RootEntity> getAllRows(EntityManager em) { CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<RootEntity> cq = cb.createQuery( RootEntity.class ); Root<RootEntity> c = cq.from( RootEntity.class ); return em.createQuery( cq.select( c ).orderBy( cb.desc( c.get( "status" ) ) ) ).getResultList(); }
public void testFindById(boolean useSameEm) { EntityManager em = emf.createEntityManager(); StudentMongoCalendar studentMax = em.find(StudentMongoCalendar.class, getMaxValue(Calendar.class)); Assert.assertNotNull(studentMax); Assert.assertEquals(getMaxValue(short.class), studentMax.getAge()); Assert.assertEquals(getMaxValue(String.class), studentMax.getName()); em.close(); }
@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()); }
@Override public void removedExpiredAccounts(LocalDate reference) { CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<Account> query = cb.createQuery(Account.class); Root<Account> account = query.from(Account.class); query.where(cb.lessThan(account.get("expiryDate").as(Date.class), reference.toDateTimeAtStartOfDay().toDate())); for (Account each : em.createQuery(query).getResultList()) { em.remove(each); } } }
@Test public void testCreateCorrelation() throws Exception { EntityManagerFactory emf = (EntityManagerFactory) context.get(EnvironmentName.ENTITY_MANAGER_FACTORY); EntityManager em = emf.createEntityManager(); Query query = em.createNamedQuery("GetProcessInstanceIdByCorrelation"); query.setParameter("ckey", "test123"); List<Long> processInstances = query.getResultList(); em.close(); assertNotNull(processInstances); assertEquals(1, processInstances.size()); }
public void testEntityListener() { EntityManagerFactory emf = getEntityManagerFactory(); EntityManager em = emf.createEntityManager(); PersonnelDTO dto = new PersonnelDTO(); dto.setFirstName("Vivek"); dto.setLastName("vivek"); dto.setPersonId("1_p"); em.persist(dto); PersonnelDTO result = em.find(PersonnelDTO.class, "1_p"); Assert.assertNotNull(result); Assert.assertEquals("Mishra", result.getLastName()); emf.close(); }
@TestForIssue(jiraKey = "HHH-9296") @Test public void selectByParent() { doInJPA( this::entityManagerFactory, entityManager -> { Post post = entityManager.find( Post.class, 1 ); CriteriaBuilder cb = entityManager.getCriteriaBuilder(); CriteriaQuery<PostDetails> query = cb.createQuery( PostDetails.class ); Root<PostDetails> root = query.from( PostDetails.class ); query.where( cb.equal( root.get( "post" ), post ) ); final PostDetails result = entityManager.createQuery( query ).getSingleResult(); assertNotNull( result ); }); }
@Test public void test_criteria_param_example() { doInJPA( this::entityManagerFactory, entityManager -> { //tag::criteria-param-example[] CriteriaBuilder builder = entityManager.getCriteriaBuilder(); CriteriaQuery<Person> criteria = builder.createQuery( Person.class ); Root<Person> root = criteria.from( Person.class ); ParameterExpression<String> nickNameParameter = builder.parameter( String.class ); criteria.where( builder.equal( root.get( Person_.nickName ), nickNameParameter ) ); TypedQuery<Person> query = entityManager.createQuery( criteria ); query.setParameter( nickNameParameter, "JD" ); List<Person> persons = query.getResultList(); //end::criteria-param-example[] assertEquals(1, persons.size()); }); }
@Test @TestForIssue(jiraKey = "HHH-12786") public void testBasicProxyingWithProtectedMethodCalledInConstructor() { doInJPA( this::entityManagerFactory, entityManager -> { Adult adult = new Adult(); adult.setName( "Arjun Kumar" ); entityManager.persist( adult ); } ); doInJPA( this::entityManagerFactory, entityManager -> { List<Adult> adultsCalledArjun = entityManager .createQuery( "SELECT a from Adult a WHERE a.name = :name", Adult.class ) .setParameter( "name", "Arjun Kumar" ).getResultList(); Adult adult = adultsCalledArjun.iterator().next(); entityManager.remove( adult ); } ); }
@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 } }
private void deleteNamedQueryOnCounter() { EntityManager em = emf.createEntityManager(); String deleteQuery = "Delete From Counters c where c.id <= " + id2; Query q = em.createQuery(deleteQuery); q.executeUpdate(); Counters counter2 = new Counters(); counter2 = em.find(Counters.class, id1); Assert.assertNull(counter2); Counters counter3 = new Counters(); counter3 = em.find(Counters.class, id2); Assert.assertNull(counter3); em.close(); } }
public void deleteCounter() { EntityManager em = emf.createEntityManager(); Counters counters = new Counters(); counters = em.find(Counters.class, id3); Assert.assertNotNull(counters); Assert.assertNotNull(counters.getCounter()); em.remove(counters); EntityManager em1 = emf.createEntityManager(); counters = em1.find(Counters.class, id3); Assert.assertNull(counters); em.close(); }