@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(); } }
@Override @Transactional(value="defaultTransactionManager") public void clearDuplicateAccessTokens() { Query query = manager.createQuery("select a.jwt, count(1) as c from OAuth2AccessTokenEntity a GROUP BY a.jwt HAVING count(1) > 1"); @SuppressWarnings("unchecked") List<Object[]> resultList = query.getResultList(); List<JWT> values = new ArrayList<>(); for (Object[] r : resultList) { logger.warn("Found duplicate access tokens: {}, {}", ((JWT)r[0]).serialize(), r[1]); values.add((JWT) r[0]); } if (values.size() > 0) { CriteriaBuilder cb = manager.getCriteriaBuilder(); CriteriaDelete<OAuth2AccessTokenEntity> criteriaDelete = cb.createCriteriaDelete(OAuth2AccessTokenEntity.class); Root<OAuth2AccessTokenEntity> root = criteriaDelete.from(OAuth2AccessTokenEntity.class); criteriaDelete.where(root.get("jwt").in(values)); int result = manager.createQuery(criteriaDelete).executeUpdate(); logger.warn("Deleted {} duplicate access tokens", result); } }
@Test public void deferredQueryWithResultList() { 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").getResultList(); verify(query).getResultList(); verify(targetEm).close(); }
private <E extends Object> void assertFindByName(EntityManager em, String clazz, E e, String name, String fieldName) { String query = "Select p from PF p where p." + fieldName + " = " + name; // // find by name. Query q = em.createQuery(query); List<E> results = q.getResultList(); Assert.assertNotNull(results); Assert.assertFalse(results.isEmpty()); Assert.assertEquals(3, results.size()); }
private void findByNameAndAgeWithOrClause() { EntityManager em; String query; Query q; List<StudentCouchDBDate> students; int count; em = emf.createEntityManager(); query = "Select s From StudentOracleNoSQLDate s where s.name = Kuldeep and s.age > " + getMinValue(short.class); q = em.createQuery(query); students = q.getResultList(); Assert.assertNotNull(students); Assert.assertEquals(1, students.size()); count = 0; for (StudentCouchDBDate student : students) { Assert.assertEquals(getMaxValue(Date.class), student.getId()); Assert.assertEquals(getMaxValue(short.class), student.getAge()); Assert.assertEquals("Kuldeep", student.getName()); count++; } Assert.assertEquals(1, count); em.close(); }
@SuppressWarnings("unchecked") public static ArrayList<ProcessInstanceInfo> retrieveProcessInstanceInfo(EntityManagerFactory emf) { JtaTransactionManager txm = new JtaTransactionManager(null, null, null); boolean txOwner = txm.begin(); EntityManager em = emf.createEntityManager(); ArrayList<ProcessInstanceInfo> procInstInfoList = new ArrayList<ProcessInstanceInfo>(); List<Object> mdList = em.createQuery("SELECT p FROM ProcessInstanceInfo p").getResultList(); for( Object resultObject : mdList ) { ProcessInstanceInfo procInstInfo = (ProcessInstanceInfo) resultObject; procInstInfoList.add(procInstInfo); logger.trace("> {}", procInstInfo); } txm.commit(txOwner); return procInstInfoList; }
@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()); }
/** * @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 @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 max aggregation with nested and or clause. */ public void testMaxAggregationWithNestedAndOrClause() { String nestedQuery = "Select max(p.age) from PersonES p where p.age > 0 AND (p.salary > 250 and (p.personName = 'karthik' OR p.personName = 'pragalbh'))"; Query query = em.createQuery(nestedQuery); List resultList = query.getResultList(); Assert.assertNotNull(resultList); Assert.assertEquals(1, resultList.size()); Assert.assertEquals(40.0, resultList.get(0)); }
@Override @Transactional(value="defaultTransactionManager") public void clearDuplicateRefreshTokens() { Query query = manager.createQuery("select a.jwt, count(1) as c from OAuth2RefreshTokenEntity a GROUP BY a.jwt HAVING count(1) > 1"); @SuppressWarnings("unchecked") List<Object[]> resultList = query.getResultList(); List<JWT> values = new ArrayList<>(); for (Object[] r : resultList) { logger.warn("Found duplicate refresh tokens: {}, {}", ((JWT)r[0]).serialize(), r[1]); values.add((JWT) r[0]); } if (values.size() > 0) { CriteriaBuilder cb = manager.getCriteriaBuilder(); CriteriaDelete<OAuth2RefreshTokenEntity> criteriaDelete = cb.createCriteriaDelete(OAuth2RefreshTokenEntity.class); Root<OAuth2RefreshTokenEntity> root = criteriaDelete.from(OAuth2RefreshTokenEntity.class); criteriaDelete.where(root.get("jwt").in(values)); int result = manager.createQuery(criteriaDelete).executeUpdate(); logger.warn("Deleted {} duplicate refresh tokens", result); } }
private void findByNameAndAgeWithOrClause() { EntityManager em; String query; Query q; List<StudentHBaseByteWrapper> students; int count; em = emf.createEntityManager(); query = "Select s From StudentHBaseByteWrapper s where s.name = Kuldeep and s.age > " + getPartialValue(short.class); q = em.createQuery(query); students = q.getResultList(); Assert.assertNotNull(students); Assert.assertEquals(1, students.size()); count = 0; for (StudentHBaseByteWrapper student : students) { Assert.assertEquals(getMaxValue(Byte.class), student.getId()); Assert.assertEquals(getMaxValue(short.class), student.getAge()); Assert.assertEquals("Kuldeep", student.getName()); count++; } Assert.assertEquals(1, count); em.close(); }
@Override @SuppressWarnings("unchecked") public List<Contact> findRelatives(Contact contact) { return entityManager.createQuery("SELECT u FROM User u WHERE u.lastname = :lastname") // .setParameter("lastname", contact.getLastname()) // .getResultList(); } }
@Test @SuppressWarnings("unchecked") public void testEntityManagerProxyIsProxy() { EntityManager em = createContainerManagedEntityManager(); assertTrue(Proxy.isProxyClass(em.getClass())); Query q = em.createQuery("select p from Person as p"); List<Person> people = q.getResultList(); assertTrue(people.isEmpty()); assertTrue("Should be open to start with", em.isOpen()); try { em.close(); fail("Close should not work on container managed EM"); } catch (IllegalStateException ex) { // OK } assertTrue(em.isOpen()); }
/** * @param b */ private void testNativeQuery(boolean b) { String s = "Select * From " + "\"StudentOracleNoSQLUUID\""; EntityManager em = emf.createEntityManager(); Query q = em.createNativeQuery(s, StudentCouchDBUUID.class); List<StudentCouchDBUUID> results = q.getResultList(); Assert.assertNotNull(results); }
@Test @SuppressWarnings("unchecked") public void testEntityManagerProxyIsProxy() { EntityManager em = entityManagerFactory.createEntityManager(); assertTrue(Proxy.isProxyClass(em.getClass())); Query q = em.createQuery("select p from Person as p"); List<Person> people = q.getResultList(); assertNotNull(people); assertTrue("Should be open to start with", em.isOpen()); em.close(); assertFalse("Close should work on application managed EM", em.isOpen()); }
/** * Test field with in clause. */ public void testFieldWithInClause() { String queryString = "Select p.personName from PersonES p where p.personId IN ( '1', '2') and p.age = 10"; Query query = em.createQuery(queryString); List resultList = query.getResultList(); Assert.assertNotNull(resultList); Assert.assertEquals(1, resultList.size()); Assert.assertEquals("karthik", resultList.get(0)); }
@Test @SuppressWarnings("unchecked") public void testMultipleResults() { // Add with JDBC String firstName = "Tony"; insertPerson(firstName); assertTrue(Proxy.isProxyClass(sharedEntityManager.getClass())); Query q = sharedEntityManager.createQuery("select p from Person as p"); List<Person> people = q.getResultList(); assertEquals(1, people.size()); assertEquals(firstName, people.get(0).getFirstName()); }
private void findByNameAndAgeWithOrClause() { EntityManager em; String query; Query q; List<StudentHBaseInt> students; int count; em = emf.createEntityManager(); query = "Select s From StudentHBaseInt s where s.name = Kuldeep and s.age > " + getPartialValue(short.class); q = em.createQuery(query); students = q.getResultList(); Assert.assertNotNull(students); Assert.assertEquals(1, students.size()); count = 0; for (StudentHBaseInt student : students) { Assert.assertEquals(getMaxValue(int.class), student.getId()); Assert.assertEquals(getMaxValue(short.class), student.getAge()); Assert.assertEquals("Kuldeep", student.getName()); count++; } Assert.assertEquals(1, count); em.close(); }
@SuppressWarnings({"unchecked"}) private void printPersons(StringBuilder sb) { List<Person> persons = entityManager.createQuery( "select p from Person p order by p.id").getResultList(); sb.append("Persons:\n"); for (Person p : persons) { printPerson(sb, p); sb.append("\n"); } }