EDIT

import eu.etaxonomy.cdm.persistence.dto.ClassificationLookupDTO;

    @Override

    public ClassificationLookupDTO classificationLookup(Classification classification) {

        ClassificationLookupDTO classificationLookupDTO = new ClassificationLookupDTO(classification);

        // only for debugging:

//        logger.setLevel(Level.TRACE);

//        Logger.getLogger("org.hibernate.SQL").setLevel(Level.DEBUG);

        String hql = "select t.id, n.rank, tp.id from TaxonNode as tn join tn.classification as c join tn.taxon as t join t.name as n "

                + " left join tn.parent as tnp left join tnp.taxon as tp "

                + " where c = :classification";

        Query query = getSession().createQuery(hql);

        query.setParameter("classification", classification);

        @SuppressWarnings("unchecked")

        List<Object[]> result = query.list();

        for(Object[] row : result) {

            Integer parentId = null;

//            if(row.length == 3) { // TODO check necessary?

//                parentId = (Integer) row[2];

//            }

            classificationLookupDTO.add((Integer)row[0], (Rank)row[1], parentId);

        }

        return classificationLookupDTO ;

    }

import eu.etaxonomy.cdm.persistence.dto.ClassificationLookupDTO;

    public Long countChildrenOf(Taxon taxon, Classification classification);

    public ClassificationLookupDTO classificationLookup(Classification classification);

// $Id$

/**

* Copyright (C) 2015 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.persistence.dto;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;

import eu.etaxonomy.cdm.model.name.Rank;

import eu.etaxonomy.cdm.model.taxon.Classification;

/**

 * @author a.kohlbecker

 * @date Sep 3, 2015

 *

 */

public class ClassificationLookupDTO {

    private final Map<Integer, Integer> taxonIdToParentId = new HashMap<Integer, Integer>();

    private final Map<Rank,Collection<Integer>> taxonIdByRank = new HashMap<Rank, Collection<Integer>>();

    private final Map<Integer,Collection<Integer>> childTaxonMap = new HashMap<Integer,Collection<Integer>>();

    private Classification classification = null;

    /**

     * @return the taxonIds

     */

    public Set<Integer> getTaxonIds() {

        return taxonIdToParentId.keySet();

    }

    /**

     * @return the taxonIdByRank

     */

    public Map<Rank, Collection<Integer>> getTaxonIdByRank() {

        return taxonIdByRank;

    }

    /**

     * @return the childTaxonMap

     */

    public Map<Integer, Collection<Integer>> getChildTaxonMap() {

        return childTaxonMap;

    }

    /**

     * @return the classification

     */

    public Classification getClassification() {

        return classification;

    }

    /**

     *

     * @param classification

     *      Must never be null the ClassificationLookupDTO always specific to one

     *      Classification.

     */

    public ClassificationLookupDTO(Classification classification) {

        this.classification  = classification;

    }

    public void add(Integer taxonId, Rank rank, Integer parentId) {

        taxonIdToParentId.put(taxonId, parentId);

        if(!childTaxonMap.containsKey(parentId)) {

            childTaxonMap.put(parentId, new HashSet<Integer>());

        }

        childTaxonMap.get(parentId).add(taxonId);

        if(!taxonIdByRank.containsKey(rank)) {

            taxonIdByRank.put(rank, new HashSet<Integer>());

        }

        taxonIdByRank.get(rank).add(taxonId);

    }

    public void dropRank(Rank rank) {

        Collection<Integer> idsForRank = taxonIdByRank.get(rank);

        taxonIdByRank.remove(rank);

        for(Integer taxonId : idsForRank) {

            Integer parentId = taxonIdToParentId.get(taxonId);

            taxonIdToParentId.remove(taxonId);

            childTaxonMap.remove(parentId);

        }

    }

}

