/**
* ラボモジュールを検索する。
*
* @param patientId 対象患者のID
* @param firstResult 取得結果リストの最初の番号
* @param maxResult 取得する件数の最大値
* @return ラボモジュールのリスト
*/
@Override
public List<NLaboModule> getLaboTest(String fidPid, int firstResult, int maxResult) {
// String fidPid = SessionHelper.getQualifiedPid(ctx, patientId);
//
// 検体採取日の降順で返す
//
List<NLaboModule> ret =
(List<NLaboModule>)
em.createQuery(QUERY_MODULE_BY_FIDPID)
.setParameter(FIDPID, fidPid)
.setFirstResult(firstResult)
.setMaxResults(maxResult)
.getResultList();
for (NLaboModule m : ret) {
if (m.getReportFormat() != null && m.getReportFormat().equals(WOLF)) {
List<NLaboItem> items =
(List<NLaboItem>)
em.createQuery(QUERY_ITEM_BY_MID_ORDERBY_SORTKEY)
.setParameter(MID, m.getId())
.getResultList();
m.setItems(items);
} else {
List<NLaboItem> items =
(List<NLaboItem>)
em.createQuery(QUERY_ITEM_BY_MID).setParameter(MID, m.getId()).getResultList();
m.setItems(items);
}
}
return ret;
}
/**
* Deletes all Results and ResultSets of a test, selftest or survey
*
* @param olatRes
* @param olatResDet
* @param repRef
* @return deleted ResultSets
*/
public int deleteAllResults(Long olatRes, String olatResDet, Long repRef) {
StringBuilder sb = new StringBuilder();
sb.append("select rset from ").append(QTIResultSet.class.getName()).append(" as rset ");
sb.append(
" where rset.olatResource=:resId and rset.olatResourceDetail=:resSubPath and rset.repositoryRef=:repoKey ");
EntityManager em = dbInstance.getCurrentEntityManager();
List<QTIResultSet> sets =
em.createQuery(sb.toString(), QTIResultSet.class)
.setParameter("resId", olatRes)
.setParameter("resSubPath", olatResDet)
.setParameter("repoKey", repRef)
.getResultList();
StringBuilder delSb = new StringBuilder();
delSb
.append("delete from ")
.append(QTIResult.class.getName())
.append(" as res where res.resultSet.key=:setKey");
Query delResults = em.createQuery(delSb.toString());
for (QTIResultSet set : sets) {
delResults.setParameter("setKey", set.getKey()).executeUpdate();
em.remove(set);
}
return sets.size();
}
@Override
public List<BluetoothDwell> getBluetoothDwellInRangeByCampaign(
Date start, Date end, Company c, Campaign camp) {
Query q;
if (start == null || end == null) {
q =
em.createQuery(
"SELECT bdwell FROM BluetoothDwell bdwell WHERE bdwell.company = ?1 and bdwell.campaign = ?2");
q.setParameter(1, c);
q.setParameter(2, camp);
} else {
q =
em.createQuery(
"SELECT bdwell FROM BluetoothDwell bdwell WHERE bdwell.company = ?1 AND bdwell.eventDate BETWEEN ?2 AND ?3 AND bdwell.campaign = ?4");
q.setParameter(1, c);
q.setParameter(2, start, TemporalType.TIMESTAMP);
q.setParameter(3, end, TemporalType.TIMESTAMP);
q.setParameter(4, camp);
}
List<BluetoothDwell> results = (List<BluetoothDwell>) q.getResultList();
if (results.size() > 0) {
return results;
}
return null;
}
protected TypedQuery<RefreshToken> getRefreshTokensQuery(
Client c, UserSubject resourceOwnerSubject) {
if (c == null && resourceOwnerSubject == null) {
return entityManager.createQuery(
"SELECT t FROM " + REFRESH_TOKEN_TABLE_NAME + " t", RefreshToken.class);
} else if (c == null) {
return entityManager.createQuery(
"SELECT t FROM "
+ REFRESH_TOKEN_TABLE_NAME
+ " t JOIN t.subject s WHERE s.login = '******'",
RefreshToken.class);
} else if (resourceOwnerSubject == null) {
return entityManager.createQuery(
"SELECT t FROM "
+ REFRESH_TOKEN_TABLE_NAME
+ " t JOIN t.client c WHERE c.clientId = '"
+ c.getClientId()
+ "'",
RefreshToken.class);
} else {
return entityManager.createQuery(
"SELECT t FROM "
+ REFRESH_TOKEN_TABLE_NAME
+ " t JOIN t.subject s JOIN t.client c WHERE s.login = '******' AND c.clientId = '"
+ c.getClientId()
+ "'",
RefreshToken.class);
}
}
public Page<Object[]> getCustomerConsist(String type, int pageNo, int pageSize) {
String hql =
"select count(id) from Customer c "
+ "where c."
+ type
+ " is not null "
+ "group by c."
+ type;
Query query = entityManager.createQuery(hql);
int total = query.getResultList().size();
hql =
"select c."
+ type
+ " , count(id) from Customer c where c."
+ type
+ " is not null "
+ "group by c."
+ type;
query = entityManager.createQuery(hql);
query.setFirstResult((pageNo - 1) * pageSize).setMaxResults(pageSize);
List content = query.getResultList();
PageRequest pageable = new PageRequest(pageNo - 1, pageSize);
PageImpl<Object[]> page = new PageImpl<Object[]>(content, pageable, total);
return page;
}
public void findAllEmployeesWithPhoneNumbers() {
EntityManager em = createEntityManager();
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = builder.isEmpty("phoneNumbers").not();
ReadAllQuery raq = new ReadAllQuery(Employee.class);
raq.setSelectionCriteria(whereClause);
raq.useDistinct();
List expectedResult = (List) getServerSession().executeQuery(raq);
String ejbqlString = "SELECT DISTINCT e FROM Employee e, IN (e.phoneNumbers) l";
Query query = em.createQuery(ejbqlString);
if (usesSOP() && getServerSession().getPlatform().isOracle()) {
// distinct is incompatible with blob in selection clause on Oracle
query.setHint(QueryHints.SERIALIZED_OBJECT, "false");
}
List firstResult = query.getResultList();
String alternateEjbqlString = "SELECT e FROM Employee e WHERE e.phoneNumbers IS NOT EMPTY";
List secondResult = em.createQuery(alternateEjbqlString).getResultList();
// 14 employees returned
Assert.assertEquals(
"Ejbql statements returned different results: data validation error",
firstResult.size(),
14);
Assert.assertTrue(
"Equivalent Ejbql statements returned different results",
comparer.compareObjects(secondResult, firstResult));
Assert.assertTrue(
"Find all employees with phone numbers test failed",
comparer.compareObjects(expectedResult, firstResult));
}
public void getOrderForCustomer() {
EntityManager em = createEntityManager();
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = builder.get("name").equal("Jane Smith");
ReadAllQuery raq = new ReadAllQuery(Customer.class);
raq.setSelectionCriteria(whereClause);
Customer expectedCustomer = (Customer) (((List) getServerSession().executeQuery(raq)).get(0));
SalesPerson salesPerson =
((Order) (expectedCustomer.getOrders().iterator().next())).getSalesPerson();
String ejbqlString =
"SELECT DISTINCT c FROM Customer c JOIN c.orders o JOIN o.salesPerson s WHERE s.id = "
+ salesPerson.getId();
List firstResult = em.createQuery(ejbqlString).getResultList();
String alternateEjbqlString =
"SELECT DISTINCT c FROM Customer c, IN(c.orders) o WHERE o.salesPerson.id = "
+ salesPerson.getId();
List secondResuslt = em.createQuery(alternateEjbqlString).getResultList();
// only 1 order for this customer
Assert.assertEquals(
"Get order for customer test failed: data validation error", firstResult.size(), 1);
Assert.assertTrue(
"Get order for customer test failed: two equivalent ejb queries return different results",
comparer.compareObjects(secondResuslt, firstResult));
Assert.assertTrue(
"Get order for customer test failed",
comparer.compareObjects(expectedCustomer, firstResult));
}
public LetterModule getLetter(long letterPk) {
LetterModule ret =
(LetterModule)
em.createQuery(QUERY_LETTER_BY_ID).setParameter(ID, letterPk).getSingleResult();
// item
List<LetterItem> items =
(List<LetterItem>)
em.createQuery(QUERY_ITEM_BY_ID).setParameter(ID, ret.getId()).getResultList();
ret.setLetterItems(items);
// text
List<LetterText> texts =
(List<LetterText>)
em.createQuery(QUERY_TEXT_BY_ID).setParameter(ID, ret.getId()).getResultList();
ret.setLetterTexts(texts);
// date
List<LetterDate> dates =
(List<LetterDate>)
em.createQuery(QUERY_DATE_BY_ID).setParameter(ID, ret.getId()).getResultList();
ret.setLetterDates(dates);
return ret;
}
public void delete(long pk) {
List<LetterItem> itemList =
(List<LetterItem>) em.createQuery(QUERY_ITEM_BY_ID).setParameter(ID, pk).getResultList();
for (LetterItem item : itemList) {
em.remove(item);
}
List<LetterText> textList =
(List<LetterText>) em.createQuery(QUERY_TEXT_BY_ID).setParameter(ID, pk).getResultList();
for (LetterText txt : textList) {
em.remove(txt);
}
List<LetterDate> dateList =
(List<LetterDate>) em.createQuery(QUERY_DATE_BY_ID).setParameter(ID, pk).getResultList();
for (LetterDate date : dateList) {
em.remove(date);
}
LetterModule delete =
(LetterModule) em.createQuery(QUERY_LETTER_BY_ID).setParameter(ID, pk).getSingleResult();
em.remove(delete);
}
@Override
public List<Object[]> getAllStatReconCtiMsc(String x, String where) {
// TODO Auto-generated method stub
if (x.contains("to_char")) {
return em.createQuery(
"Select "
+ x
+ " ,SUM(nbAppelCti) From StatReconCtiMsc s where "
+ where
+ " Group By to_date(dateAppel,'YYMMDD') Order By to_date(dateAppel,'YYMMDD') ASC ")
.getResultList();
} else {
return em.createQuery(
"Select "
+ x
+ " ,SUM(nbAppelCti) From StatReconCtiMsc s where "
+ where
+ " Group By "
+ x
+ " Order BY "
+ x
+ " ASC")
.getResultList();
}
}
public void changeRenderingStates() {
ApplicationContext context =
FacesContextUtils.getWebApplicationContext(FacesContext.getCurrentInstance());
SaveAppointments saveAppointmentsObjectInAvaliableAppointments =
(SaveAppointments) context.getBean("saveAppointments");
TypedQuery<Object[]> doctorAndTimeQuery =
em.createQuery(
"SELECT u.doktoradi,FUNCTION('DATE',u.tarih),u.uygunrandevuid FROM Uygunrandevular AS u WHERE u.doktorid=:doctorid ORDER BY u.tarih ASC",
Object[].class);
doctorAndTimeQuery.setParameter(
"doctorid",
saveAppointmentsObjectInAvaliableAppointments.selectedAppointment.getDoktorid());
doctorAndTimeList = new ArrayList<>();
doctorAndTimeList = doctorAndTimeQuery.getResultList();
TypedQuery<Randevusaatleri> query =
em.createQuery(
"SELECT c FROM Randevusaatleri c WHERE c.doktorid=:doctorid", Randevusaatleri.class);
System.out.println(
"Seçilen Randevunun ID'si"
+ saveAppointmentsObjectInAvaliableAppointments.selectedAppointment
.getUygunrandevuid());
query.setParameter(
"doctorid",
saveAppointmentsObjectInAvaliableAppointments.selectedAppointment.getDoktorid());
appointmentClockResults = new ArrayList<>();
appointmentClockResults = query.getResultList();
setRenderingTakingAppointmentInfo(false);
setRenderingClocks(true);
}
public static void jpql(EntityManager em) {
String jpql = "select b from oopQueryBasicBoard b";
System.out.println(em.createQuery(jpql, Board.class).getResultList());
jpql = "select m from oopQueryBasicMember m where titleName = 'titlename'";
System.out.println(em.createQuery(jpql, Member.class).getResultList());
}
public List<Zajecia> pobierzNieObecnosciDoRaportu(
long idStudenta, long idGrupy, long idPrzedmiotu) {
List<Zajecia> obecnosci =
em.createQuery("select o.zajecia from Obecnosci o where o.student.id = :idStudenta")
.setParameter("idStudenta", idStudenta)
.getResultList();
List<Zajecia> nieobecnosci = new ArrayList<Zajecia>();
if (obecnosci.size() > 0) {
nieobecnosci =
em.createQuery(
"from Zajecia as z where z.grupa = :grupaId and z.przedmiot = :przedmiotId and not z in (:obecnosci) ")
.setParameter("grupaId", idGrupy)
.setParameter("przedmiotId", idPrzedmiotu)
.setParameter("obecnosci", obecnosci)
.getResultList();
} else {
nieobecnosci =
em.createQuery(
"from Zajecia as z where z.grupa = :grupaId and z.przedmiot = :przedmiotId")
.setParameter("grupaId", idGrupy)
.setParameter("przedmiotId", idPrzedmiotu)
.getResultList();
}
return nieobecnosci;
}
public Map<String, Object> find(
Person examplePerson, int first, int max, String[] order, boolean[] desc) {
Map<String, Object> result = new HashMap<String, Object>(4);
String from = "from Person e ";
String where = "where lower(e.lastName) like :lastName ";
String orderBy =
order != null && order.length > 0
? "order by e." + order[0] + (desc[0] ? " desc" : "")
: "";
String lastName = examplePerson.getLastName() != null ? examplePerson.getLastName() : "";
Query qc = entityManager.createQuery("select count(e) " + from + where);
qc.setParameter("lastName", "%" + lastName.toLowerCase() + "%");
long resultCount = (Long) qc.getSingleResult();
if (max == 0) max = 36;
Query ql = entityManager.createQuery("select e " + from + where + orderBy);
ql.setFirstResult(first);
ql.setMaxResults(max);
ql.setParameter("lastName", "%" + lastName.toLowerCase() + "%");
List<?> resultList = ql.getResultList();
result.put("firstResult", first);
result.put("maxResults", max);
result.put("resultCount", resultCount);
result.put("resultList", resultList);
return result;
}
@Test
public void createAwithB() {
DynamicType simpleTypeA = helper.getType("SimpleA");
assertNotNull(simpleTypeA);
DynamicType simpleTypeB = helper.getType("SimpleB");
assertNotNull(simpleTypeB);
EntityManager em = emf.createEntityManager();
assertNotNull(JpaHelper.getServerSession(emf).getDescriptorForAlias("SimpleB"));
DynamicEntity simpleInstanceB = simpleTypeB.newDynamicEntity();
simpleInstanceB.set("id", 1);
simpleInstanceB.set("value1", "B2");
DynamicEntity simpleInstanceA = simpleTypeA.newDynamicEntity();
simpleInstanceA.set("id", 1);
simpleInstanceA.set("value1", "A2");
simpleInstanceA.<Collection<DynamicEntity>>get("b").add(simpleInstanceB);
simpleInstanceB.set("a", simpleInstanceA);
em.getTransaction().begin();
em.persist(simpleInstanceB);
em.persist(simpleInstanceA);
em.getTransaction().commit();
int simpleCountB =
((Number) em.createQuery("SELECT COUNT(s) FROM SimpleB s").getSingleResult()).intValue();
assertEquals(1, simpleCountB);
int simpleCountA =
((Number) em.createQuery("SELECT COUNT(s) FROM SimpleA s").getSingleResult()).intValue();
assertEquals(1, simpleCountA);
em.close();
}
/**
* @param dsft The DatasetFieldType in which to look up a ControlledVocabularyValue.
* @param strValue String value that may exist in a controlled vocabulary of the provided
* DatasetFieldType.
* @param lenient should we accept alternate spellings for value from mapping table
* @return The ControlledVocabularyValue found or null.
*/
public ControlledVocabularyValue findControlledVocabularyValueByDatasetFieldTypeAndStrValue(
DatasetFieldType dsft, String strValue, boolean lenient) {
TypedQuery<ControlledVocabularyValue> typedQuery =
em.createQuery(
"SELECT OBJECT(o) FROM ControlledVocabularyValue AS o WHERE o.strValue = :strvalue AND o.datasetFieldType = :dsft",
ControlledVocabularyValue.class);
typedQuery.setParameter("strvalue", strValue);
typedQuery.setParameter("dsft", dsft);
try {
ControlledVocabularyValue cvv = typedQuery.getSingleResult();
return cvv;
} catch (NoResultException | NonUniqueResultException ex) {
if (lenient) {
// if the value isn't found, check in the list of alternate values for this datasetFieldType
TypedQuery<ControlledVocabAlternate> alternateQuery =
em.createQuery(
"SELECT OBJECT(o) FROM ControlledVocabAlternate as o WHERE o.strValue = :strvalue AND o.datasetFieldType = :dsft",
ControlledVocabAlternate.class);
alternateQuery.setParameter("strvalue", strValue);
alternateQuery.setParameter("dsft", dsft);
try {
ControlledVocabAlternate alternateValue = alternateQuery.getSingleResult();
return alternateValue.getControlledVocabularyValue();
} catch (NoResultException | NonUniqueResultException ex2) {
return null;
}
} else {
return null;
}
}
}
@Test
@Transactional
public void testCopy() {
EntityManager em = bookDao.getEntityManager();
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Book> criteria = cb.createQuery(Book.class);
// Fetch join
Root<Book> root = criteria.from(Book.class);
Path<String> path = root.join("author").<String>get("name");
root.fetch("author");
criteria.select(root);
// SubQuery
Subquery<String> sq = criteria.subquery(String.class);
Root<Author> author = sq.from(Author.class);
sq.select(author.<String>get("name"));
sq.where(cb.equal(author.<String>get("name"), "Rod"));
criteria.where(cb.in(path).value(sq));
CriteriaQuery<Book> copy = cb.createQuery(Book.class);
JpaUtils.copyCriteria(criteria, copy);
List<Book> copyBooks = em.createQuery(copy).getResultList();
List<Book> books = em.createQuery(criteria).getResultList();
assertEquals(books, copyBooks);
}
public static Page<Tuserinfo> findTuserinfoesByPage(String queryParam, Page<Tuserinfo> page) {
EntityManager em = Tuserinfo.entityManager();
String sql = "SELECT o FROM Tuserinfo o ";
String countSql = "SELECT count(*) FROM Tuserinfo o ";
StringBuilder whereSql = new StringBuilder(" WHERE 1=1 ");
if (StringUtils.isNotBlank(queryParam)) {
whereSql.append(" AND (userno like :queryParam1 OR username like :queryParam2 )");
}
StringBuilder orderSql = new StringBuilder(" ORDER BY ");
if (page.isOrderBySetted()) {
orderSql.append(" " + page.getOrderBy() + " " + page.getOrderDir());
} else {
orderSql.append(" userno ASC");
}
String tsql = sql + whereSql.toString() + orderSql.toString();
String tCountSql = countSql + whereSql.toString();
TypedQuery<Tuserinfo> q = em.createQuery(tsql, Tuserinfo.class);
TypedQuery<Long> total = em.createQuery(tCountSql, Long.class);
if (StringUtils.isNotBlank(queryParam)) {
q.setParameter("queryParam1", "%" + queryParam + "%");
total.setParameter("queryParam1", "%" + queryParam + "%");
q.setParameter("queryParam2", "%" + queryParam + "%");
total.setParameter("queryParam2", "%" + queryParam + "%");
}
q.setFirstResult(page.getPageIndex()).setMaxResults(page.getMaxResult());
List<Tuserinfo> resultList = q.getResultList();
int count = total.getSingleResult().intValue();
page.setList(resultList);
page.setTotalResult(count);
return page;
}
public void parameterTest() {
EntityManager em = createEntityManager();
List employeeList = getServerSession().readAllObjects(Employee.class);
Employee expectedEmployee = (Employee) employeeList.get(0);
int i = 1;
while (expectedEmployee.getPhoneNumbers().size() == 0) {
expectedEmployee = (Employee) employeeList.get(i);
i++;
}
String phoneNumber = (expectedEmployee.getPhoneNumbers().iterator().next()).getNumber();
String ejbqlString;
String alternateEjbqlString;
if (usesSOP() && getServerSession().getPlatform().isOracle()) {
// distinct is incompatible with blob in selection clause on Oracle
ejbqlString = "SELECT e FROM Employee e, IN(e.phoneNumbers) p WHERE p.number = ?1";
alternateEjbqlString =
"SELECT e FROM Employee e, IN(e.phoneNumbers) p WHERE p.number = :number";
} else {
ejbqlString = "SELECT DISTINCT e FROM Employee e, IN(e.phoneNumbers) p WHERE p.number = ?1";
alternateEjbqlString =
"SELECT DISTINCT e FROM Employee e, IN(e.phoneNumbers) p WHERE p.number = :number";
}
List firstResult = em.createQuery(ejbqlString).setParameter(1, phoneNumber).getResultList();
List secondResult =
em.createQuery(alternateEjbqlString).setParameter("number", phoneNumber).getResultList();
// random test cant duplicate
Assert.assertTrue(
"Parameter test failed: two equivalent ejb queries return different results",
comparer.compareObjects(secondResult, firstResult));
Assert.assertTrue(
"Parameter test failed", comparer.compareObjects(expectedEmployee, firstResult));
}
private void cleanDB() {
EntityManager entityManager = StopTime.entityManager();
entityManager.createQuery("DELETE FROM StopTime").executeUpdate();
entityManager.createQuery("DELETE FROM Trip").executeUpdate();
entityManager.createQuery("DELETE FROM Route").executeUpdate();
entityManager.createQuery("DELETE FROM Stop").executeUpdate();
}
public void updateAllTest() {
if ((JUnitTestCase.getServerSession()).getPlatform().isSymfoware()) {
getServerSession()
.logMessage(
"Test updateAllTest skipped for this platform, "
+ "Symfoware doesn't support UpdateAll/DeleteAll on multi-table objects (see rfe 298193).");
return;
}
EntityManager em = createEntityManager();
String empName = "Saunders";
String manName = "Smitty";
String ejbqlString = "SELECT DISTINCT e FROM Employee e WHERE e.lastName = '" + empName + "'";
Employee employee = (Employee) em.createQuery(ejbqlString).getSingleResult();
Address addr = em.find(Address.class, employee.getAddress().getID());
String ejbqlString2 = "SELECT DISTINCT e FROM Employee e WHERE e.lastName = '" + manName + "'";
Employee manager = (Employee) em.createQuery(ejbqlString2).getSingleResult();
beginTransaction(em);
em.createQuery("UPDATE Employee e SET e.manager = :manager " + "WHERE e.address = :addr ")
.setParameter("manager", manager)
.setParameter("addr", addr)
.executeUpdate();
commitTransaction(em);
String ejbqlString3 =
"SELECT DISTINCT e.manager FROM Employee e WHERE e.lastName = '" + empName + "'";
String result = ((Employee) em.createQuery(ejbqlString3).getSingleResult()).getLastName();
Assert.assertTrue("UpdateAll test failed", result.equals(manName));
}
public void queryMedicalHistory4() {
EntityManager em = emf.createEntityManager();
Map medicals = new HashMap();
long ssn = 0;
EntityTransaction tran = em.getTransaction();
tran.begin();
String jpql = "select m from MedicalHistory2 m";
Query q = em.createQuery(jpql);
List<MedicalHistory2> ms = q.getResultList();
for (MedicalHistory2 m : ms) {
ssn = m.getId();
}
tran.commit();
em.close();
em = emf.createEntityManager();
tran = em.getTransaction();
tran.begin();
jpql = "select m from MedicalHistory2 m where m.patient.ssn = " + ssn;
q = em.createQuery(jpql);
ms = q.getResultList();
for (MedicalHistory2 m : ms) {
assertMedicalHistory2(m);
}
tran.commit();
em.close();
findObj4(ssn);
}
public Page<Object[]> getCustomerService(int pageNo, int pageSize, Date minDate, Date maxDate) {
String hql =
"select count(cs.serviceType) from CustomerService cs "
+ " where cs.customer is not null And cs.serviceType is not null "
+ " and cs.createDate between ? and ?";
Query query = entityManager.createQuery(hql);
query.setParameter(1, minDate);
query.setParameter(2, maxDate);
long total = (long) query.getSingleResult();
hql =
"select cs.serviceType , count(cs.serviceType) from CustomerService cs "
+ "where cs.customer is not null and cs.serviceType is not null and cs.createDate between ? and ? "
+ " group by cs.serviceType";
query = entityManager.createQuery(hql);
query.setParameter(1, minDate);
query.setParameter(2, maxDate);
query.setFirstResult((pageNo - 1) * pageSize).setMaxResults(pageSize);
List<Object[]> content = query.getResultList();
PageRequest pageable = new PageRequest(pageNo - 1, pageSize);
PageImpl<Object[]> page = new PageImpl<Object[]>(content, pageable, total);
return page;
}
public void testMetamodelOnClauseOverCollection() {
EntityManager em = createEntityManager();
Query query =
em.createQuery("Select e from Employee e join e.phoneNumbers p on p.areaCode = '613'");
List baseResult = query.getResultList();
CriteriaBuilder qb = em.getCriteriaBuilder();
CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
Metamodel metamodel = em.getMetamodel();
EntityType<Employee> entityEmp_ = metamodel.entity(Employee.class);
EntityType<PhoneNumber> entityPhone_ = metamodel.entity(PhoneNumber.class);
Root<Employee> root = cq.from(entityEmp_);
Join phoneNumber = root.join(entityEmp_.getCollection("phoneNumbers"));
phoneNumber.on(qb.equal(phoneNumber.get(entityPhone_.getSingularAttribute("areaCode")), "613"));
List testResult = em.createQuery(cq).getResultList();
clearCache();
closeEntityManager(em);
if (baseResult.size() != testResult.size()) {
fail(
"Criteria query using ON clause did not match JPQL results; "
+ baseResult.size()
+ " were expected, while criteria query returned "
+ testResult.size());
}
}
private Element crearEstructuraXML() {
Element historialNotas = new Element(ConstantesArchivosXML.SUPERPADRE);
Query q = entityManager.createQuery(ConsultasJpql.HISTORIAL_NOTAS_ESTUDIANTES);
@SuppressWarnings("unchecked")
List<Usuario> usuarios = (List<Usuario>) q.getResultList();
for (Usuario usuario : usuarios) {
Element usuarioXML = crearXMLUsuario(usuario);
Query q2 = entityManager.createQuery(ConsultasJpql.HISTORIAL_NOTAS);
q2.setParameter("parametro", usuario.getId());
@SuppressWarnings("unchecked")
List<HistorialNotas> notasCurso = (List<HistorialNotas>) q2.getResultList();
for (HistorialNotas curso : notasCurso) {
Element cursoXML =
crearXMLCurso(
curso.getGrupoCurso().getCursoGrupo(),
curso.getNota(),
curso.getGrupoCurso().getIdGrupo(),
curso.getGrupoCurso().getSemestre());
usuarioXML.addContent(cursoXML);
}
historialNotas.addContent(usuarioXML);
}
return historialNotas;
}
public void testMetamodelOnClauseWithLeftJoin() {
EntityManager em = createEntityManager();
Query query =
em.createQuery(
"Select e from Employee e left join e.address a on a.city = 'Ottawa' "
+ "where a.postalCode is not null");
List baseResult = query.getResultList();
Metamodel metamodel = em.getMetamodel();
EntityType<Employee> entityEmp_ = metamodel.entity(Employee.class);
EntityType<Address> entityAddr_ = metamodel.entity(Address.class);
CriteriaBuilder qb = em.getCriteriaBuilder();
CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
Root<Employee> root = cq.from(entityEmp_);
Join address = root.join(entityEmp_.getSingularAttribute("address"), JoinType.LEFT);
address.on(qb.equal(address.get(entityAddr_.getSingularAttribute("city")), "Ottawa"));
cq.where(qb.isNotNull(address.get(entityAddr_.getSingularAttribute("postalCode"))));
List testResult = em.createQuery(cq).getResultList();
clearCache();
closeEntityManager(em);
if (baseResult.size() != testResult.size()) {
fail(
"Criteria query using ON clause with a left join did not match JPQL results; "
+ baseResult.size()
+ " were expected, while criteria query returned "
+ testResult.size());
}
}
/**
* Returns a collection of bounds for reactions included in the given's model metabolism. Note
* that it has to be a sum of bounds of the parent model (if the given model has a parent) and the
* bounds directly associated with current model.
*
* @param model
* @return collection of bounds for the given model
*/
Collection<EBounds> getBoundsForModel(EModel model, EntityManager em) {
if (model.getParent() == null) {
return model.getEBoundsCollection();
} else {
/*
* There are two sources of bounds for each model.
* First, we retrieve bounds that have been defined for this model
*/
List<EBounds> res1 =
em.createQuery("SELECT e FROM EBounds e WHERE e.model = :model")
.setParameter("model", model)
.getResultList();
/*
* The remaining bounds are taken from the parent model
*/
List<EBounds> res2 =
em.createQuery(
" SELECT b FROM EModel m, EBounds b WHERE "
+ " m.id = :modelID AND m.parent IS NOT NULL AND "
+ " b.model = m.parent AND NOT EXISTS (SELECT c "
+ " FROM EBounds c WHERE c.model = :model AND "
+ " b.reaction = c.reaction )")
.setParameter("modelID", model.getId())
.setParameter("model", model)
.getResultList();
res1.addAll(res2);
return res1;
}
}
/**
* Deletes a tag.
*
* @param tagId Tag ID
* @param userId User ID
*/
public void delete(String tagId, String userId) {
EntityManager em = ThreadLocalContext.get().getEntityManager();
// Get the tag
Query q = em.createQuery("select t from Tag t where t.id = :id and t.deleteDate is null");
q.setParameter("id", tagId);
Tag tagDb = (Tag) q.getSingleResult();
// Delete the tag
Date dateNow = new Date();
tagDb.setDeleteDate(dateNow);
// Delete linked data
q =
em.createQuery(
"update DocumentTag dt set dt.deleteDate = :dateNow where dt.tagId = :tagId and dt.deleteDate is not null");
q.setParameter("dateNow", dateNow);
q.setParameter("tagId", tagId);
q.executeUpdate();
q =
em.createQuery(
"update Acl a set a.deleteDate = :dateNow where a.sourceId = :tagId and a.deleteDate is null");
q.setParameter("tagId", tagId);
q.setParameter("dateNow", dateNow);
q.executeUpdate();
// Create audit log
AuditLogUtil.create(tagDb, AuditLogType.DELETE, userId);
}
@SuppressWarnings({"unchecked"})
private void cleanup() {
EntityManager em = getOrCreateEntityManager();
em.getTransaction().begin();
for (Hoarder hoarder : (List<Hoarder>) em.createQuery("from Hoarder").getResultList()) {
hoarder.getItems().clear();
em.remove(hoarder);
}
for (Category category : (List<Category>) em.createQuery("from Category").getResultList()) {
if (category.getExampleItem() != null) {
category.setExampleItem(null);
em.remove(category);
}
}
for (Item item : (List<Item>) em.createQuery("from Item").getResultList()) {
item.setCategory(null);
em.remove(item);
}
em.createQuery("delete from Item").executeUpdate();
em.getTransaction().commit();
em.close();
}
@Test
public void testQuotientAndMultiply() {
EntityManager em = getOrCreateEntityManager();
em.getTransaction().begin();
CriteriaQuery<Number> criteria = builder.createQuery(Number.class);
criteria.from(Product.class);
criteria.select(
builder.quot(
builder.prod(
builder.literal(BigDecimal.valueOf(10.0)),
builder.literal(BigDecimal.valueOf(5.0))),
BigDecimal.valueOf(2.0)));
Number result = em.createQuery(criteria).getSingleResult();
assertEquals(25.0d, result.doubleValue(), 0.1d);
criteria.select(
builder.prod(
builder.quot(
builder.literal(BigDecimal.valueOf(10.0)),
builder.literal(BigDecimal.valueOf(5.0))),
BigDecimal.valueOf(2.0)));
result = em.createQuery(criteria).getSingleResult();
assertEquals(4.0d, result.doubleValue(), 0.1d);
em.getTransaction().commit();
em.close();
}