@Nullable protected User loadUser(String login) throws LoginException { if (login == null) { throw new IllegalArgumentException("Login is null"); } EntityManager em = persistence.getEntityManager(); String queryStr = "select u from sec$User u where u.loginLowerCase = ?1 and (u.active = true or u.active is null)"; Query q = em.createQuery(queryStr); q.setParameter(1, login.toLowerCase()); List list = q.getResultList(); if (list.isEmpty()) { log.debug("Unable to find user: {}", login); return null; } else { //noinspection UnnecessaryLocalVariable User user = (User) list.get(0); return user; } }
EntityManager mainEm = persistence.getEntityManager(); List ids = mainEm.createQuery(getExcludeIdsQueryString()) .setParameter("entityName", metaClass.getName()) .getResultList(); if (ids.isEmpty()) { return storeEm.createQuery(getQueryString()) .setParameter("ids", ids) .getResultList(); List loadingIds = ids.subList(i, Math.min(i + LOADING_SIZE, ids.size())); List loadingResult = storeEm.createQuery(getQueryString()) .setParameter("ids", loadingIds) .setMaxResults(ftsConfig.getReindexBatchSize()) .getResultList(); result.addAll(loadingResult); if (result.size() == ftsConfig.getReindexBatchSize()) { } else { return storeEm.createQuery(getQueryString()) .getResultList(); Query query = em.createQuery(getQueryString()); if (excludeFromQueue) { query.setParameter("entityName", metaClass.getName()); query.setMaxResults(ftsConfig.getReindexBatchSize()); return query.getResultList();
private Query createPolymorphicQuery(EntityManager em, Class<? extends Entity> polymorphicEntityClass, String attribute, Entity softReference, String view) { String tableName = getTableNameFromEntityClass(polymorphicEntityClass); Query query = em.createQuery("select e from " + tableName + " e where e." + attribute + " = :softReference"); query.setParameter("softReference", softReference, false); if (view != null) { query.setView(polymorphicEntityClass, view); } return query; }
@Override public void run(EntityManager em) { Query query = em.createQuery("delete from sys$ScheduledExecution e where e.id in ?1"); query.setParameter(1, subList); query.executeUpdate(); } });
protected synchronized List<ScheduledTask> getTasks() { log.trace("Read all active tasks from DB and lock them"); EntityManager em = persistence.getEntityManager(); Query query = em.createQuery("select t from sys$ScheduledTask t where t.active = true"); query.setLockMode(LockModeType.PESSIMISTIC_WRITE); return query.getResultList(); } }
log.debug("Constraints applied: " + printQuery(query.getQueryString())); query.setView(queryView); if (queryParams != null) { for (Map.Entry<String, Object> queryParamEntry : queryParams.entrySet()) { query.setParameter(queryParamEntry.getKey(), queryParamEntry.getValue()); query.setFirstResult(parameterPrototype.getFirstResult() == null ? 0 : parameterPrototype.getFirstResult()); query.setMaxResults(parameterPrototype.getMaxResults()); } else { Configuration configuration = AppBeans.get(Configuration.NAME); ReportingConfig config = configuration.getConfig(ReportingConfig.class); query.setMaxResults(config.getParameterPrototypeQueryLimit()); queryResult = query.getResultList(); tx.commit(); } catch (Exception e) {
String pkName = referenceToEntitySupport.getPrimaryKeyForLoadingEntity(metaClass); List<BaseGenericIdEntity> entitiesValues = em.createQuery(format("select e from %s e where e.%s in :ids", metaClass.getName(), pkName)) .setParameter("ids", ids) .setView(metaClass.getJavaClass(), View.MINIMAL) .getResultList();
break; query.setFirstResult(firstResult); query.setMaxResults(maxResults); List<E> list = query.getResultList(); if (list.size() == 0) { break;
Query q = persistence.getEntityManager().createQuery("select h.user.id, count(h.id) " + "from sec$ScreenHistory h group by h.user.id having count(h.id) > ?1"); q.setParameter(1, MAX_RECORDS); List<Object[]> userList = q.getResultList(); tx.commitRetaining(); deleteQuery.setParameter(1, toDelete); deleteQuery.executeUpdate(); tx.commitRetaining();
protected boolean referenceExists(String entityName, MetaProperty property) { String template = property.getRange().getCardinality().isMany() ? "select count(e) from %s e join e.%s c where c." + primaryKeyName + "= ?1" : "select count(e) from %s e where e.%s." + primaryKeyName + " = ?1"; String qstr = String.format(template, entityName, property.getName()); Query query = entityManager.createQuery(qstr); query.setParameter(1, entity.getId()); query.setMaxResults(1); Long count = (Long) query.getSingleResult(); return count > 0; }
@Override @Transactional(timeout = 2) public String executeSelectSql(String sql) { checkTestMode(); log.info("started: " + sql); EntityManager em = persistence.getEntityManager(); Query query = em.createNativeQuery(sql); query.getResultList(); log.info("finished: " + sql); return "Done"; }
@Override public long getLastFinished(ScheduledTask task) { EntityManager em = persistence.getEntityManager(); Query query = em.createQuery( "select max(e.finishTime) from sys$ScheduledExecution e where e.task.id = ?1") .setParameter(1, task.getId()); Date date = (Date) query.getFirstResult(); return date == null ? 0 : date.getTime(); }
protected <T extends Entity> T findWithViews(MetaClass metaClass, Object id, List<View> views) { Object realId = getRealId(id); log.debug("find {} by id={}, views={}", metaClass.getJavaClass().getSimpleName(), realId, views); String pkName = metadata.getTools().getPrimaryKeyName(metaClass); if (pkName == null) throw new IllegalStateException("Cannot determine PK name for entity " + metaClass); Query query = createQuery(String.format("select e from %s e where e.%s = ?1", metaClass.getName(), pkName)); ((QueryImpl) query).setSingleResultExpected(true); query.setParameter(1, realId); for (View view : views) { query.addView(view); } //noinspection unchecked return (T) query.getFirstResult(); }
@SuppressWarnings("unchecked") protected <E extends Entity> List<E> executeQuery(Query query, boolean singleResult) { List<E> list; try { if (singleResult) { try { E result = (E) query.getSingleResult(); list = new ArrayList<>(1); list.add(result); } catch (NoResultException e) { list = Collections.emptyList(); } } else { list = query.getResultList(); } } catch (javax.persistence.PersistenceException e) { if (e.getCause() instanceof org.eclipse.persistence.exceptions.QueryException && e.getMessage() != null && e.getMessage().contains("Fetch group cannot be set on report query")) { throw new DevelopmentException("DataManager cannot execute query for single attributes"); } else { throw e; } } return list; }
protected String generateReportName(String sourceName, int iteration) { if (iteration == 1) { iteration++; //like in win 7: duplicate of file 'a.txt' is 'a (2).txt', NOT 'a (1).txt' } String reportName = StringUtils.stripEnd(sourceName, null); if (iteration > 0) { String newReportName = String.format("%s (%s)", reportName, iteration); if (newReportName.length() > MAX_REPORT_NAME_LENGTH) { String abbreviatedReportName = StringUtils.abbreviate(reportName, MAX_REPORT_NAME_LENGTH - String.valueOf(iteration).length() - 3);// 3 cause it us " ()".length reportName = String.format("%s (%s)", abbreviatedReportName, iteration); } else { reportName = newReportName; } } Transaction tx = persistence.createTransaction(); try { Long countOfReportsWithSameName = (Long) persistence.getEntityManager() .createQuery("select count(r) from report$Report r where r.name = :name") .setParameter("name", reportName) .getSingleResult(); tx.commit(); if (countOfReportsWithSameName > 0) { return generateReportName(sourceName, ++iteration); } } finally { tx.end(); } return reportName; }
SequenceSupport sequenceSupport = getSequenceSupport(sequence); Query query = em.createNativeQuery(sequenceSupport.sequenceExistsSql(sequenceName)); List list = query.getResultList(); if (list.isEmpty()) { query = em.createNativeQuery(sequenceSupport.createSequenceSql(sequenceName, sequence.getStartValue(), sequence.getIncrement())); query.executeUpdate();
public Query getQuery(EntityManager em) { Query query = em.createQuery(queryString); //we have to replace parameter names in macros because for {@link com.haulmont.cuba.core.sys.querymacro.TimeBetweenQueryMacroHandler} //we need to replace a parameter with number of days with its value before macros is expanded to JPQL expression replaceParamsInMacros(query); applyConstraints(query); QueryParser parser = QueryTransformerFactory.createParser(queryString); Set<String> paramNames = parser.getParamNames(); for (Map.Entry<String, Object> entry : queryParams.entrySet()) { String name = entry.getKey(); if (paramNames.contains(name)) { Object value = entry.getValue(); if (value instanceof TemporalValue) { TemporalValue temporalValue = (TemporalValue) value; query.setParameter(name, temporalValue.date, temporalValue.type); } else { if (noConversionParams != null && Arrays.asList(noConversionParams).contains(name)) { query.setParameter(name, value, false); } else { query.setParameter(name, value); } } } else { if (entry.getValue() != null) throw new DevelopmentException("Parameter '" + name + "' is not used in the query"); } } return query; }
protected Query createQuery(EntityManager em, LoadContext context, boolean singleResult) { LoadContext.Query contextQuery = context.getQuery(); RdbmsQueryBuilder queryBuilder = AppBeans.get(RdbmsQueryBuilder.NAME); queryBuilder.init( contextQuery == null ? null : contextQuery.getQueryString(), contextQuery == null ? null : contextQuery.getCondition(), contextQuery == null ? null : contextQuery.getSort(), contextQuery == null ? null : contextQuery.getParameters(), contextQuery == null ? null : contextQuery.getNoConversionParams(), context.getId(), context.getMetaClass() ); queryBuilder.setSingleResult(singleResult); if (!context.getPrevQueries().isEmpty()) { log.debug("Restrict query by previous results"); queryBuilder.restrictByPreviousResults(userSessionSource.getUserSession().getId(), context.getQueryKey()); } Query query = queryBuilder.getQuery(em); if (contextQuery != null) { if (contextQuery.getFirstResult() != 0) query.setFirstResult(contextQuery.getFirstResult()); if (contextQuery.getMaxResults() != 0) query.setMaxResults(contextQuery.getMaxResults()); if (contextQuery.isCacheable()) { query.setCacheable(contextQuery.isCacheable()); } } return query; }
String logMsg = "Load previous query results: " + RdbmsQueryBuilder.printQuery(query.getQueryString()); log.debug(logMsg); long start = System.currentTimeMillis(); idList = query.getResultList(); tx.commit();
@Override @Transactional(timeout = 2) public String executeUpdateSql(String sql) { checkTestMode(); log.info("started: " + sql); EntityManager em = persistence.getEntityManager(); Query query = em.createNativeQuery(sql); query.executeUpdate(); log.info("finished: " + sql); return "Done"; }