Example usage for org.apache.lucene.search BooleanQuery BooleanQuery

List of usage examples for org.apache.lucene.search BooleanQuery BooleanQuery

Introduction

In this page you can find the example usage for org.apache.lucene.search BooleanQuery BooleanQuery.

Prototype

BooleanQuery

Source Link

Usage

From source file:edu.harvard.iq.dvn.core.index.Indexer.java

License:Apache License

public List search(List<Long> studyIds, List<SearchTerm> searchTerms) throws IOException {
    logger.fine("Start search: " + DateTools.dateToString(new Date(), Resolution.MILLISECOND));
    Long[] studyIdsArray = null;/*from   www. j  ava2s . co  m*/
    if (studyIds != null) {
        studyIdsArray = studyIds.toArray(new Long[studyIds.size()]);
        Arrays.sort(studyIdsArray);
    }
    List<Long> results = null;
    List<BooleanQuery> searchParts = new ArrayList();

    // "study-level search" is our "normal", default search, that is 
    // performed on the study metadata keywords.
    boolean studyLevelSearch = false;
    boolean containsStudyLevelAndTerms = false;

    // We also support searches on variables and file-level metadata:
    // We do have to handle these 2 separately, because of the 2 different
    // levels of granularity: one searches on variables, the other on files.
    boolean variableSearch = false;
    boolean fileMetadataSearch = false;

    // And the boolean below indicates any file-level searche - i.e., 
    // either a variable, or file metadata search.  
    // -- L.A. 
    boolean fileLevelSearch = false;

    List<SearchTerm> studyLevelSearchTerms = new ArrayList();
    List<SearchTerm> variableSearchTerms = new ArrayList();
    List<SearchTerm> fileMetadataSearchTerms = new ArrayList();

    for (Iterator it = searchTerms.iterator(); it.hasNext();) {
        SearchTerm elem = (SearchTerm) it.next();
        logger.fine("INDEXER: processing term; name=" + elem.getFieldName() + "; value=" + elem.getValue());
        if (elem.getFieldName().equals("variable")) {
            //                SearchTerm st = dvnTokenizeSearchTerm(elem);
            //                variableSearchTerms.add(st);
            variableSearchTerms.add(elem);
            variableSearch = true;

        } else if (isFileMetadataField(elem.getFieldName())) {
            fileMetadataSearch = true;
            fileMetadataSearchTerms.add(elem);

        } else {
            //                SearchTerm nvst = dvnTokenizeSearchTerm(elem);
            //                nonVariableSearchTerms.add(nvst);
            if (elem.getOperator().equals("=")) {
                containsStudyLevelAndTerms = true;
            }
            studyLevelSearchTerms.add(elem);
            studyLevelSearch = true;

        }
    }

    // For now we are not supporting searches on variables and file-level
    // metadata *at the same time*. 
    // -- L.A. 

    if (variableSearch && fileMetadataSearch) {
        throw new IOException(
                "Unsupported search term combination! " + "Searches on both variables and file-level metadata "
                        + "at the same time are not supported.");
    }

    if (variableSearch || fileMetadataSearch) {
        fileLevelSearch = true;
    }

    List<Long> nvResults = null;
    List<Long> filteredResults = null;

    // If there are "AND"-type Study-level search terms in the search, 
    // let's run it now:

    if (containsStudyLevelAndTerms) {
        BooleanQuery searchTermsQuery = andSearchTermClause(studyLevelSearchTerms);
        logger.fine("INDEXER: search terms query (native): " + searchTermsQuery.toString());
        searchParts.add(searchTermsQuery);
        BooleanQuery searchQuery = andQueryClause(searchParts);
        logger.fine("Start hits: " + DateTools.dateToString(new Date(), Resolution.MILLISECOND));
        logger.fine("INDEXER: search query (native): " + searchQuery.toString());
        nvResults = getHitIds(searchQuery);
        logger.fine("Done hits: " + DateTools.dateToString(new Date(), Resolution.MILLISECOND));
        logger.fine("Start filter: " + DateTools.dateToString(new Date(), Resolution.MILLISECOND));
        logger.fine("before intersectionResults... studyIds: " + studyIds + " nvResults: " + nvResults);
        filteredResults = studyIds != null ? intersectionResults(nvResults, studyIdsArray) : nvResults;
        logger.fine("after intersectionResults... filteredResults: " + filteredResults);
        logger.fine("Done filter: " + DateTools.dateToString(new Date(), Resolution.MILLISECOND));
    }

    // If there is a file-level portion of the search, we'll run it now, 
    // combining the results with (or, rather filtering them against) the
    // hit list produced by the study-level search above, or supplied to this
    // method as an argument (if any). 
    // IMPORTANT: 
    // do note that this logic assumes that the file-level search can be 
    // EITHER on variables, or on file-level metadata; but never on both. 
    // -- L.A. 

    logger.fine("fileLevelSearch: " + fileLevelSearch);
    if (filteredResults != null) {
        logger.fine("filteredResults.size: " + filteredResults.size());
    }
    logger.fine("containsStudyLevelAndTerms: " + containsStudyLevelAndTerms);
    logger.fine("variableSearch: " + variableSearch);
    if (fileLevelSearch) {
        if (containsStudyLevelAndTerms && (filteredResults.size() > 0)) {
            if (variableSearch) {
                logger.fine("Start nonvar search variables: "
                        + DateTools.dateToString(new Date(), Resolution.MILLISECOND));
                results = searchVariables(filteredResults, variableSearchTerms, true); // get var ids
                logger.fine("Done nonvar search variables: "
                        + DateTools.dateToString(new Date(), Resolution.MILLISECOND));
            } else if (fileMetadataSearch) {
                logger.fine("Start file-level metadata search; searching for file ids."
                        + DateTools.dateToString(new Date(), Resolution.MILLISECOND));
                results = searchFileMetadata(filteredResults, fileMetadataSearchTerms, true); // get var ids
                logger.fine("Done searching for file ids, on file-level metadata: "
                        + DateTools.dateToString(new Date(), Resolution.MILLISECOND));
            }
        } else {
            logger.fine("Start file-level metadata search: "
                    + DateTools.dateToString(new Date(), Resolution.MILLISECOND));

            if (studyLevelSearch && !containsStudyLevelAndTerms) {
                if (variableSearch) {
                    results = searchVariables(studyIds, variableSearchTerms, false);
                } else if (fileMetadataSearch) {
                    results = searchFileMetadata(studyIds, fileMetadataSearchTerms, false);
                }
                if (results != null) {
                    studyIdsArray = results.toArray(new Long[results.size()]);
                    Arrays.sort(studyIdsArray);
                }
                BooleanQuery searchQuery = new BooleanQuery();
                List<TermQuery> termQueries = orLongEqSearchTermQueries(results, "id");
                for (Iterator clausesIter = termQueries.iterator(); clausesIter.hasNext();) {
                    TermQuery termQuery = (TermQuery) clausesIter.next();
                    searchQuery.add(termQuery, BooleanClause.Occur.SHOULD);
                }

                for (Iterator it = searchTerms.iterator(); it.hasNext();) {
                    SearchTerm elem = (SearchTerm) it.next();
                    if (!elem.getFieldName().equalsIgnoreCase("variable")
                            && !isFileMetadataField(elem.getFieldName())) {

                        Term term = new Term(elem.getFieldName(), elem.getValue());
                        TermQuery termQuery = new TermQuery(term);
                        if (elem.getOperator().equals("=")) {
                            searchQuery.add(termQuery, BooleanClause.Occur.MUST);
                        } else {
                            searchQuery.add(termQuery, BooleanClause.Occur.MUST_NOT);
                        }
                    }
                }
                List<Long> studyIdResults = getHitIds(searchQuery);

                if (variableSearch) {
                    results = searchVariables(studyIdResults, variableSearchTerms, true); // get var ids
                } else if (fileMetadataSearch) {
                    results = searchFileMetadata(studyIdResults, fileMetadataSearchTerms, true); // get file ids
                }
            } else {
                List<Long> finalResults = filteredResults != null ? filteredResults : studyIds;
                logger.fine(
                        "in else... this was false: (studyLevelSearch && !containsStudyLevelAndTerms) ... finalResults: "
                                + finalResults);
                if (variableSearch) {
                    results = searchVariables(finalResults, variableSearchTerms, true); // get var ids
                } else if (fileMetadataSearch) {
                    results = searchFileMetadata(finalResults, fileMetadataSearchTerms, true); // get file ids
                }
            }
            logger.fine("Done searching on file-level metadata: "
                    + DateTools.dateToString(new Date(), Resolution.MILLISECOND));
        }
    } else {
        results = filteredResults;
    }
    logger.fine("Done search: " + DateTools.dateToString(new Date(), Resolution.MILLISECOND));

    return results;

}

