Example usage for org.apache.solr.client.solrj SolrQuery setQuery

List of usage examples for org.apache.solr.client.solrj SolrQuery setQuery

  1. HOME
  2. Java
  3. org.apache.solr
  4. org.apache.solr.client.solrj.*
  5. SolrQuery
  6. setQuery

Introduction

In this page you can find the example usage for org.apache.solr.client.solrj SolrQuery setQuery.

Prototype

public SolrQuery setQuery(String query)

Source Link

Usage

From source file:au.org.ala.biocache.dao.SearchDAOImpl.java

License:Open Source License

/**
 * Returns the count of distinct values for the facets.  Uses groups for group counts.
 * Supports foffset and flimit for paging. Supports fsort 'count' or 'index'.
 * <p/>/*from w  w  w.  jav  a  2s  .  c o  m*/
 * TODO work out whether or not we should allow facet ranges to be downloaded....
 */
public List<FacetResultDTO> getFacetCounts(SpatialSearchRequestParams searchParams) throws Exception {
    Collection<FacetResultDTO> facetResults = new ArrayList<FacetResultDTO>();

    queryFormatUtils.formatSearchQuery(searchParams);
    String queryString = searchParams.getFormattedQuery();
    searchParams.setFacet(false);
    searchParams.setPageSize(0);

    //get facet group counts
    SolrQuery query = initSolrQuery(searchParams, false, null);
    query.setQuery(queryString);
    query.setFields(null);
    query.setRows(0);
    searchParams.setPageSize(0);

    //exclude multivalue fields
    Set<IndexFieldDTO> fields = getIndexedFields();
    List<String> multivalueFields = new ArrayList<String>();
    for (String facet : searchParams.getFacets()) {
        boolean added = false;
        for (IndexFieldDTO f : fields) {
            if (f.getName().equals(facet) && !f.isMultivalue()) {
                query.add("group.field", facet);
                added = true;
            }
        }
        if (!added) {
            multivalueFields.add(facet);
        }
    }

    if (multivalueFields.size() > 0) {
        facetResults.addAll(getMultivalueFacetCounts(query, searchParams, multivalueFields));
    }

    if (multivalueFields.size() < searchParams.getFacets().length) {
        //now use the supplied facets to add groups to the query

        // facet totals are slow, so only fetch when foffset == 0 and flimit != -1
        Map<String, Integer> ngroups = new HashMap<String, Integer>();
        GroupResponse groupResponse = null;
        if (searchParams.getFlimit() != -1 && searchParams.getFoffset() == 0) {
            query.add("group", "true");
            query.add("group.ngroups", "true");
            query.add("group.limit", "0");

            QueryResponse response = runSolrQuery(query, searchParams);
            groupResponse = response.getGroupResponse();
            for (GroupCommand gc : groupResponse.getValues()) {
                ngroups.put(gc.getName(), gc.getNGroups());
            }
        }

        //include paged facets when flimit > 0 or flimit == -1
        if (searchParams.getFlimit() != 0) {
            searchParams.setFacet(true);
            SolrQuery facetQuery = initSolrQuery(searchParams, false, null);
            facetQuery.setQuery(queryString);
            facetQuery.setFields(null);
            facetQuery.setSortField(searchParams.getSort(), ORDER.valueOf(searchParams.getDir()));
            QueryResponse qr = runSolrQuery(facetQuery, searchParams);
            SearchResultDTO searchResults = processSolrResponse(searchParams, qr, facetQuery,
                    OccurrenceIndex.class);
            facetResults = searchResults.getFacetResults();
            if (facetResults != null) {
                for (FacetResultDTO fr : facetResults) {
                    if (searchParams.getFlimit() == -1) {
                        fr.setCount(fr.getFieldResult().size());
                    } else {
                        Integer count = ngroups.get(fr.getFieldName());
                        if (count != null)
                            fr.setCount(count);
                    }
                }
            }
        } else if (groupResponse != null) {
            //only return group counts
            for (GroupCommand gc : groupResponse.getValues()) {
                facetResults.add(new FacetResultDTO(gc.getName(), null, gc.getNGroups()));
            }
        }
    }

    return new ArrayList<FacetResultDTO>(facetResults);
}