import eu.etaxonomy.cdm.persistence.dto.ClassificationLookupDTO;

    @Test

    @DataSet(value="ClassificationDaoHibernateImplTest.listRankSpecificRootNodes.xml")

    public void testClassificationLookup() {

        Classification classification = classificationDao.load(UUID.fromString(CLASSIFICATION_FULL_UUID));

        ClassificationLookupDTO classificationLookupDto = classificationDao.classificationLookup(classification);

        assertEquals(4, classificationLookupDto.getTaxonIds().size());

    }

     * @deprecated use {@link #listByIds(Set, Integer, Integer, List, List)} instead

    @Deprecated

    /**

     * @param idSet

     * @param pageSize

     * @param pageNumber

     * @param orderHints

     * @param propertyPaths

     * @return

     */

    List<T> listByIds(Set<Integer> idSet, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints,

            List<String> propertyPaths);

    @Override

    @Transactional(readOnly = true)

    public List<T> listByIds(Set<Integer> idSet, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths){

        return dao.listByIds(idSet, pageSize, pageNumber, orderHints, propertyPaths);

    }

import java.util.Iterator;

import eu.etaxonomy.cdm.model.common.OrderedTermBase;

import eu.etaxonomy.cdm.model.taxon.TaxonBase;

import eu.etaxonomy.cdm.persistence.dao.taxon.IClassificationDao;

import eu.etaxonomy.cdm.persistence.dto.ClassificationLookupDTO;

    protected static final List<String> TAXONDESCRIPTION_INIT_STRATEGY = Arrays.asList(new String [] {

            "description.markers.markerType",

            "description.elements.markers.markerType",

            "description.elements.area",

            "description.elements.sources.citation.authorship",

            "description.elements.sources.nameUsedInSource",

            "description.elements.multilanguageText",

            "name.status.type",

    });

    @Autowired

    private IClassificationDao classificationDao;

        logger.setLevel(Level.INFO); // TRACE will slow down a lot since it forces loading all term representations

        logger.info("Hibernate JDBC Batch size: "

                + ((SessionFactoryImplementor) getSession().getSessionFactory()).getSettings().getJdbcBatchSize());

        Set<Classification> classifications = new HashSet<Classification>();

        if(classification == null) {

            classifications.addAll(classificationService.listClassifications(null, null, null, null));

        } else {

            classifications.add(classification);

        }

        int aggregationWorkTicks = mode.equals(AggregationMode.byAreasAndRanks) ? 400 : 200;

        // take start time for performance testing

        // NOTE: use ONLY_FISRT_BATCH = true to measure only one batch

        double start = System.currentTimeMillis();

        monitor.beginTask("Accumulating distributions", (classifications.size() * aggregationWorkTicks) + 1 );

        for(Classification _classification : classifications) {

            ClassificationLookupDTO classificationLookupDao = classificationDao.classificationLookup(_classification);

            monitor.subTask("Accumulating distributions to super areas for " + _classification.getTitleCache());

            if (mode.equals(AggregationMode.byAreas) || mode.equals(AggregationMode.byAreasAndRanks)) {

                accumulateByArea(superAreas, classificationLookupDao, new SubProgressMonitor(monitor, 200),

                        mode.equals(AggregationMode.byAreas) || mode.equals(AggregationMode.byAreasAndRanks));

            }

            monitor.subTask("Accumulating distributions to higher ranks for " + _classification.getTitleCache());

            double end1 = System.currentTimeMillis();

            logger.info("Time elapsed for accumulateByArea() : " + (end1 - start) / (1000) + "s");

            double start2 = System.currentTimeMillis();

            if (mode.equals(AggregationMode.byRanks) || mode.equals(AggregationMode.byAreasAndRanks)) {

                accumulateByRank(lowerRank, upperRank, classification, new SubProgressMonitor(monitor, 200),

                        mode.equals(AggregationMode.byRanks));

            }

            double end2 = System.currentTimeMillis();

            logger.info("Time elapsed for accumulateByRank() : " + (end2 - start2) / (1000) + "s");

            logger.info("Time elapsed for accumulate(): " + (end2 - start) / (1000) + "s");

            if(ONLY_FISRT_BATCH) {

                break;

            }

        }

     * @param classificationLookupDao

     *

    protected void accumulateByArea(List<NamedArea> superAreas, ClassificationLookupDTO classificationLookupDao,  IProgressMonitor subMonitor, boolean doClearDescriptions) {

        subMonitor.beginTask("Accumulating by area ",  classificationLookupDao.getTaxonIds().size());

        Iterator<Integer> taxonIdIterator = classificationLookupDao.getTaxonIds().iterator();

        while (taxonIdIterator.hasNext()) {

            // load taxa for this batch

            List<TaxonBase> taxa = new ArrayList<TaxonBase>(batchSize);

            Set<Integer> taxonIds = new HashSet<Integer>(batchSize);

            while(taxonIdIterator.hasNext() && taxonIds.size() < batchSize ) {

                taxonIds.add(taxonIdIterator.next());

//            logger.debug("accumulateByArea() - taxon " + taxonPager.getFirstRecord() + " to " + taxonPager.getLastRecord() + " of " + taxonPager.getCount() + "]");

            taxa = taxonService.listByIds(taxonIds, null, null, null, TAXONDESCRIPTION_INIT_STRATEGY);

            for(TaxonBase taxon : taxa) {

                    logger.debug("accumulateByArea() - taxon :" + taxonToString(taxon));

                TaxonDescription description = findComputedDescription((Taxon)taxon, doClearDescriptions);

                List<Distribution> distributions = distributionsFor((Taxon)taxon);

                    // TODO consider using the TermHierarchyLookup (only in local branch a.kohlbecker)

                            logger.trace("accumulateByArea() - \t\t" + termToString(subArea));

                                    logger.trace("accumulateByArea() - \t\t" + termToString(subArea) + ": " + termToString(status));

                            logger.debug("accumulateByArea() - \t >> " + termToString(superArea) + ": " + termToString(accumulatedStatus));

    /**

     * @param taxon

     * @param logger2

     * @return

     */

    private String taxonToString(TaxonBase taxon) {

        if(logger.isTraceEnabled()) {

            return taxon.getTitleCache();

        } else {

            return taxon.toString();

        }

    }

    /**

     * @param taxon

     * @param logger2

     * @return

     */

    private String termToString(OrderedTermBase<?> term) {

        if(logger.isTraceEnabled()) {

            return term.getLabel() + " [" + term.getIdInVocabulary() + "]";

        } else {

            return term.getIdInVocabulary();

        }

    }

                logger.debug("accumulateByRank() - at Rank '" + termToString(rank) + "'");

                                logger.debug("accumulateByRank() - skipping already processed taxon :" + taxonToString(taxon));

                            logger.debug("accumulateByRank() [" + rank.getLabel() + "] - taxon :" + taxonToString(taxon));

                                logger.trace("                   subtaxon :" + taxonToString(subTaxonNode.getTaxon()));

        List<Distribution> distributions = new ArrayList<Distribution>();

        for(TaxonDescription description: taxon.getDescriptions()) {

            for(DescriptionElementBase deb : description.getElements()) {

                if(deb instanceof Distribution) {

                    distributions.add((Distribution)deb);

                }

            }

        }

        return distributions;