From source file:edu.harvard.iq.dvn.core.index.Indexer.java

License:Apache License

public List searchVariables(List<Long> studyIds, SearchTerm searchTerm) throws IOException {
    BooleanQuery indexQuery = null;/*from w ww . j  a v a 2s  . c  o m*/
    BooleanQuery searchQuery = new BooleanQuery();
    BooleanQuery.setMaxClauseCount(dvnMaxClauseCount);
    if (studyIds != null) {
        searchQuery.add(orIdSearchTermClause(studyIds, "varStudyId"), BooleanClause.Occur.MUST);
    }
    if (searchTerm.getFieldName().equalsIgnoreCase("variable")) {
        indexQuery = buildVariableQuery(searchTerm);
        if (searchTerm.getOperator().equals("=")) {
            searchQuery.add(indexQuery, BooleanClause.Occur.MUST);
        } else {
            searchQuery.add(indexQuery, BooleanClause.Occur.MUST_NOT);
        }
    }
    List<Document> variableResults = getHits(searchQuery);
    List<Long> variableIdResults = getVariableHitIds(variableResults);
    // TODO: 
    // Double-check if the intersectionVarDocResults() below - i.e., filtering
    // the hit list against the list of supplied study ids - is necessary at all. 
    // I would think not - because the study IDs were already added to the
    // search query, above. -- L.A.
    List<Long> finalResults = studyIds != null ? intersectionVarDocResults(variableResults, studyIds)
            : variableIdResults;
    return finalResults;
}