From source file:au.org.ala.biocache.dao.SearchDAOImpl.java

License:Open Source License

/**
 * @see au.org.ala.biocache.dao.SearchDAO#findByFulltext(SpatialSearchRequestParams)
 *//*from  w  w w.j av a2  s .  c  o  m*/
@Override
public SolrDocumentList findByFulltext(SpatialSearchRequestParams searchParams) throws Exception {
    SolrDocumentList sdl = null;

    try {
        queryFormatUtils.formatSearchQuery(searchParams);
        String queryString = searchParams.getFormattedQuery();
        SolrQuery solrQuery = new SolrQuery();
        solrQuery.setQuery(queryString);
        solrQuery.setFields(searchParams.getFl());
        solrQuery.setFacet(false);
        solrQuery.setRows(searchParams.getPageSize());

        sdl = runSolrQuery(solrQuery, searchParams).getResults();
    } catch (SolrServerException ex) {
        logger.error("Problem communicating with SOLR server. " + ex.getMessage(), ex);
    }

    return sdl;
}

From source file:au.org.ala.biocache.dao.SearchDAOImpl.java

License:Open Source License

/**
 * @see au.org.ala.biocache.dao.SearchDAO#getStatistics(SpatialSearchRequestParams)
 *//*from w ww .  jav a 2  s.c o  m*/
public Map<String, FieldStatsInfo> getStatistics(SpatialSearchRequestParams searchParams) throws Exception {
    try {
        queryFormatUtils.formatSearchQuery(searchParams);
        String queryString = searchParams.getFormattedQuery();
        SolrQuery solrQuery = new SolrQuery();
        solrQuery.setQuery(queryString);
        for (String field : searchParams.getFacets()) {
            solrQuery.setGetFieldStatistics(field);
        }
        QueryResponse qr = runSolrQuery(solrQuery, searchParams);
        if (logger.isDebugEnabled()) {
            logger.debug(qr.getFieldStatsInfo());
        }
        return qr.getFieldStatsInfo();

    } catch (SolrServerException ex) {
        logger.error("Problem communicating with SOLR server. " + ex.getMessage(), ex);
    }
    return null;
}

From source file:au.org.ala.biocache.dao.SearchDAOImpl.java

License:Open Source License

