Java 类org.hibernate.ScrollableResults 实例源码

@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 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();
    }
}

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;
}