From source file:edu.harvard.iq.dvn.core.index.Indexer.java

License:Apache License

public List searchVariables(List<Long> studyIds, List<SearchTerm> searchTerms, boolean varIdReturnValues)
        throws IOException {
    BooleanQuery searchQuery = new BooleanQuery();
    BooleanQuery.setMaxClauseCount(dvnMaxClauseCount);
    if (studyIds != null) {
        searchQuery.add(orIdSearchTermClause(studyIds, "varStudyId"), BooleanClause.Occur.MUST);
    }/* w w  w  .  jav  a2 s .c o m*/
    for (Iterator it = searchTerms.iterator(); it.hasNext();) {
        SearchTerm elem = (SearchTerm) it.next();
        BooleanQuery indexQuery = null;
        if (elem.getFieldName().equalsIgnoreCase("variable")) {
            indexQuery = buildVariableQuery(elem);
            if (elem.getOperator().equals("=")) {
                searchQuery.add(indexQuery, BooleanClause.Occur.MUST);
            } else {
                searchQuery.add(indexQuery, BooleanClause.Occur.MUST_NOT);
            }
        }
    }
    List<Long> finalResults = null;
    // TODO: 
    // Double-check if the intersection(Var)DocResults() below - i.e., filtering
    // the hit list against the list of supplied study ids - is necessary at all. 
    // I would think not - because the study IDs were already added to the
    // search query, above. -- L.A.
    if (varIdReturnValues) {
        List<Document> variableResults = getHits(searchQuery);
        List<Long> variableIdResults = getVariableHitIds(variableResults);
        finalResults = studyIds != null ? intersectionVarDocResults(variableResults, studyIds)
                : variableIdResults;
    } else {
        List<Long> studyIdResults = getVariableHitStudyIds(searchQuery); // gets the study ids
        finalResults = studyIds != null ? intersectionResults(studyIdResults, studyIds) : studyIdResults;
    }
    return finalResults;
}

From source file:edu.harvard.iq.dvn.core.index.Indexer.java

License:Apache License