@Cacheable(cacheName = "legendCache")
public List<LegendItem> getLegend(SpatialSearchRequestParams searchParams, String facetField,
        String[] cutpoints) throws Exception {
    List<LegendItem> legend = new ArrayList<LegendItem>();

    queryFormatUtils.formatSearchQuery(searchParams);
    if (logger.isInfoEnabled()) {
        logger.info("search query: " + searchParams.getFormattedQuery());
    }//  w w  w .  ja v a 2  s.co m
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQueryType("standard");
    solrQuery.setQuery(searchParams.getFormattedQuery());
    solrQuery.setRows(0);
    solrQuery.setFacet(true);

    //is facet query?
    if (cutpoints == null) {
        //special case for the decade
        if (DECADE_FACET_NAME.equals(facetField))
            initDecadeBasedFacet(solrQuery, "occurrence_year");
        else
            solrQuery.addFacetField(facetField);
    } else {
        solrQuery.addFacetQuery("-" + facetField + ":[* TO *]");

        for (int i = 0; i < cutpoints.length; i += 2) {
            solrQuery.addFacetQuery(facetField + ":[" + cutpoints[i] + " TO " + cutpoints[i + 1] + "]");
        }
    }

    solrQuery.setFacetMinCount(1);
    solrQuery.setFacetLimit(-1);//MAX_DOWNLOAD_SIZE);  // unlimited = -1

    solrQuery.setFacetMissing(true);

    QueryResponse qr = runSolrQuery(solrQuery, searchParams.getFormattedFq(), 1, 0, "score", "asc");
    List<FacetField> facets = qr.getFacetFields();
    if (facets != null) {
        for (FacetField facet : facets) {
            List<FacetField.Count> facetEntries = facet.getValues();
            if (facet.getName().contains(facetField) && (facetEntries != null) && (facetEntries.size() > 0)) {
                int i = 0;
                for (i = 0; i < facetEntries.size(); i++) {
                    FacetField.Count fcount = facetEntries.get(i);
                    if (fcount.getCount() > 0) {
                        String fq = facetField + ":\"" + fcount.getName() + "\"";
                        if (fcount.getName() == null) {
                            fq = "-" + facetField + ":[* TO *]";
                        }
                        legend.add(new LegendItem(fcount.getName(), fcount.getCount(), fq));
                    }
                }
                break;
            }
        }
    }
    //check if we have query based facets
    Map<String, Integer> facetq = qr.getFacetQuery();
    if (facetq != null && facetq.size() > 0) {
        for (Entry<String, Integer> es : facetq.entrySet()) {
            legend.add(new LegendItem(es.getKey(), es.getValue(), es.getKey()));
        }
    }

    //check to see if we have a date range facet
    List<FacetField> facetDates = qr.getFacetDates();
    if (facetDates != null && !facetDates.isEmpty()) {
        FacetField ff = facetDates.get(0);
        String firstDate = null;
        for (FacetField.Count facetEntry : ff.getValues()) {
            String startDate = facetEntry.getName();
            if (firstDate == null) {
                firstDate = startDate;
            }
            String finishDate;
            if (DECADE_PRE_1850_LABEL.equals(startDate)) {
                startDate = "*";
                finishDate = firstDate;
            } else {
                int startYear = Integer.parseInt(startDate.substring(0, 4));
                finishDate = (startYear - 1) + "-12-31T23:59:59Z";
            }
            legend.add(new LegendItem(facetEntry.getName(), facetEntry.getCount(),
                    "occurrence_year:[" + startDate + " TO " + finishDate + "]"));
        }
    }
    return legend;
}

From source file:au.org.ala.biocache.dao.SearchDAOImpl.java

License:Open Source License

public FacetField getFacet(SpatialSearchRequestParams searchParams, String facet) throws Exception {
    queryFormatUtils.formatSearchQuery(searchParams);
    if (logger.isInfoEnabled()) {
        logger.info("search query: " + searchParams.getFormattedQuery());
    }/*  ww w. j ava  2 s.  co  m*/
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQueryType("standard");
    solrQuery.setQuery(searchParams.getFormattedQuery());
    solrQuery.setRows(0);
    solrQuery.setFacet(true);
    solrQuery.addFacetField(facet);
    solrQuery.setFacetMinCount(1);
    solrQuery.setFacetLimit(-1); //MAX_DOWNLOAD_SIZE);  // unlimited = -1

    QueryResponse qr = runSolrQuery(solrQuery, searchParams.getFormattedFq(), 1, 0, "score", "asc");
    return qr.getFacetFields().get(0);
}

From source file:au.org.ala.biocache.dao.SearchDAOImpl.java

License:Open Source License

