EDIT

    public List<TaxonBase> getTaxaByName(boolean doTaxa, boolean doSynonyms, String queryString, MatchMode matchMode,

            Integer pageSize, Integer pageNumber) {

    }

    @Override

    }

    @Override

            boolean includeAuthors,

            String queryString, Classification classification,

            MatchMode matchMode, Set<NamedArea> namedAreas, NameSearchOrder order,

        boolean doCount = false;

        String searchField = includeAuthors ? "titleCache" : "nameCache";

        if (query != null){

            @SuppressWarnings("unchecked")

    //new search for the editor, for performance issues the return values are only uuid and titleCache, to avoid the initialisation of all objects

    @Override

    @SuppressWarnings("unchecked")

            MatchMode matchMode, Set<NamedArea> namedAreas) {

//        long zstVorher;

//        long zstNachher;

        			resultObjects.add(new UuidAndTitleCache(TaxonNameBase.class, name.getUuid(), name.getId(), name.getTitleCache()));

        		}

        	}

        		return resultObjects;

        	}

        }

        if (query != null){

                //differentiate taxa and synonyms

                // new Boolean(result[3].toString()) is due to the fact that result[3] could be a Boolean ora String

                // see FIXME in 'prepareQuery' for more details

                    if (result[3].equals("synonym")) {

                        resultObjects.add( new UuidAndTitleCache(Synonym.class, (UUID) result[0], (Integer) result[1], (String)result[2], new Boolean(result[4].toString()), null));

                    }

                    else {

                        resultObjects.add( new UuidAndTitleCache(Taxon.class, (UUID) result[0], (Integer) result[1], (String)result[2], new Boolean(result[4].toString()), null));

                    }

                }else if (doSynonyms){

                    resultObjects.add( new UuidAndTitleCache(Synonym.class, (UUID) result[0], (Integer) result[1], (String)result[2], new Boolean(result[4].toString()), null));

                }

     *

     *

     */

            String searchField, String queryString, Classification classification,

            MatchMode matchMode, Set<NamedArea> namedAreas, boolean doCount, NameSearchOrder order) {

                classification, matchMode, namedAreas, order, doCount, true);

    }

     * @param clazz

     * @return

     */

                Classification classification, MatchMode matchMode, Set<NamedArea> namedAreas, NameSearchOrder order, boolean doCount, boolean doNotReturnFullEntities){

            if (order == null){

                selectWhat = (doCount ? "count(t)": "t");

            }

            String hql = "";

            Set<NamedArea> areasExpanded = new HashSet<NamedArea>();

            if(namedAreas != null && namedAreas.size() > 0){

            String taxonSubselect = subSelects[1];

            String synonymSubselect = subSelects[2];

            String misappliedSelect = subSelects[0];

            logger.debug("taxonSubselect: " + taxonSubselect != null ? taxonSubselect: "NULL");

            Query subTaxon = null;

            Query subSynonym = null;

            Query subMisappliedNames = null;

            if(doTaxa){

                // find Taxa

                subTaxon = getSession().createQuery(taxonSubselect).setParameter("queryString", hqlQueryString);

                }

            }

            List<Integer> taxa = new ArrayList<Integer>();

            List<Integer> synonyms = new ArrayList<Integer>();

            if (doSynonyms){

            if (doIncludeMisappliedNames){

                taxa.addAll(subMisappliedNames.list());

            }

            //FIXME : the fourth element of the result should be a boolean, but in the case of a synonym

            // (which does require a check) a constant boolean (false) value needs to set. It seems that

                } else{

                    hql = "select " + selectWhat + " from %s t";

                }

                if  (taxa.size()>0){

                    hql = "select " + selectWhat;

                    // in doNotReturnFullEntities mode it is nesscary to also return the type of the matching entities:

     *

     * FIXME implement classification restriction & implement test: see {@link TaxonDaoHibernateImplTest#testCountTaxaByName()}

     */

            Classification classification, MatchMode matchMode, Set<NamedArea> namedAreas, NameSearchOrder order, Integer pageSize, Integer pageNumber, boolean doCount) {

        if(pageSize != null &&  !doCount && query != null) {

            query.setMaxResults(pageSize);

    private Query prepareTaxaByCommonName(String queryString, Classification classification,

            MatchMode matchMode, Set<NamedArea> namedAreas, Integer pageSize, Integer pageNumber, boolean doCount, boolean doNotReturnFullEntities){

        if (doNotReturnFullEntities){

        	what += " t.uuid, t.id, t.titleCache, \'taxon\', case when t.taxonNodes is empty and t.relationsFromThisTaxon is empty and t.relationsToThisTaxon is empty then true else false end ";

        }else {

    }

    @Override

            boolean doIncludeAuthors, String queryString, Classification classification,

        MatchMode matchMode, Set<NamedArea> namedAreas) {

        */

        String searchField = doIncludeAuthors ? "titleCache": "nameCache";

        if (query != null) {

            return (Long)query.uniqueResult();

        }else{

    public List<TaxonBase> findByNameTitleCache(boolean doTaxa, boolean doSynonyms, String queryString, Classification classification, MatchMode matchMode, Set<NamedArea> namedAreas, NameSearchOrder order, Integer pageNumber, Integer pageSize, List<String> propertyPaths) {

        boolean doCount = false;

        if (query != null){

            List<TaxonBase> results = query.list();

            defaultBeanInitializer.initializeAll(results, propertyPaths);

                " left join rt.name as n2" +

                " left join rft.type as rtype";

           String doClassificationWhere = " tn.classification = :classification";

           String doClassificationForMisappliedNamesWhere = " tn2 .classification = :classification";

           String doAreaRestrictionWhere =  " e.area.uuid in (:namedAreasUuids)";

           String doSearchFieldWhere = "%s." + searchField +  " " + matchMode.getMatchOperator() + " :queryString";

        String taxonSubselect = null;

        String synonymSubselect = null;

        String misappliedSelect = null;

        if(classification != null ){

            if (!doIncludeMisappliedNames){

                    " WHERE " + doAreaRestrictionWhere +

                    " AND " + doClassificationWhere +

                    " AND " + String.format(doSearchFieldWhere, "sn");

                } else {

                    taxonSubselect = String.format(doTaxonSubSelect, "t" )+ doTaxonNameJoin +

                    " WHERE " + doClassificationWhere +

                    synonymSubselect = String.format(doTaxonSubSelect, "s" ) + doSynonymNameJoin +

                    " WHERE " + doClassificationWhere +

                    " AND " + String.format(doSearchFieldWhere, "sn");

                }

            }else{ //misappliedNames included

                if(doAreaRestriction){

                    " WHERE " + doAreaRestrictionWhere +

                    " AND " + String.format(doSearchFieldWhere, "n") +

                    " AND " + doClassificationForMisappliedNamesWhere +

                    synonymSubselect = String.format(doAreaRestrictionSubSelect, "s") + doSynonymNameJoin +

                    " WHERE " + doAreaRestrictionWhere +

                } else {

                    misappliedSelect = String.format(doTaxonMisappliedNameSubSelect, "t" ) + doTaxonNameJoin + doMisappliedNamesJoin +

                    " WHERE " + String.format(doSearchFieldWhere, "n") +

                    " WHERE " + doClassificationWhere +

                    " AND " +  String.format(doSearchFieldWhere, "sn");

                }

            }

        } else {

                synonymSubselect = String.format(doAreaRestrictionSubSelect, "s") + doSynonymNameJoin +

                " WHERE " +   doAreaRestrictionWhere +

                " AND " +  String.format(doSearchFieldWhere, "sn");

            } else {

                misappliedSelect = String.format(doTaxonMisappliedNameSubSelect, "t" ) + doTaxonNameJoin + doMisappliedNamesJoin + " WHERE " +  String.format(doSearchFieldWhere, "n") + " AND " + doRelationshipTypeComparison;

                taxonSubselect = String.format(doTaxonSubSelect, "t" ) + doTaxonNameJoin + " WHERE " +  String.format(doSearchFieldWhere, "n");

                synonymSubselect = String.format(doTaxonSubSelect, "s" ) + doSynonymNameJoin + " WHERE " +  String.format(doSearchFieldWhere, "sn");

            }

        }

        return result;

    }

     * @param propertyPaths TODO

     * @return list of found taxa

     */

            boolean includeAuthors, String queryString, Classification classification,

            MatchMode matchMode, Set<NamedArea> namedAreas,

            NameSearchOrder order, Integer pageSize, Integer pageNumber, List<String> propertyPaths);

     * @param propertyPaths

     * @return

     */

            boolean doIncludeAuthors, String queryString, Classification classification,

            MatchMode matchMode, Set<NamedArea> namedAreas);

    public List<TaxonNameBase> findIdenticalNamesNew(List <String> propertyPaths);

    public List<UuidAndTitleCache<IdentifiableEntity>> getTaxaByNameForEditor(boolean doTaxa, boolean doSynonyms, boolean doNamesWithoutTaxa,

            String queryString, Classification classification,

            MatchMode matchMode, Set<NamedArea> namedAreas);

         * Misapplied names should be found regardless of whether they are contained in a classification or not.

         */

        //two accepted taxa starting with R in classification "TestBaum"

        Assert.assertEquals("There should be 2 Taxa", 2, results.size());

        //three taxa, 2 accepted and 1 misapplied name starting with R

        Assert.assertEquals("There should be 3 Taxa", 3, results.size());

        //one synonym has no accepted taxon

        Assert.assertEquals("There should be 11 Taxa",11, results.size());

        //two accepted taxa in classification and 1 misapplied name with accepted name in classification

        Assert.assertEquals("There should be 3 Taxa", 3, results.size());

        //same as above because all taxa, synonyms and misapplied names starting with R are in the classification

        Assert.assertEquals("There should be 3 Taxa", 3, results.size());

        //find misapplied names with accepted taxon in the classification, the accepted taxa of two misapplied names are in the classification

        Assert.assertEquals("There should be 2 Taxa", 2, results.size());

        //find misapplied names beginning with R

        Assert.assertEquals("There should be 1 Taxa", 1, results.size());

        //find all three misapplied names

        Assert.assertEquals("There should be 3 Taxa", 3, results.size());

    }

        Reference sec = referenceDao.findById(1);

        assert sec != null : "sec must exist";

        assertNotNull("getTaxaByName should return a List", results);

        assertFalse("The list should not be empty", results.isEmpty());

        assertEquals(4, results.size());

        assertNotNull("getTaxaByName should return a List", results);

        assertEquals(7, results.size());

        assertNotNull("getTaxaByName should return a List", results);

        assertEquals(5, results.size());

        assertEquals(results.get(0).getType(), Taxon.class);

        assertNotNull("getTaxaByName should return a List", results);

        assertEquals(2, results.size());

        assertEquals(results.get(0).getType(), Synonym.class);

        assertNotNull("getTaxaByName should return a List", results);

        assertEquals("Results list should contain one entity",1,results.size());

        assertNotNull("getTaxaByName should return a List", results);

        assertEquals("Results list should contain one entity", 8, results.size());

        // 1. searching for a taxon (Rethera)

        //long numberOfTaxa = taxonDao.countTaxaByName(Taxon.class, "Rethera", null, MatchMode.BEGINNING, namedAreas);

            null, null, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        assertTrue("expected to find two taxa but found "+results.size(), results.size() == 2);

        // 2. searching for a taxon (Rethera) contained in a specific classification

            null, null, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        assertTrue("expected to find one taxon but found "+results.size(), results.size() == 1);

        // 3. searching for Synonyms

            null, null, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        /*System.err.println(results.get(0).getTitleCache() + " - " +results.get(1).getTitleCache() + " - " +results.get(2).getTitleCache() );

        assertTrue("expected to find three taxa but found "+results.size(), results.size() == 3);

        // 4. searching for Synonyms

            null, null, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        assertTrue("expected to find three taxa but found "+results.size(), results.size() == 3);

        // 5. searching for a Synonyms and Taxa

            null, null, null, null);

        //only five taxa have a distribution

        assertNotNull("getTaxaByName should return a List", results);

        int numberOfClassifications = classificationDao.count();

        List<String> propertyPaths = new ArrayList<>();

        propertyPaths.add("taxonNodes");

        Taxon taxon = (Taxon)taxa.get(0);

        Set<TaxonNode> nodes = taxon.getTaxonNodes();

        assertTrue(nodes.size() == 1);

    @Test

    @DataSet

    public void testCountTaxaByName() {

        assertEquals(5, numberOfTaxa);

        assertEquals(1, numberOfTaxa);

        assertEquals(2, numberOfTaxa);

        assertEquals(7, numberOfTaxa);

        assertEquals(0, numberOfTaxa);

//	FIXME implement test for search in specific classification

//		Reference reference = referenceDao.findByUuid(UUID.fromString("596b1325-be50-4b0a-9aa2-3ecd610215f2"));

        assertFalse("the list should not be empty", commonNameResults.isEmpty());

        assertEquals("There should be one Taxon with common name", 1,commonNameResults.size());

        assertEquals(" sec. ???", ((TaxonBase)commonNameResults.get(0)).getTitleCache());

    }

    @Test

  <DESCRIPTIONELEMENTBASE DTYPE="TextData" ID="36" INDESCRIPTION_ID="2" CREATED="2008-12-10 09:56:07.0" UUID="c1e21ed1-4925-4e85-845f-e4b7a8386a33" UPDATED="2008-12-10 09:56:07.253" AREA_ID="[null]" STATUS_ID="[null]" FEATURE_ID="936" NAME="[null]"/>

  <DESCRIPTIONELEMENTBASE DTYPE="Distribution" ID="37" INDESCRIPTION_ID="34" CREATED="2008-12-10 09:56:07.0" UUID="c47cd33c-0fac-4ed2-83f1-27f83fdb4657" UPDATED="2008-12-10 09:56:07.253" AREA_ID="1970" STATUS_ID="1994" FEATURE_ID="936" NAME="[null]"/>

  <DESCRIPTIONELEMENTBASE DTYPE="CommonTaxonName" ID="38" INDESCRIPTION_ID="1" CREATED="2008-12-10 09:56:07.0" UUID="a837f822-30d6-4891-b917-cedd642ba919" UPDATED="2008-12-10 09:56:07.253" AREA_ID="[null]" STATUS_ID="[null]" FEATURE_ID="933" NAME="common name"/>

  <DESCRIPTIONELEMENTBASE_LANGUAGESTRING TEXTDATA_ID="34" MULTILANGUAGETEXT_ID="1" MULTILANGUAGETEXT_MAPKEY_ID="406"/>

  <DESCRIPTIONELEMENTBASE_LANGUAGESTRING TEXTDATA_ID="35" MULTILANGUAGETEXT_ID="2" MULTILANGUAGETEXT_MAPKEY_ID="406"/>

import org.apache.log4j.Logger;

import org.apache.lucene.index.CorruptIndexException;

import org.apache.lucene.queryparser.classic.ParseException;

import org.apache.lucene.search.BooleanClause.Occur;

import org.apache.lucene.search.BooleanQuery;

import org.apache.lucene.search.BooleanQuery.Builder;

        List<UuidAndTitleCache<IdentifiableEntity>> results = new ArrayList<UuidAndTitleCache<IdentifiableEntity>>();

        }

        return results;

    }

        }

            if(configurator.getPageSize() != null){ // no point counting if we need all anyway

                numberTaxaResults =

                    dao.countTaxaByName(configurator.isDoTaxa(),configurator.isDoSynonyms(), configurator.isDoMisappliedNames(),

                        configurator.getClassification(), configurator.getMatchMode(),

                        configurator.getNamedAreas());

            }

            if(configurator.getPageSize() == null || numberTaxaResults > configurator.getPageSize() * configurator.getPageNumber()){ // no point checking again if less results

                taxa = dao.getTaxaByName(configurator.isDoTaxa(), configurator.isDoSynonyms(),

                    configurator.getTitleSearchStringSqlized(), configurator.getClassification(),

                    configurator.getMatchMode(), configurator.getNamedAreas(), configurator.getOrder(),

                    configurator.getPageSize(), configurator.getPageNumber(), propertyPath);

        // Taxa from common names

       return new DefaultPagerImpl<>

            (configurator.getPageNumber(), numberOfResults, configurator.getPageSize(), results);

            byCommonNameSearch.setCdmTypRestriction(Taxon.class);

            byCommonNameSearch.setQuery(byCommonNameJoinQuery);

            byCommonNameSearch.setSortFields(sortFields);

            idFieldMap.put(CdmBaseType.TAXON, "id");

            luceneSearches.add(byCommonNameSearch);

    @Override

    public List<TaxonBase> findTaxaByName(MatchingTaxonConfigurator config){

        return taxonList;

    }

        Assert.assertEquals("Expecting 1 entity", 1, pager.getCount().intValue());

        //FIXME FAILS: abies balamea is returned twice, see also testFullText_Grouping()

        logSearchResults(pager, Level.DEBUG, null);

        Assert.assertEquals("expecting to find the Abies balsamea via the GERMAN DescriptionElements", 1, pager.getCount().intValue());

  <DESCRIPTIONELEMENTBASE DTYPE="TextData" ID="5002" CREATED="2013-09-23 16:10:04.0" UUID="45dadcf2-ed50-40d9-b3ff-0c34819d2ef5" UPDATED="2013-09-23 16:10:04.569" ORDERRELEVANT="[null]" NAME="[null]" CREATEDBY_ID="[null]" UPDATEDBY_ID="[null]" FEATURE_ID="937" INDESCRIPTION_ID="5000" AREA_ID="[null]" LANGUAGE_ID="[null]" STATUS_ID="[null]" ASSOCIATEDSPECIMENOROBSERVATION_ID="[null]" UNIT_ID="[null]" TAXON2_ID="[null]" FORMAT_ID="[null]"/>

  <DESCRIPTIONELEMENTBASE DTYPE="Distribution" ID="5003" CREATED="2013-09-23 16:10:04.0" UUID="331f9689-0157-4291-bc2b-e287f3c3653e" UPDATED="2013-09-23 16:10:04.584" ORDERRELEVANT="[null]" NAME="[null]" CREATEDBY_ID="[null]" UPDATEDBY_ID="[null]" FEATURE_ID="923" INDESCRIPTION_ID="5000" AREA_ID="705" LANGUAGE_ID="[null]" STATUS_ID="1994" ASSOCIATEDSPECIMENOROBSERVATION_ID="[null]" UNIT_ID="[null]" TAXON2_ID="[null]" FORMAT_ID="[null]"/>

  <DESCRIPTIONELEMENTBASE DTYPE="CommonTaxonName" ID="5004" CREATED="2013-09-23 16:10:04.0" UUID="c5d56f14-4826-4165-b638-4cf8c3d4deb2" UPDATED="2013-09-23 16:10:04.584" ORDERRELEVANT="[null]" NAME="Balsam-Tanne" CREATEDBY_ID="[null]" UPDATEDBY_ID="[null]" FEATURE_ID="933" INDESCRIPTION_ID="5000" AREA_ID="[null]" LANGUAGE_ID="349" STATUS_ID="[null]" ASSOCIATEDSPECIMENOROBSERVATION_ID="[null]" UNIT_ID="[null]" TAXON2_ID="[null]" FORMAT_ID="[null]"/>

  <DESCRIPTIONELEMENTBASE DTYPE="CommonTaxonName" ID="5005" CREATED="2013-09-23 16:10:04.0" UUID="fc8a41af-e4e7-49e6-8fae-89d215108852" UPDATED="2013-09-23 16:10:04.585" ORDERRELEVANT="[null]" NAME="&#1041;&#1072;&#1083;&#1100;&#1079;&#1072;&#1084; &#1085;&#1100;&#1099;&#1074;" CREATEDBY_ID="[null]" UPDATEDBY_ID="[null]" FEATURE_ID="933" INDESCRIPTION_ID="5000" AREA_ID="[null]" LANGUAGE_ID="229" STATUS_ID="[null]" ASSOCIATEDSPECIMENOROBSERVATION_ID="[null]" UNIT_ID="[null]" TAXON2_ID="[null]" FORMAT_ID="[null]"/>

  <DESCRIPTIONELEMENTBASE DTYPE="Distribution" ID="5006" CREATED="2013-09-23 16:10:04.0" UUID="130db0d0-4d4d-410c-87af-7b904dfa43b6" UPDATED="2013-09-23 16:10:04.589" ORDERRELEVANT="[null]" NAME="[null]" CREATEDBY_ID="[null]" UPDATEDBY_ID="[null]" FEATURE_ID="923" INDESCRIPTION_ID="5001" AREA_ID="664" LANGUAGE_ID="[null]" STATUS_ID="1993" ASSOCIATEDSPECIMENOROBSERVATION_ID="[null]" UNIT_ID="[null]" TAXON2_ID="[null]" FORMAT_ID="[null]"/>

  <DESCRIPTIONELEMENTBASE DTYPE="Distribution" ID="5007" CREATED="2013-09-23 16:10:04.0" UUID="b01a427a-01c9-4f04-82a5-ca886b7ae6a8" UPDATED="2013-09-23 16:10:04.6" ORDERRELEVANT="[null]" NAME="[null]" CREATEDBY_ID="[null]" UPDATEDBY_ID="[null]" FEATURE_ID="923" INDESCRIPTION_ID="5001" AREA_ID="566" LANGUAGE_ID="[null]" STATUS_ID="1995" ASSOCIATEDSPECIMENOROBSERVATION_ID="[null]" UNIT_ID="[null]" TAXON2_ID="[null]" FORMAT_ID="[null]"/>