public List searchFileMetadata(List<Long> studyIds, List<SearchTerm> searchTerms, boolean fileIdReturnValues)
        throws IOException {
    BooleanQuery searchQuery = new BooleanQuery();
    BooleanQuery.setMaxClauseCount(dvnMaxClauseCount);
    if (studyIds != null) {
        searchQuery.add(orIdSearchTermClause(studyIds, "id"), BooleanClause.Occur.MUST);
    }//from   ww  w .  j  av a2 s  .  c  om
    for (Iterator it = searchTerms.iterator(); it.hasNext();) {
        SearchTerm elem = (SearchTerm) it.next();
        BooleanQuery indexQuery = null;
        // Determine if this is a file-level metadata search term:
        if (isFileMetadataField(elem.getFieldName())) {
            indexQuery = buildFileMetadataQuery(elem);
            logger.fine("INDEXER: filemetadata element query (native): " + indexQuery.toString());
            if (elem.getOperator().equals("=")) {
                // We only support "=" on file metadata, for now, anyway. 
                // -- L.A. 
                searchQuery.add(indexQuery, BooleanClause.Occur.MUST);
            } else {
                searchQuery.add(indexQuery, BooleanClause.Occur.MUST_NOT);
            }
        }
    }

    logger.fine("INDEXER: filemetadata combined query (native): " + searchQuery.toString());

    List<Long> finalResults = null;
    // TODO: 
    // Double-check if the intersection(File)DocResults() below - i.e., filtering
    // the hit list against the list of supplied study ids - is necessary at all. 
    // I would think not - because the study IDs were already added to the
    // search query, above. -- L.A.
    if (fileIdReturnValues) {
        List<Document> fileMetadataResults = getHits(searchQuery);
        List<Long> fileMetadataIdResults = getFileMetadataHitIds(fileMetadataResults);
        finalResults = studyIds != null ? intersectionFileDocResults(fileMetadataResults, studyIds)
                : fileMetadataIdResults;
    } else {
        List<Long> studyIdResults = getFileMetadataHitStudyIds(searchQuery); // gets the study ids
        finalResults = studyIds != null ? intersectionResults(studyIdResults, studyIds) : studyIdResults;
    }
    return finalResults;
}

From source file:edu.harvard.iq.dvn.core.index.Indexer.java

License:Apache License

BooleanQuery orPhraseQuery(List<SearchTerm> orSearchTerms) {
    BooleanQuery orTerms = new BooleanQuery();
    orTerms.setMaxClauseCount(dvnMaxClauseCount);
    for (Iterator it = orSearchTerms.iterator(); it.hasNext();) {
        SearchTerm elem = (SearchTerm) it.next();
        String[] phrase = getPhrase(elem.getValue().toLowerCase().trim());
        if (phrase.length > 1) {
            PhraseQuery phraseQuery = new PhraseQuery();
            phraseQuery.setSlop(10);/*w  ww  . java2  s.co  m*/

            for (int i = 0; i < phrase.length; i++) {
                phraseQuery.add(new Term(elem.getFieldName(), phrase[i].toLowerCase().trim()));
            }
            orTerms.add(phraseQuery, BooleanClause.Occur.SHOULD);
        } else if (phrase.length == 1) {
            //                Term t = new Term(elem.getFieldName(), elem.getValue().toLowerCase().trim());
            logger.fine("INDEXER: orPhraseQuery: search element value: " + phrase[0].toLowerCase().trim());
            Term t = new Term(elem.getFieldName(), phrase[0].toLowerCase().trim());
            logger.fine("INDEXER: orPhraseQuery: term value=" + t.text());
            TermQuery orQuery = new TermQuery(t);
            logger.fine("INDEXER: TermQuery orQuery (native): " + orQuery.toString());
            orTerms.add(orQuery, BooleanClause.Occur.SHOULD);
        }
    }
    return orTerms;
}

From source file:edu.harvard.iq.dvn.core.index.Indexer.java

License:Apache License