public Map<String, Integer> getOccurrenceCountsForTaxa(List<String> taxa) throws Exception {
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQueryType("standard");
    solrQuery.setRows(0);/*w  w w.j  a va 2 s. c o  m*/
    solrQuery.setFacet(true);
    solrQuery.setFacetLimit(taxa.size());
    StringBuilder sb = new StringBuilder();
    Map<String, Integer> counts = new HashMap<String, Integer>();
    Map<String, String> lftToGuid = new HashMap<String, String>();
    for (String lsid : taxa) {
        //get the lft and rgt value for the taxon
        String[] values = searchUtils.getTaxonSearch(lsid);
        //first value is the search string
        if (sb.length() > 0)
            sb.append(" OR ");
        sb.append(values[0]);
        lftToGuid.put(values[0], lsid);
        //add the query part as a facet
        solrQuery.add("facet.query", values[0]);
    }
    solrQuery.setQuery(sb.toString());

    //solrQuery.add("facet.query", "confidence:" + os.getRange());
    QueryResponse qr = runSolrQuery(solrQuery, null, 1, 0, "score", "asc");
    Map<String, Integer> facetQueries = qr.getFacetQuery();
    for (String facet : facetQueries.keySet()) {
        //add all the counts based on the query value that was substituted
        String lsid = lftToGuid.get(facet);
        Integer count = facetQueries.get(facet);
        if (lsid != null && count != null)
            counts.put(lsid, count);
    }
    if (logger.isDebugEnabled()) {
        logger.debug(facetQueries);
    }
    return counts;
}

From source file:au.org.ala.biocache.dao.SearchDAOImpl.java

License:Open Source License

/**
 * Get SOLR max boolean clauses.//from   w w w.  j a v  a  2 s .  com
 *
 * @return
 */
public int getMaxBooleanClauses() {
    if (maxBooleanClauses == 0) {
        SolrQuery solrQuery = new SolrQuery();
        solrQuery.setFacet(false);
        solrQuery.setRows(0);

        int value = 1024;
        boolean ok = false;
        int step = -1;
        while (step != 0 || ok == false) {
            String q = 1 + StringUtils.repeat(" AND 1", value - 1);
            solrQuery.setQuery(q);
            try {
                query(solrQuery, queryMethod); //throws exception when too many boolean clauses
                if (step == -1)
                    value *= 2; //push upper limit
                else
                    step /= 2;
                ok = true;
            } catch (Exception e) {
                if (step == -1)
                    step = value / 2; //set initial step value
                else if (ok == false && step > 1)
                    step /= 2;
                ok = false;
            }
            if (step != -1) {
                if (ok)
                    value += step;
                else
                    value -= step;
            }
        }
        maxBooleanClauses = value;
    }

    queryFormatUtils.setMaxBooleanClauses(maxBooleanClauses);

    return maxBooleanClauses;
}

From source file:au.org.ala.biocache.dao.SearchDAOImpl.java

License:Open Source License

/**
 * Perform grouped facet query.//from w ww . j  a v  a  2s.c o m
 * <p>
 * facets is the list of grouped facets required
 * flimit restricts the number of groups returned
 * pageSize restricts the number of docs in each group returned
 * fl is the list of fields in the returned docs
 */
public List<GroupFacetResultDTO> searchGroupedFacets(SpatialSearchRequestParams searchParams) throws Exception {
    queryFormatUtils.formatSearchQuery(searchParams);
    String queryString = searchParams.getFormattedQuery();
    searchParams.setFacet(false);

    //get facet group counts
    SolrQuery query = initSolrQuery(searchParams, false, null);
    query.setQuery(queryString);
    query.setFields(null);
    //now use the supplied facets to add groups to the query
    query.add("group", "true");
    query.add("group.ngroups", "true");
    query.add("group.limit", String.valueOf(searchParams.getPageSize()));
    query.setRows(searchParams.getFlimit());
    query.setFields(searchParams.getFl());
    for (String facet : searchParams.getFacets()) {
        query.add("group.field", facet);
    }
    QueryResponse response = runSolrQuery(query, searchParams);
    GroupResponse groupResponse = response.getGroupResponse();

    List<GroupFacetResultDTO> output = new ArrayList();
    for (GroupCommand gc : groupResponse.getValues()) {
        List<GroupFieldResultDTO> list = new ArrayList<GroupFieldResultDTO>();

        String facet = gc.getName();
        for (Group v : gc.getValues()) {
            List<OccurrenceIndex> docs = (new DocumentObjectBinder()).getBeans(OccurrenceIndex.class,
                    v.getResult());

            //build facet displayName and fq
            String value = v.getGroupValue();
            Long count = v.getResult() != null ? v.getResult().getNumFound() : 0L;
            if (value == null) {
                list.add(new GroupFieldResultDTO("", count, "-" + facet + ":*", docs));
            } else {
                list.add(new GroupFieldResultDTO(getFacetValueDisplayName(facet, value), count,
                        facet + ":\"" + value + "\"", docs));
            }
        }

        output.add(new GroupFacetResultDTO(gc.getName(), list, gc.getNGroups()));
    }

    return output;
}

