@Override protected void executeDataMigration(HibernateMigrationHelper helper, MigrationResult result, Session session) { session.createQuery("UPDATE BaseEntity SET disabled = false").executeUpdate(); result.incrementStatus(); ScrollableResults scroll = session .createQuery( "FROM BaseEntity be LEFT JOIN be.attributes att WHERE att.key = :archived AND att.value = :true") .setParameter("archived", KEY_ARCHIVED).setParameter("true", "true").scroll(); while( scroll.next() ) { FakeBaseEntity be = (FakeBaseEntity) scroll.get(0); be.disabled = true; session.save(be); session.flush(); session.clear(); result.incrementStatus(); } }
@Override protected void executeDataMigration(HibernateMigrationHelper helper, MigrationResult result, Session session) throws Exception { ScrollableResults results = session.createQuery( "FROM MimeEntryAttributes WHERE element LIKE '%.gif' AND mapkey = 'PluginIconPath' ").scroll(); while( results.next() ) { Object[] resultEntry = results.get(); FakeMimeEntryAttributes fmeAttr = (FakeMimeEntryAttributes) resultEntry[0]; fmeAttr.element = fmeAttr.element.replaceAll(".gif", ".png"); session.save(fmeAttr); session.flush(); session.clear(); } }
@Override public Iterator<QtiAssessmentResult> getIterator() { final ScrollableResults cinnamonScroll = (ScrollableResults) getHibernateTemplate() .execute(new HibernateCallback() { @Override public Object doInHibernate(Session session) throws HibernateException, SQLException { final Query query = getAllQuery(session); query.setReadOnly(true); return query.scroll(ScrollMode.FORWARD_ONLY); } }); return new ScrollableResultsIterator<QtiAssessmentResult>(cinnamonScroll); }
@Override public Iterator<QtiItemResult> getIterator() { final ScrollableResults cinnamonScroll = (ScrollableResults) getHibernateTemplate() .execute(new HibernateCallback() { @Override public Object doInHibernate(Session session) throws HibernateException, SQLException { final Query query = getAllQuery(session); query.setReadOnly(true); return query.scroll(ScrollMode.FORWARD_ONLY); } }); return new ScrollableResultsIterator<QtiItemResult>(cinnamonScroll); }
@Override public Iterator<QtiAssessmentItem> getIterator() { final ScrollableResults cinnamonScroll = (ScrollableResults) getHibernateTemplate() .execute(new HibernateCallback() { @Override public Object doInHibernate(Session session) throws HibernateException, SQLException { final Query query = session.createQuery("FROM QtiAssessmentItem WHERE institution = :institution"); query.setParameter("institution", CurrentInstitution.get()); query.setReadOnly(true); return query.scroll(ScrollMode.FORWARD_ONLY); } }); return new ScrollableResultsIterator<QtiAssessmentItem>(cinnamonScroll); }
@Override protected void executeDataMigration(HibernateMigrationHelper helper, MigrationResult result, Session session) { ScrollableResults scroll = session.createQuery(QUERY).scroll(); while( scroll.next() ) { FakeWorkflowItemStatus item = (FakeWorkflowItemStatus) scroll.get(0); if( item.dateDue != null ) { item.started = new Date(item.dateDue.getTime() - TimeUnit.DAYS.toMillis(item.wnode.escalationdays)); } else { item.started = new Date(); } session.save(item); session.flush(); session.clear(); result.incrementStatus(); } }
@Override protected void executeDataMigration(HibernateMigrationHelper helper, MigrationResult result, Session session) { Query query = session .createQuery("select i.id, i.moderation.id from Item i where moderating = true or status = 'rejected'"); ScrollableResults results = query.scroll(); while( results.next() ) { Query upQuery = session .createQuery("update ModerationStatus m set lastAction = " + "(select max(h.date) from Item i join i.history h where i.id = ? and h.type in ('approved','rejected', 'comment') group by i.id) " + "where m.id = ?"); upQuery.setParameter(0, results.get(0)); upQuery.setParameter(1, results.get(1)); upQuery.executeUpdate(); } }
@Override protected void executeDataMigration(HibernateMigrationHelper helper, MigrationResult result, Session session) { ScrollableResults scroll = session.createQuery("from Notification").scroll(); while( scroll.next() ) { FakeNotification note = (FakeNotification) scroll.get(0); if( note.reason.equals("review") ) { session.delete(note); } else { note.itemidOnly = note.itemid; note.processed = true; note.batched = false; session.save(note); } session.flush(); session.clear(); result.incrementStatus(); } }
@Override protected void executeDataMigration(HibernateMigrationHelper helper, MigrationResult result, Session session) { // Find dupes and kill them (keep the latest one) final ScrollableResults dupes = session.createQuery(getDupesFrom() + " ORDER BY n.date DESC").scroll( ScrollMode.FORWARD_ONLY); final Set<String> visited = Sets.newHashSet(); while( dupes.next() ) { final FakeNotification dupe = (FakeNotification) dupes.get(0); final String key = dupe.itemid + dupe.reason + dupe.userTo + dupe.institution.id; // Ignore the most recent notification, we'll keep this one if( !visited.contains(key) ) { visited.add(key); } else { session.delete(dupe); session.flush(); session.clear(); } result.incrementStatus(); } }
/** * Coordinates the efforts to perform a scroll across all the included query translators. * * @param queryParameters The query parameters * @param session The session * * @return The query result iterator * * @throws HibernateException Indicates a problem performing the query */ public ScrollableResults performScroll( QueryParameters queryParameters, SessionImplementor session) throws HibernateException { if ( TRACE_ENABLED ) { LOG.tracev( "Iterate: {0}", getSourceQuery() ); queryParameters.traceParameters( session.getFactory() ); } if ( translators.length != 1 ) { throw new QueryException( "implicit polymorphism not supported for scroll() queries" ); } if ( queryParameters.getRowSelection().definesLimits() && translators[0].containsCollectionFetches() ) { throw new QueryException( "firstResult/maxResults not supported in conjunction with scroll() of a query containing collection fetches" ); } return translators[0].scroll( queryParameters, session ); }
@Override public ScrollableResults scroll(Criteria criteria, ScrollMode scrollMode) { // TODO: Is this guaranteed to always be CriteriaImpl? CriteriaImpl criteriaImpl = (CriteriaImpl) criteria; errorIfClosed(); checkTransactionSynchStatus(); String entityName = criteriaImpl.getEntityOrClassName(); CriteriaLoader loader = new CriteriaLoader( getOuterJoinLoadable(entityName), factory, criteriaImpl, entityName, getLoadQueryInfluencers() ); autoFlushIfRequired( loader.getQuerySpaces() ); dontFlushFromFind++; try { return loader.scroll(this, scrollMode); } finally { delayedAfterCompletion(); dontFlushFromFind--; } }
@Override public ScrollableResults scrollCustomQuery(CustomQuery customQuery, QueryParameters queryParameters) throws HibernateException { errorIfClosed(); checkTransactionSynchStatus(); if ( LOG.isTraceEnabled() ) { LOG.tracev( "Scroll SQL query: {0}", customQuery.getSQL() ); } CustomLoader loader = new CustomLoader( customQuery, getFactory() ); autoFlushIfRequired( loader.getQuerySpaces() ); dontFlushFromFind++; //stops flush being called multiple times if this method is recursively called try { return loader.scroll(queryParameters, this); } finally { delayedAfterCompletion(); dontFlushFromFind--; } }
public ScrollableResults scroll(ScrollMode scrollMode) throws HibernateException { verifyParameters(); before(); Map namedParams = getNamedParams(); NativeSQLQuerySpecification spec = generateQuerySpecification( namedParams ); QueryParameters qp = getQueryParameters( namedParams ); qp.setScrollMode( scrollMode ); try { return getSession().scroll( spec, qp ); } finally { after(); } }
@Override public ScrollableResults scroll(Criteria criteria, ScrollMode scrollMode) { // TODO: Is this guaranteed to always be CriteriaImpl? CriteriaImpl criteriaImpl = (CriteriaImpl) criteria; errorIfClosed(); String entityName = criteriaImpl.getEntityOrClassName(); CriteriaLoader loader = new CriteriaLoader( getOuterJoinLoadable( entityName ), factory, criteriaImpl, entityName, getLoadQueryInfluencers() ); return loader.scroll(this, scrollMode); }
void converteerToegangLeveringsautorisaties() { final Session session = (Session) entityManager.getDelegate(); final ScrollableResults scResults = session.createCriteria(ToegangLeveringsAutorisatie.class).scroll(ScrollMode.FORWARD_ONLY); while (scResults.next()) { final ToegangLeveringsAutorisatie toegang = (ToegangLeveringsAutorisatie) scResults.get(0); if (Stelsel.GBA == toegang.getLeveringsautorisatie().getStelsel()) { if (toegang.getLeveringsautorisatie().getDatumEinde() != null) { LOGGER.warn("ToegangLeveringsAutorisatie met id {} wordt niet geconverteerd, " + "want leveringsautorisatie '{}' met id {} is niet geldig", toegang.getId(), toegang.getLeveringsautorisatie().getNaam(), toegang.getLeveringsautorisatie().getId()); continue; } converteerToegangLeveringsAutorisatie(toegang); entityManager.flush(); entityManager.clear(); } } }
private void deleteProductCharacteristicValue(ProductCharacteristic productCharacteristic) { ScrollableResults scroll = null; try { OBCriteria<ProductCharacteristicValue> criteria = OBDal.getInstance().createCriteria( ProductCharacteristicValue.class); criteria.add(Restrictions.eq(ProductCharacteristicValue.PROPERTY_CHARACTERISTIC, productCharacteristic.getCharacteristic())); criteria.add(Restrictions.eq(ProductCharacteristicValue.PROPERTY_PRODUCT, productCharacteristic.getProduct())); scroll = criteria.scroll(ScrollMode.FORWARD_ONLY); int i = 0; while (scroll.next()) { ProductCharacteristicValue productCharacteristicValue = (ProductCharacteristicValue) scroll .get(0); OBDal.getInstance().remove(productCharacteristicValue); i++; if (i % 100 == 0) { OBDal.getInstance().flush(); OBDal.getInstance().getSession().clear(); } } } finally { scroll.close(); } }
/** * Get all the payment details with available credit */ public static ScrollableResults getPaymentsWithCredit(String businessPartnerId, String currencyId) { StringBuilder hql = new StringBuilder(); hql.append(" SELECT t1." + FIN_Payment.PROPERTY_ID); hql.append(" FROM " + FIN_Payment.ENTITY_NAME + " as t1"); hql.append(" WHERE t1." + FIN_Payment.PROPERTY_BUSINESSPARTNER + ".id = :businessPartnerId"); hql.append(" AND t1." + FIN_Payment.PROPERTY_CURRENCY + ".id = :currencyId"); hql.append(" AND t1." + FIN_Payment.PROPERTY_GENERATEDCREDIT + " <> 0"); hql.append(" AND t1." + FIN_Payment.PROPERTY_GENERATEDCREDIT + " <> t1." + FIN_Payment.PROPERTY_USEDCREDIT); final Query query = OBDal.getInstance().getSession().createQuery(hql.toString()); query.setParameter("businessPartnerId", businessPartnerId); query.setParameter("currencyId", currencyId); ScrollableResults scroll = query.scroll(ScrollMode.SCROLL_SENSITIVE); return scroll; }
private void initializeLines(CostAdjustment costAdjustment) { // initialize is related transaction adjusted flag to false OBCriteria<CostAdjustmentLine> critLines = OBDal.getInstance().createCriteria( CostAdjustmentLine.class); critLines.add(Restrictions.eq(CostAdjustmentLine.PROPERTY_COSTADJUSTMENT, costAdjustment)); critLines.add(Restrictions.eq(CostAdjustmentLine.PROPERTY_ISRELATEDTRANSACTIONADJUSTED, true)); ScrollableResults lines = critLines.scroll(ScrollMode.FORWARD_ONLY); long count = 1L; try { while (lines.next()) { CostAdjustmentLine line = (CostAdjustmentLine) lines.get(0); line.setRelatedTransactionAdjusted(false); OBDal.getInstance().save(line); if (count % 1000 == 0) { OBDal.getInstance().flush(); OBDal.getInstance().getSession().clear(); } count++; } OBDal.getInstance().flush(); OBDal.getInstance().getSession().clear(); } finally { lines.close(); } }
private void updateInitInventoriesTrxDate(Date startingDate, String ruleId) { StringBuffer where = new StringBuffer(); where.append(" as trx"); where.append(" join trx." + MaterialTransaction.PROPERTY_PHYSICALINVENTORYLINE + " as il"); where.append(" where il." + InventoryCountLine.PROPERTY_PHYSINVENTORY + ".id IN ("); where.append(" select cri." + CostingRuleInit.PROPERTY_INITINVENTORY + ".id"); where.append(" from " + CostingRuleInit.ENTITY_NAME + " as cri"); where.append(" where cri." + CostingRuleInit.PROPERTY_COSTINGRULE + ".id = :cr"); where.append(" )"); OBQuery<MaterialTransaction> trxQry = OBDal.getInstance().createQuery( MaterialTransaction.class, where.toString()); trxQry.setNamedParameter("cr", ruleId); trxQry.setFetchSize(1000); ScrollableResults trxs = trxQry.scroll(ScrollMode.FORWARD_ONLY); int i = 0; while (trxs.next()) { MaterialTransaction trx = (MaterialTransaction) trxs.get(0); trx.setTransactionProcessDate(startingDate); OBDal.getInstance().save(trx); if ((i % 100) == 0) { OBDal.getInstance().flush(); OBDal.getInstance().getSession().clear(); } } trxs.close(); }
private ScrollableResults getTransactions(Set<String> childOrgs, Date startDate, Date endDate) { StringBuffer select = new StringBuffer(); select.append("select trx as trx"); select.append(" from " + MaterialTransaction.ENTITY_NAME + " as trx"); select.append(" where trx." + MaterialTransaction.PROPERTY_ORGANIZATION + ".id in (:orgs)"); select.append(" and trx." + MaterialTransaction.PROPERTY_ISCOSTCALCULATED + " = true"); select.append(" and trx." + MaterialTransaction.PROPERTY_TRANSACTIONPROCESSDATE + " >= (:startDate)"); if (endDate != null) { select.append(" and trx." + MaterialTransaction.PROPERTY_TRANSACTIONPROCESSDATE + " < (:endDate)"); } select.append(" order by trx." + MaterialTransaction.PROPERTY_MOVEMENTDATE); Query stockLinesQry = OBDal.getInstance().getSession().createQuery(select.toString()); stockLinesQry.setParameterList("orgs", childOrgs); stockLinesQry.setTimestamp("startDate", startDate); if (endDate != null) { stockLinesQry.setTimestamp("endDate", endDate); } stockLinesQry.setFetchSize(1000); ScrollableResults stockLines = stockLinesQry.scroll(ScrollMode.FORWARD_ONLY); return stockLines; }
private ScrollableResults getCloseInventoryLines(Set<String> orgs) { StringBuffer where = new StringBuffer(); where.append(" as il"); where.append(" where exists (select 1 from " + CostingRuleInit.ENTITY_NAME + " as cri"); where.append(" where cri." + CostingRuleInit.PROPERTY_CLOSEINVENTORY + " = il." + InventoryCountLine.PROPERTY_PHYSINVENTORY + ")"); where.append(" and il." + InventoryCountLine.PROPERTY_ORGANIZATION + ".id IN (:orgs)"); where.append(" order by " + InventoryCountLine.PROPERTY_PRODUCT + ", il." + InventoryCountLine.PROPERTY_BOOKQUANTITY); OBQuery<InventoryCountLine> iclQry = OBDal.getInstance().createQuery(InventoryCountLine.class, where.toString()); iclQry.setNamedParameter("orgs", orgs); iclQry.setFilterOnActive(false); iclQry.setFilterOnReadableClients(false); iclQry.setFilterOnReadableOrganization(false); iclQry.setFetchSize(1000); return iclQry.scroll(ScrollMode.FORWARD_ONLY); }
/** * Computes the row number of a record which has the id which is passed in as a parameter. The * rownumber computation takes into account the filter and sorting settings of the the OBQuery * object. * * @param targetId * the record id * @return the row number or -1 if not found */ public int getRowNumber(String targetId) { String qryStr = createQueryString(); if (qryStr.toLowerCase().contains(FROM_SPACED)) { final int index = qryStr.indexOf(FROM_SPACED) + FROM_SPACED.length(); qryStr = qryStr.substring(index); } final Query qry = getSession() .createQuery("select " + usedAlias + "id " + FROM_SPACED + qryStr); setParameters(qry); final ScrollableResults results = qry.scroll(ScrollMode.FORWARD_ONLY); try { while (results.next()) { final String id = results.getString(0); if (id.equals(targetId)) { return results.getRowNumber(); } } } finally { results.close(); } return -1; }
public int doCriteriaQry() { final OBCriteria<MaterialTransaction> obc = OBDal.getInstance().createCriteria( MaterialTransaction.class); obc.add(Restrictions.isNotNull(MaterialTransaction.PROPERTY_UOM)); obc.addOrderBy(MaterialTransaction.PROPERTY_PRODUCT + "." + Product.PROPERTY_NAME, false); obc.setMaxResults(10); obc.setFirstResult(0); if (doScroll) { final ScrollableResults r = obc.scroll(ScrollMode.FORWARD_ONLY); int cnt = 0; while (r.next()) { cnt++; } return cnt; } final List<MaterialTransaction> cs = obc.list(); return cs.size(); }
public int doCriteriaQry() { OBCriteria<BusinessPartner> c = OBDal.getInstance().createCriteria(BusinessPartner.class); c.setFilterOnActive(false); c.setFilterOnReadableClients(false); c.setFilterOnReadableOrganization(false); c.setMaxResults(1000); if (doScroll) { final ScrollableResults r = c.scroll(ScrollMode.FORWARD_ONLY); int cnt = 0; while (r.next()) { cnt++; } return cnt; } final List<BusinessPartner> cs = c.list(); return cs.size(); }
public int doHqlQry() { OBQuery<BusinessPartner> q = OBDal.getInstance().createQuery(BusinessPartner.class, ""); q.setFilterOnActive(false); q.setFilterOnReadableClients(false); q.setFilterOnReadableOrganization(false); q.setMaxResult(1000); qryStr = "All BusinessPartners"; if (doScroll) { int cnt = 0; ScrollableResults scroller = q.scroll(ScrollMode.FORWARD_ONLY); while (scroller.next()) { cnt++; } return cnt; } final List<BusinessPartner> cs = q.list(); return cs.size(); }
/** * Runs the query by calling <code>org.hibernate.Query.scroll()</code>. * * @return scrollable results of the query */ public ScrollableResults scroll() { setMaxCount(); setQueryRunning(true); try { scrollableResults = query.scroll(ScrollMode.FORWARD_ONLY); } finally { setQueryRunning(false); } return scrollableResults; }
/** * @param query * The query. * @param n * The n'th element. * @param logPerformance * True, if the performance should be logged. * @param class1 * @param <T> * Return type of this method. * @return The n'th element or null. */ private <T> T getNthElement(org.hibernate.Query query, int n, boolean logPerformance) { StopWatch stopWatch = new StopWatch(); if (logPerformance) { stopWatch.start(); } query.setMaxResults(n); ScrollableResults scrollableResults = query.scroll(ScrollMode.SCROLL_INSENSITIVE); stopStopWatches(logPerformance, stopWatch, "QueryHelper#query.scroll"); resetAndStartStopWatch(logPerformance, stopWatch); if (scrollableResults.last()) { stopStopWatches(logPerformance, stopWatch, "QueryHelper#scrollableResults.setRowNumber" + n); resetAndStartStopWatch(logPerformance, stopWatch); return (T) scrollableResults.get(0); } return null; }
public ScrollableResults performScroll( QueryParameters queryParameters, SessionImplementor session) throws HibernateException { if ( log.isTraceEnabled() ) { log.trace( "iterate: " + getSourceQuery() ); queryParameters.traceParameters( session.getFactory() ); } if ( translators.length != 1 ) { throw new QueryException( "implicit polymorphism not supported for scroll() queries" ); } if ( queryParameters.getRowSelection().definesLimits() && translators[0].containsCollectionFetches() ) { throw new QueryException( "firstResult/maxResults not supported in conjunction with scroll() of a query containing collection fetches" ); } return translators[0].scroll( queryParameters, session ); }
public ScrollableResults scroll(CriteriaImpl criteria, ScrollMode scrollMode) { errorIfClosed(); checkTransactionSynchStatus(); String entityName = criteria.getEntityOrClassName(); CriteriaLoader loader = new CriteriaLoader( getOuterJoinLoadable(entityName), factory, criteria, entityName, getEnabledFilters() ); autoFlushIfRequired( loader.getQuerySpaces() ); dontFlushFromFind++; try { return loader.scroll(this, scrollMode); } finally { dontFlushFromFind--; } }
public ScrollableResults scrollCustomQuery(CustomQuery customQuery, QueryParameters queryParameters) throws HibernateException { errorIfClosed(); checkTransactionSynchStatus(); if ( log.isTraceEnabled() ) { log.trace( "scroll SQL query: " + customQuery.getSQL() ); } CustomLoader loader = new CustomLoader( customQuery, getFactory() ); autoFlushIfRequired( loader.getQuerySpaces() ); dontFlushFromFind++; //stops flush being called multiple times if this method is recursively called try { return loader.scroll(queryParameters, this); } finally { dontFlushFromFind--; } }
public void testScrollCriteria() { Session session = openSession(); Transaction t = session.beginTransaction(); Course course = new Course(); course.setCourseCode("HIB"); course.setDescription("Hibernate Training"); session.persist(course); session.flush(); session.clear(); ScrollableResults sr = session.createCriteria(Course.class).scroll(); assertTrue( sr.next() ); course = (Course) sr.get(0); assertNotNull(course); sr.close(); session.delete(course); t.commit(); session.close(); }
private void cacheExistingStringClassIdentities() throws Exception { Logger.getLogger(getClass()).info("Loading String Class Identities"); final Session session = getService().getEntityManager().unwrap(Session.class); final org.hibernate.Query hQuery = session .createSQLQuery("select id, name, language from string_class_identity"); hQuery.setReadOnly(true).setFetchSize(100000).setCacheable(false); final ScrollableResults results = hQuery.scroll(ScrollMode.FORWARD_ONLY); while (results.next()) { final Long id = ((BigInteger) results.get()[0]).longValue(); final String name = (String) results.get()[1]; final String language = (String) results.get()[2]; final String identityCode = name + language; stringClassIdentityCache.put(identityCode, id); } results.close(); }
private void cacheExistingLexicalClassIdentities() throws Exception { Logger.getLogger(getClass()).info("Loading Lexical Class Identities"); final Session session = getService().getEntityManager().unwrap(Session.class); final org.hibernate.Query hQuery = session.createSQLQuery( "select id, language, normalizedName from lexical_class_identity"); hQuery.setReadOnly(true).setFetchSize(100000).setCacheable(false); final ScrollableResults results = hQuery.scroll(ScrollMode.FORWARD_ONLY); while (results.next()) { final Long id = ((BigInteger) results.get()[0]).longValue(); final String language = (String) results.get()[1]; final String normalizedName = (String) results.get()[2]; final String identityCode = language + normalizedName; lexicalClassIdentityCache.put(identityCode, id); } results.close(); }
@SuppressWarnings("unchecked") @Override protected <T extends OriannaObject<?>> List<T> doGetAll(final Class<T> type) { final Class<? extends OriannaDto> clazz = getDtoClass(type); final ScrollableResults result = hibernateGetAll(clazz); if(result == null) { return Collections.emptyList(); } try { final List<T> response = new ArrayList<>(); while(result.next()) { response.add((T)type.getDeclaredConstructors()[0].newInstance(result.get(0))); } result.close(); return response; } catch(InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | SecurityException e) { throw new OriannaException("Couldn't load data from DB"); } }
private static void runStatelessHql() throws Exception { Stopwatch watch = Stopwatch.createStarted(); StatelessSession statelessSession = sessionFactory.openStatelessSession(); try { statelessSession.getTransaction().begin(); Query query = statelessSession .createQuery( " SELECT d.id, d.firstName, d.lastName, c.id, c.make " + " FROM Driver d " + " LEFT JOIN d.cars c WHERE index(c) LIKE 'Good'").setFetchSize(0).setReadOnly(true); ScrollableResults scroll = query.scroll(ScrollMode.FORWARD_ONLY); while (scroll.next()) { LOG.info("Entry " + scroll.get(0)); } statelessSession.getTransaction().commit(); } catch (Exception ex) { statelessSession.getTransaction().rollback(); throw ex; } finally { statelessSession.close(); } LOG.info("StatelessHql:=" + watch.toString()); }
/** * @param request * @return * @see edu.utah.further.core.chain.AbstractRequestHandler#process(edu.utah.further.core.api.chain.ChainRequest) */ @Override public boolean process(final ChainRequest request) { final QueryExecutionRequest executionRequest = new QueryExecutionRequest(request); final GenericCriteria criteria = executionRequest.getResult(); final ScrollableResults results = getResultListFromHibernate(criteria); executionRequest.setResult(results); executionRequest.setStatus("Executed query @ " + TimeService.getDate()); // Hibernate's ScrollableResults interface has no hasNext() or peek(), so go one // row forward (if exists) and then back all the way so that we don't miss the // first row in subsequent processors final boolean hasNext = results.next(); if (hasNext) { results.previous(); } return hasNext; }
/** * Execute Hibernate criteria query and return a scrollable result set. * * @param criteria * Hibernate criteria * @return scrollable result set * @see https://jira.chpc.utah.edu/browse/FUR-1274 */ @HibernateExecutor private ScrollableResults getResultListFromHibernate(final GenericCriteria criteria) { ScrollableResults results = null; // Need to use INSENSITIVE scroll-mode per FUR-1300 and // http://www.coderanch.com/t/301684/JDBC/java/Unsupported-syntax-refreshRow final ScrollMode scrollMode = ScrollMode.SCROLL_INSENSITIVE; try { results = criteria.setCacheMode(CacheMode.IGNORE).scroll(scrollMode); } catch (final HibernateException e) { log.error("An exception occurred while scrolling results", e); } // Normally we won't know up-front the size of a streaming result set. But for // easier debugging of the subsequent paging sub-chain, print out the size of the // list because we know it already in this case. if (log.isDebugEnabled()) { log.debug("Result set = " + StringUtil.getNullSafeToString(results)); } return results; }
/** * {@inheritDoc} */ @Override public void createDesignDetails(ArrayDesign arrayDesign) throws PlatformFileReadException { final Map<String, LogicalProbe> logicalProbes = new HashMap<String, LogicalProbe>(); int count = 0; try { final ArrayDesignDetails details = new ArrayDesignDetails(); arrayDesign.setDesignDetails(details); getArrayDao().save(arrayDesign); getArrayDao().save(details); final ScrollableResults results = loadRows(this.fileOnDisk); count = loadProbes(details, logicalProbes, results); arrayDesign.setNumberOfFeatures(count); } catch (final IOException e) { LOG.error("Error processing line " + count); throw new PlatformFileReadException(this.fileOnDisk, "Couldn't read file: ", e); } finally { this.hibernateHelper.getCurrentSession().createSQLQuery("DROP TABLE " + TEMP_TABLE_NAME + ";") .executeUpdate(); } }
private int loadProbes(ArrayDesignDetails details, Map<String, LogicalProbe> logicalProbes, ScrollableResults results) throws IOException { int count = 0; results.beforeFirst(); String lastSeqId = null; while (results.next()) { final Object[] values = results.get(); final Map<String, Object> vals = new HashMap<String, Object>(); vals.put(PROBE_ID, values[0]); vals.put(SEQ_ID, values[1]); vals.put(CONTAINER2, values[2]); vals.put(X, values[3]); vals.put(Y, values[4]); if (lastSeqId != null && !vals.get(SEQ_ID).equals(lastSeqId)) { logicalProbes.clear(); flushAndClearSession(); } lastSeqId = (String) vals.get(SEQ_ID); final PhysicalProbe p = createPhysicalProbe(details, vals, logicalProbes); getArrayDao().save(p); ++count; } return count; }