BooleanQuery orPhraseOrWildcardQuery(List<SearchTerm> orSearchTerms) {
    BooleanQuery orTerms = new BooleanQuery();
    orTerms.setMaxClauseCount(dvnMaxClauseCount);
    for (Iterator it = orSearchTerms.iterator(); it.hasNext();) {
        SearchTerm elem = (SearchTerm) it.next();
        String[] phrase = getPhrase(elem.getValue().toLowerCase().trim());
        if (phrase.length > 1) {
            PhraseQuery phraseQuery = new PhraseQuery();
            phraseQuery.setSlop(10);//  w ww.  ja va 2s .com

            for (int i = 0; i < phrase.length; i++) {
                phraseQuery.add(new Term(elem.getFieldName(), phrase[i].toLowerCase().trim()));
            }
            orTerms.add(phraseQuery, BooleanClause.Occur.SHOULD);
        } else if (phrase.length == 1) {
            //                Term t = new Term(elem.getFieldName(), elem.getValue().toLowerCase().trim());
            logger.fine("INDEXER: wildcardQuery: search element value: " + phrase[0].toLowerCase().trim());
            if (isPrefixSearchableFileMetadataField(elem.getFieldName())) {
                Term t = new Term(elem.getFieldName(), phrase[0].toLowerCase().trim() + "*");
                logger.fine("INDEXER: wildcardQuery: term value=" + t.text());
                WildcardQuery wcQuery = new WildcardQuery(t);
                logger.fine("INDEXER: Term wildcardQuery (native): " + wcQuery.toString());
                orTerms.add(wcQuery, BooleanClause.Occur.SHOULD);
            } else {
                logger.fine("INDEXER: building PhraseQuery: search element value: "
                        + phrase[0].toLowerCase().trim());
                Term t = new Term(elem.getFieldName(), phrase[0].toLowerCase().trim());
                logger.fine("INDEXER: building PhraseQuery: term value=" + t.text());
                TermQuery orQuery = new TermQuery(t);
                logger.fine("INDEXER: TermQuery orQuery (native): " + orQuery.toString());
                orTerms.add(orQuery, BooleanClause.Occur.SHOULD);
            }

        }
    }
    return orTerms;
}

From source file:edu.harvard.iq.dvn.core.index.Indexer.java

License:Apache License

BooleanQuery orIdSearchTermClause(List<Long> id, String fieldName) {
    BooleanQuery idTerms = new BooleanQuery();
    for (Iterator it = id.iterator(); it.hasNext();) {
        Long lId = (Long) it.next();
        //Term varStudyId = new Term ("varStudyId",lId.toString());
        Term varStudyId = new Term(fieldName, lId.toString());
        TermQuery varStudyIdQuery = new TermQuery(varStudyId);
        idTerms.add(varStudyIdQuery, BooleanClause.Occur.SHOULD);
    }//from   w ww. j a  va  2  s  .  c o m
    return idTerms;
}

From source file:edu.harvard.iq.dvn.core.index.Indexer.java

License:Apache License

public BooleanQuery andSearchTermClause(List<SearchTerm> andSearchTerms) {
    BooleanQuery andTerms = new BooleanQuery();
    andTerms.setMaxClauseCount(dvnMaxClauseCount);
    Query rQuery = null;/*w  w  w  .  ja v  a2  s  . co  m*/
    for (Iterator it = andSearchTerms.iterator(); it.hasNext();) {
        SearchTerm elem = (SearchTerm) it.next();
        if (elem.getOperator().equals("<")) {
            Term end = new Term(elem.getFieldName(), elem.getValue().toLowerCase().trim());
            Term begin = null;
            rQuery = new TermRangeQuery(elem.getFieldName(), null, elem.getValue().toLowerCase().trim(), false,
                    false);
            //                rQuery = new RangeQuery(begin,end,true);
            andTerms.add(rQuery, BooleanClause.Occur.MUST);
        } else if (elem.getOperator().equals(">")) {
            Term end = null;
            Term begin = new Term(elem.getFieldName(), elem.getValue().toLowerCase().trim());
            rQuery = new TermRangeQuery(elem.getFieldName(), elem.getValue().toLowerCase().trim(), null, false,
                    false);
            //                rQuery = new RangeQuery(begin,end,true);
            andTerms.add(rQuery, BooleanClause.Occur.MUST);
        } else if (elem.getFieldName().equalsIgnoreCase("any")) {
            andTerms = buildAnyQuery(elem.getValue().toLowerCase().trim());
        } else {
            String[] phrase = getPhrase(elem.getValue().toLowerCase().trim());
            if (phrase.length > 1) {
                PhraseQuery phraseQuery = new PhraseQuery();
                phraseQuery.setSlop(10);
                andTerms.add(partialMatch(elem, 10));
            } else if (phrase.length == 1) {
                //                    Term t = new Term(elem.getFieldName(), elem.getValue().toLowerCase().trim());
                Term t = new Term(elem.getFieldName(), phrase[0].toLowerCase().trim());
                TermQuery andQuery = new TermQuery(t);
                if (elem.getOperator().equals("=")) {
                    andTerms.add(andQuery, BooleanClause.Occur.MUST);
                } else if (elem.getOperator().equalsIgnoreCase("-")) {
                    andTerms.add(andQuery, BooleanClause.Occur.MUST_NOT);
                }
            }
        }

    }
    return andTerms;
}