From source file:au.org.ala.biocache.dao.SearchDAOImpl.java

License:Open Source License

/**
 * @see au.org.ala.biocache.dao.SearchDAO#searchPivot(au.org.ala.biocache.dto.SpatialSearchRequestParams)
 *///from  w  w  w.jav  a2 s  . c o  m
public List<FacetPivotResultDTO> searchPivot(SpatialSearchRequestParams searchParams) throws Exception {
    String pivot = StringUtils.join(searchParams.getFacets(), ",");
    searchParams.setFacets(new String[] {});

    queryFormatUtils.formatSearchQuery(searchParams);
    String queryString = searchParams.getFormattedQuery();
    searchParams.setFacet(true);

    //get facet group counts
    SolrQuery query = initSolrQuery(searchParams, false, null);
    query.setQuery(queryString);
    query.setFields(null);
    //now use the supplied facets to add groups to the query
    query.add("facet.pivot", pivot);
    query.add("facet.pivot.mincount", "1");
    query.add("facet.missing", "true");
    query.setRows(0);
    searchParams.setPageSize(0);
    QueryResponse response = runSolrQuery(query, searchParams);
    NamedList<List<PivotField>> result = response.getFacetPivot();

    List<FacetPivotResultDTO> output = new ArrayList();
    for (Entry<String, List<PivotField>> pfl : result) {
        List<PivotField> list = pfl.getValue();
        if (list != null && list.size() > 0) {
            output.add(new FacetPivotResultDTO(list.get(0).getField(), getFacetPivotResults(list), null,
                    (int) response.getResults().getNumFound()));
        }

        //should only be one result
        break;
    }

    return output;
}

From source file:au.org.ala.biocache.dao.SearchDAOImpl.java

License:Open Source License

/**
 * @see au.org.ala.biocache.dao.SearchDAO#searchStat
 *///from w  w w .j a v  a  2 s. c om
public List<FieldStatsItem> searchStat(SpatialSearchRequestParams searchParams, String field, String facet)
        throws Exception {
    searchParams.setFacets(new String[] {});

    queryFormatUtils.formatSearchQuery(searchParams);
    String queryString = searchParams.getFormattedQuery();

    if (facet != null)
        searchParams.setFacet(true);

    //get facet group counts
    SolrQuery query = initSolrQuery(searchParams, false, null);
    query.setQuery(queryString);
    query.setFields(null);
    //query.setFacetLimit(-1);

    //stats parameters
    query.add("stats", "true");
    if (facet != null)
        query.add("stats.facet", facet);
    query.add("stats.field", field);

    query.setRows(0);
    searchParams.setPageSize(0);
    QueryResponse response = runSolrQuery(query, searchParams);

    List<FieldStatsItem> output = new ArrayList();
    if (facet != null && response.getFieldStatsInfo().size() > 0) {
        for (FieldStatsInfo f : response.getFieldStatsInfo().values().iterator().next().getFacets().values()
                .iterator().next()) {
            FieldStatsItem item = new FieldStatsItem(f);
            if (f.getName() == null) {
                item.setFq("-" + facet + ":*");
            } else {
                item.setFq(facet + ":\"" + f.getName() + "\"");
            }
            item.setLabel(f.getName());
            output.add(item);
        }
    } else {
        if (response.getFieldStatsInfo().size() > 0) {
            output.add(new FieldStatsItem(response.getFieldStatsInfo().values().iterator().next()));
        }
    }

    return output;
}