From source file:edu.harvard.iq.dvn.core.index.Indexer.java

License:Apache License

BooleanQuery andQueryClause(List<BooleanQuery> andQueries) {
    BooleanQuery andTerms = new BooleanQuery();
    BooleanQuery.setMaxClauseCount(dvnMaxClauseCount);
    for (Iterator it = andQueries.iterator(); it.hasNext();) {
        BooleanQuery elem = (BooleanQuery) it.next();
        BooleanClause clause = new BooleanClause(elem, BooleanClause.Occur.MUST);
        andTerms.add(clause);/*from   www. jav a 2 s. co  m*/
    }
    return andTerms;
}

From source file:edu.harvard.iq.dvn.core.web.AdvSearchPage.java

License:Apache License

public String searchWithFacets() {
    //        String query = buildQuery();
    //        List searchCollections = null;
    ArrayList<VDCCollection> searchCols = new ArrayList<VDCCollection>();
    boolean searchOnlySelectedCollections = false;

    if (validateAllSearchCriteria()) {
        if (radioButtonList1.getValue() != null) {
            String radioButtonStr = (String) radioButtonList1.getValue();
            if (radioButtonStr.indexOf("Only") > 1) {
                searchOnlySelectedCollections = true;

                //                    searchCollections = new ArrayList();
                for (Iterator it = collectionModelList.iterator(); it.hasNext();) {
                    CollectionModel elem = (CollectionModel) it.next();
                    if (elem.isSelected()) {
                        VDCCollection selectedCollection = vdcCollectionService.find(elem.getId());
                        searchCols.add(selectedCollection);
                    }/*from ww w .ja v a 2 s  . c o  m*/
                }
                if (searchCols.isEmpty()) {
                    //                    if (searchCollections.isEmpty()) {
                    searchOnlySelectedCollections = false;
                }
            }
        }

        List<SearchTerm> searchTerms = buildSearchTermList();
        VDC thisVDC = getVDCRequestBean().getCurrentVDC();
        List<Long> viewableIds = null;
        ResultsWithFacets resultsWithFacets = null;

        if (searchOnlySelectedCollections) {
            //                viewableIds = indexServiceBean.search(thisVDC, searchCollections, searchTerms);
            // older, non-faceted method above
            if (isVariableSearch() || isFileLevelMetadataSearch()) {
                viewableIds = indexServiceBean.search(thisVDC, searchCols, searchTerms);
                logger.fine("searching selected collections [old, facet-less method...]");
            } else {
                logger.fine("searching selected collections [new, facet-enabled method...]");
                List<Query> collectionQueries = new ArrayList<Query>();
                QueryParser parser = new QueryParser(Version.LUCENE_30, "abstract", new DVNAnalyzer());
                parser.setDefaultOperator(QueryParser.AND_OPERATOR);
                for (VDCCollection col : searchCols) {
                    Long colId = col.getId();
                    String type = col.getType();
                    String queryString = col.getQuery();
                    boolean isDynamic = col.isDynamic();
                    boolean isLocalScope = col.isLocalScope();
                    boolean isSubnetworkScope = col.isSubnetworkScope();

                    boolean isRootCollection = col.isRootCollection();
                    VDC colOwner = col.getOwner();
                    StringBuilder sbOuter = new StringBuilder();
                    logger.fine("For " + col.getName() + " (id=" + colId + "|isRootCollection="
                            + isRootCollection + "|type=" + type + "|isDynamic=" + isDynamic + "|isLocalScope="
                            + isLocalScope + ") adding query: <<<" + queryString + ">>>");
                    if (queryString != null && !queryString.isEmpty()) {
                        try {
                            Query dynamicQuery = parser.parse(queryString);
                            BooleanQuery dynamicLocal = new BooleanQuery();

                            // Check the scope:
                            if (isLocalScope) {
                                logger.fine("local scope collection; owned by dataverse " + colOwner.getId());
                                Query dvOwnerIdQuery = indexServiceBean.constructDvOwnerIdQuery(colOwner);
                                dynamicLocal.add(dynamicQuery, BooleanClause.Occur.MUST);
                                dynamicLocal.add(dvOwnerIdQuery, BooleanClause.Occur.MUST);
                                collectionQueries.add(dynamicLocal);

                            } else if (isSubnetworkScope) {
                                logger.fine(
                                        "subnetwork scope collection; owned by dataverse " + colOwner.getId()
                                                + ", in the subnetwork " + colOwner.getVdcNetwork().getId());
                                Query dvOwnerIdQuery = indexServiceBean
                                        .constructNetworkOwnerIdQuery(colOwner.getVdcNetwork().getId());
                                dynamicLocal.add(dynamicQuery, BooleanClause.Occur.MUST);
                                dynamicLocal.add(dvOwnerIdQuery, BooleanClause.Occur.MUST);
                                collectionQueries.add(dynamicLocal);

                            } else {
                                collectionQueries.add(dynamicQuery);
                            }

                        } catch (org.apache.lucene.queryParser.ParseException ex) {
                            Logger.getLogger(StudyListingPage.class.getName()).log(Level.SEVERE, null, ex);
                        }
                    } else {
                        List<Study> studies = col.getStudies();
                        StringBuilder sbInner = new StringBuilder();
                        for (Study study : studies) {
                            logger.fine("- has StudyId: " + study.getId());
                            String idColonId = "id:" + study.getId().toString() + " ";
                            sbInner.append(idColonId);
                        }
                        if (isRootCollection) {
                            List<Long> rootCollectionStudies = vdcService
                                    .getOwnedStudyIds(col.getOwner().getId());
                            for (Long id : rootCollectionStudies) {
                                logger.fine("- has StudyId: " + id);
                                String idColonId = "id:" + id.toString() + " ";
                                sbInner.append(idColonId);

                            }
                        }
                        logger.fine("sbInner: " + sbInner.toString());
                        sbOuter.append(sbInner);

                    }
                    logger.fine("sbOuter: " + sbOuter);
                    if (!sbOuter.toString().isEmpty()) {
                        try {
                            parser.setDefaultOperator(QueryParser.OR_OPERATOR);
                            Query staticColQuery = parser.parse(sbOuter.toString());
                            parser.setDefaultOperator(QueryParser.AND_OPERATOR);
                            logger.fine("staticCollectionQuery: " + staticColQuery);
                            collectionQueries.add(staticColQuery);
                        } catch (org.apache.lucene.queryParser.ParseException ex) {
                            Logger.getLogger(AdvSearchPage.class.getName()).log(Level.SEVERE, null, ex);
                        }
                    }
                }

                DvnQuery dvnQuery = new DvnQuery();
                dvnQuery.setSearchTerms(searchTerms);
                dvnQuery.setMultipleCollectionQueries(collectionQueries);
                dvnQuery.constructQuery();
                resultsWithFacets = indexServiceBean.searchNew(dvnQuery);
                viewableIds = resultsWithFacets.getMatchIds();
            }

        } else {
            logger.fine("in searchWithFacets in AdvSearchPage");
            /* 
             * This is the logical order here (for both the new,
             * facets-enabled methods, and the older methods still 
             * used for the variables and file-level metadata (FITS)
             * searches: 
             * We first check if we are inside a DV; then we run a 
             * DV-scoped search; 
             * If not, we check if we are inside a subnetwork; 
             * And if that is not the case either, we'll run a 
             * full DVN-wide search. 
             * 
             * TODO: it should probably be "Collection, DV, Subnetwork, DVN 
             * instead; i.e., no need to be treating the collection case 
             * separately, above. [?]
             *  -- L.A.
             */

            Long rootSubnetworkId = getVDCRequestBean().getVdcNetwork().getId();
            Long currentSubnetworkId = getVDCRequestBean().getCurrentVdcNetwork().getId();

            if (isVariableSearch() || isFileLevelMetadataSearch()) {
                // older, non-facet method

                if (thisVDC != null) {
                    viewableIds = indexServiceBean.search(thisVDC, searchTerms);
                } else {
                    logger.fine("Checking if in subnetwork... [id=" + currentSubnetworkId + "]");
                    if (!currentSubnetworkId.equals(rootSubnetworkId)) {
                        SearchTerm subnetworkSearchTerm = makeSubnetworkSearchTerm(currentSubnetworkId);
                        if (subnetworkSearchTerm != null) {
                            searchTerms.add(subnetworkSearchTerm);
                        }
                    }

                    viewableIds = indexServiceBean.search((VDC) null, searchTerms);

                }
                // TODO: 
                // Make sure the variable and file metadata searches are 
                // properly scoped for subnetworks as well. -- L.A.
            } else {

                DvnQuery dvnQuery = new DvnQuery();

                if (thisVDC != null) {
                    logger.fine("Running DVN-wide search from AdvSearchPage");

                    dvnQuery.setVdc(thisVDC);

                    List<Query> collectionQueries = new ArrayList<Query>();
                    dvnQuery.setDvOwnerIdQuery(indexServiceBean.constructDvOwnerIdQuery(dvnQuery.getVdc()));
                    collectionQueries = indexServiceBean.getCollectionQueries(dvnQuery.getVdc());
                    if (!collectionQueries.isEmpty()) {
                        logger.fine("collectionQueries: " + collectionQueries);
                        dvnQuery.setCollectionQueries(collectionQueries);
                    } else {
                        logger.fine("empty collectionQueries");
                    }
                } else if (!currentSubnetworkId.equals(rootSubnetworkId)) {
                    logger.fine("Searching only a subnetwork");
                    VDCNetwork vdcNetwork = getVDCRequestBean().getVdcNetwork();
                    String vdcNetworkName = vdcNetwork.getName();
                    logger.fine("vdcNetwork name: " + vdcNetworkName);

                    /*
                     * Brute force implementation: 
                     * going through every DV in the subnetwork, and adding 
                     * all the owner id and collection queries to the search
                     * term query:
                     * -- L.A.
                    Collection<VDC> vdcs = vdcNetwork.getNetworkVDCs();
                    List<Query> subNetworkCollectionQueries = new ArrayList<Query>();
                    List<Query> subNetworkDvMemberQueries = new ArrayList<Query>();
                    for (VDC vdc : vdcs) {
                    String name = vdc.getName();
                    logger.fine("adding queries for: " + name);
                    Query dvnSpecificQuery = indexServiceBean.constructDvOwnerIdQuery(vdc);
                    logger.fine("adding dvnSpecific query:" + dvnSpecificQuery);
                    subNetworkDvMemberQueries.add(dvnSpecificQuery);
                    List<Query> vdcCollectionQueries = indexServiceBean.getCollectionQueries(vdc);
                    for (Query collectionQuery : vdcCollectionQueries) {
                        logger.fine("adding collection query: " + collectionQuery);
                    }
                    subNetworkCollectionQueries.addAll(vdcCollectionQueries);
                    }*/

                    Query subNetworkQuery = indexServiceBean.constructNetworkIdQuery(currentSubnetworkId);
                    dvnQuery.setSubNetworkQuery(subNetworkQuery);
                } else {
                    logger.fine("Running DVN-wide search from AdvSearchPage");
                }

                // Now, run the final search: 

                dvnQuery.setSearchTerms(searchTerms);
                dvnQuery.constructQuery();
                dvnQuery.setClearPreviousFacetRequests(true); // is this still needed?
                resultsWithFacets = indexServiceBean.searchNew(dvnQuery);
                viewableIds = resultsWithFacets.getMatchIds();

            }
        }

        StudyListing sl = new StudyListing(StudyListing.SEARCH);
        sl.setVdcId(getVDCRequestBean().getCurrentVDCId());
        sl.setSearchTerms(searchTerms);
        sl.setResultsWithFacets(resultsWithFacets);
        if (isVariableSearch()) {
            Map variableMap = new HashMap();
            List studies = new ArrayList();
            varService.determineStudiesFromVariables(viewableIds, studies, variableMap);
            sl.setStudyIds(studies);
            sl.setVariableMap(variableMap);

        } else if (isFileLevelMetadataSearch()) {

            Map fileMap = new HashMap();
            List studies = new ArrayList();
            studyService.determineStudiesFromFiles(viewableIds, studies, fileMap);
            sl.setStudyIds(studies);
            sl.setFileMap(fileMap);
        } else {
            sl.setStudyIds(viewableIds);
        }

        String studyListingIndex = StudyListing.addToStudyListingMap(sl, getSessionMap());
        return "/StudyListingPage.xhtml?faces-redirect=true&studyListingIndex=" + studyListingIndex
                + getContextSuffix();
    } else {
        return "";
    }

}