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

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

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

Introduction

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

Prototype

public SolrQuery setFacetMinCount(int cnt)

Source Link

Document

set facet minimum count

Usage

From source file:org.dspace.discovery.SolrServiceImpl.java

License:BSD License

protected SolrQuery resolveToSolrQuery(Context context, DiscoverQuery discoveryQuery,
        boolean includeUnDiscoverable) {
    SolrQuery solrQuery = new SolrQuery();

    String query = "*:*";
    if (discoveryQuery.getQuery() != null) {
        query = discoveryQuery.getQuery();
    }/*from ww  w  .jav a2 s.  com*/

    solrQuery.setQuery(query);
    if (discoveryQuery.isSpellCheck()) {
        solrQuery.setParam(SpellingParams.SPELLCHECK_Q, query);
        solrQuery.setParam(SpellingParams.SPELLCHECK_COLLATE, Boolean.TRUE);
        solrQuery.setParam("spellcheck", Boolean.TRUE);
    }

    if (!includeUnDiscoverable) {
        solrQuery.addFilterQuery("NOT(withdrawn:true)");
        solrQuery.addFilterQuery("NOT(discoverable:false)");
    }

    for (int i = 0; i < discoveryQuery.getFilterQueries().size(); i++) {
        String filterQuery = discoveryQuery.getFilterQueries().get(i);
        solrQuery.addFilterQuery(filterQuery);
    }
    if (discoveryQuery.getDSpaceObjectFilter() != -1) {
        solrQuery.addFilterQuery("search.resourcetype:" + discoveryQuery.getDSpaceObjectFilter());
    }

    for (int i = 0; i < discoveryQuery.getFieldPresentQueries().size(); i++) {
        String filterQuery = discoveryQuery.getFieldPresentQueries().get(i);
        solrQuery.addFilterQuery(filterQuery + ":[* TO *]");
    }

    if (discoveryQuery.getStart() != -1) {
        solrQuery.setStart(discoveryQuery.getStart());
    }

    if (discoveryQuery.getMaxResults() != -1) {
        solrQuery.setRows(discoveryQuery.getMaxResults());
    }

    if (discoveryQuery.getSortField() != null) {
        SolrQuery.ORDER order = SolrQuery.ORDER.asc;
        if (discoveryQuery.getSortOrder().equals(DiscoverQuery.SORT_ORDER.desc))
            order = SolrQuery.ORDER.desc;

        solrQuery.addSortField(discoveryQuery.getSortField(), order);
    }

    for (String property : discoveryQuery.getProperties().keySet()) {
        List<String> values = discoveryQuery.getProperties().get(property);
        solrQuery.add(property, values.toArray(new String[values.size()]));
    }

    List<DiscoverFacetField> facetFields = discoveryQuery.getFacetFields();
    if (0 < facetFields.size()) {
        //Only add facet information if there are any facets
        for (DiscoverFacetField facetFieldConfig : facetFields) {
            String field = transformFacetField(facetFieldConfig, facetFieldConfig.getField(), false);
            solrQuery.addFacetField(field);

            // Setting the facet limit in this fashion ensures that each facet can have its own max
            solrQuery.add("f." + field + "." + FacetParams.FACET_LIMIT,
                    String.valueOf(facetFieldConfig.getLimit()));
            String facetSort;
            if (DiscoveryConfigurationParameters.SORT.COUNT.equals(facetFieldConfig.getSortOrder())) {
                facetSort = FacetParams.FACET_SORT_COUNT;
            } else {
                facetSort = FacetParams.FACET_SORT_INDEX;
            }
            solrQuery.add("f." + field + "." + FacetParams.FACET_SORT, facetSort);
            if (facetFieldConfig.getOffset() != -1) {
                solrQuery.setParam("f." + field + "." + FacetParams.FACET_OFFSET,
                        String.valueOf(facetFieldConfig.getOffset()));
            }
            if (facetFieldConfig.getPrefix() != null) {
                solrQuery.setFacetPrefix(field, facetFieldConfig.getPrefix());
            }
        }

        List<String> facetQueries = discoveryQuery.getFacetQueries();
        for (String facetQuery : facetQueries) {
            solrQuery.addFacetQuery(facetQuery);
        }

        if (discoveryQuery.getFacetMinCount() != -1) {
            solrQuery.setFacetMinCount(discoveryQuery.getFacetMinCount());
        }

        solrQuery.setParam(FacetParams.FACET_OFFSET, String.valueOf(discoveryQuery.getFacetOffset()));
    }

    if (0 < discoveryQuery.getHitHighlightingFields().size()) {
        solrQuery.setHighlight(true);
        solrQuery.add(HighlightParams.USE_PHRASE_HIGHLIGHTER, Boolean.TRUE.toString());
        for (DiscoverHitHighlightingField highlightingField : discoveryQuery.getHitHighlightingFields()) {
            solrQuery.addHighlightField(highlightingField.getField() + "_hl");
            solrQuery.add("f." + highlightingField.getField() + "_hl." + HighlightParams.FRAGSIZE,
                    String.valueOf(highlightingField.getMaxChars()));
            solrQuery.add("f." + highlightingField.getField() + "_hl." + HighlightParams.SNIPPETS,
                    String.valueOf(highlightingField.getMaxSnippets()));
        }

    }

    //Add any configured search plugins !
    List<SolrServiceSearchPlugin> solrServiceSearchPlugins = new DSpace().getServiceManager()
            .getServicesByType(SolrServiceSearchPlugin.class);
    for (SolrServiceSearchPlugin searchPlugin : solrServiceSearchPlugins) {
        searchPlugin.additionalSearchParameters(context, discoveryQuery, solrQuery);
    }
    return solrQuery;
}

From source file:org.dspace.util.SolrImportExport.java

License:BSD License

/**
 * Exports documents from the given index to the specified target directory in batches of #ROWS_PER_FILE, starting at fromWhen (or all documents).
 * See #makeExportFilename for the file names that are generated.
 *
 * @param indexName The index to export.
 * @param toDir The target directory for the export. Will be created if it doesn't exist yet. The directory must be writeable.
 * @param solrUrl The solr URL for the index to export. Must not be null.
 * @param timeField The time field to use for sorting the export. Must not be null.
 * @param fromWhen Optionally, from when to export. See options for allowed values. If null or empty, all documents will be exported.
 * @throws SolrServerException if there is a problem with exporting the index.
 * @throws IOException if there is a problem creating the files or communicating with Solr.
 * @throws SolrImportExportException if there is a problem in communicating with Solr.
 *//*from  ww w .  j  a va 2 s.co  m*/
public static void exportIndex(String indexName, File toDir, String solrUrl, String timeField, String fromWhen)
        throws SolrServerException, IOException, SolrImportExportException {
    if (StringUtils.isBlank(solrUrl)) {
        throw new SolrImportExportException(
                "Could not construct solr URL for index" + indexName + ", aborting export.");
    }

    if (!toDir.exists() || !toDir.canWrite()) {
        throw new SolrImportExportException("Target directory " + toDir
                + " doesn't exist or is not writable, aborting export of index " + indexName);
    }

    HttpSolrServer solr = new HttpSolrServer(solrUrl);

    SolrQuery query = new SolrQuery("*:*");
    if (StringUtils.isNotBlank(fromWhen)) {
        String lastValueFilter = makeFilterQuery(timeField, fromWhen);
        if (StringUtils.isNotBlank(lastValueFilter)) {
            query.addFilterQuery(lastValueFilter);
        }
    }

    query.setRows(0);
    query.setGetFieldStatistics(timeField);
    Map<String, FieldStatsInfo> fieldInfo = solr.query(query).getFieldStatsInfo();
    if (fieldInfo == null || !fieldInfo.containsKey(timeField)) {
        log.warn("Cannot get earliest date, not exporting index " + indexName + ", time field " + timeField
                + ", from " + fromWhen);
        return;
    }
    FieldStatsInfo timeFieldInfo = fieldInfo.get(timeField);
    if (timeFieldInfo == null || timeFieldInfo.getMin() == null) {
        log.warn("Cannot get earliest date, not exporting index " + indexName + ", time field " + timeField
                + ", from " + fromWhen);
        return;
    }
    Date earliestTimestamp = (Date) timeFieldInfo.getMin();

    query.setGetFieldStatistics(false);
    query.clearSorts();
    query.setRows(0);
    query.setFacet(true);
    query.add(FacetParams.FACET_RANGE, timeField);
    query.add(FacetParams.FACET_RANGE_START, SOLR_DATE_FORMAT.format(earliestTimestamp) + "/MONTH");
    query.add(FacetParams.FACET_RANGE_END, "NOW/MONTH+1MONTH");
    query.add(FacetParams.FACET_RANGE_GAP, "+1MONTH");
    query.setFacetMinCount(1);

    List<RangeFacet.Count> monthFacets = solr.query(query).getFacetRanges().get(0).getCounts();

    for (RangeFacet.Count monthFacet : monthFacets) {
        Date monthStartDate;
        String monthStart = monthFacet.getValue();
        try {
            monthStartDate = SOLR_DATE_FORMAT_NO_MS.parse(monthStart);
        } catch (java.text.ParseException e) {
            throw new SolrImportExportException("Could not read start of month batch as date: " + monthStart,
                    e);
        }
        int docsThisMonth = monthFacet.getCount();

        SolrQuery monthQuery = new SolrQuery("*:*");
        monthQuery.setRows(ROWS_PER_FILE);
        monthQuery.set("wt", "csv");
        monthQuery.set("fl", "*");

        monthQuery.addFilterQuery(timeField + ":[" + monthStart + " TO " + monthStart + "+1MONTH]");

        for (int i = 0; i < docsThisMonth; i += ROWS_PER_FILE) {
            monthQuery.setStart(i);
            URL url = new URL(solrUrl + "/select?" + monthQuery.toString());

            File file = new File(toDir.getCanonicalPath(),
                    makeExportFilename(indexName, monthStartDate, docsThisMonth, i));
            if (file.createNewFile()) {
                FileUtils.copyURLToFile(url, file);
                log.info("Exported batch " + i + " to " + file.getCanonicalPath());
            } else {
                throw new SolrImportExportException("Could not create file " + file.getCanonicalPath()
                        + " while exporting index " + indexName + ", month" + monthStart + ", batch " + i);
            }
        }
    }
}

From source file:org.emonocot.persistence.dao.hibernate.SearchableDaoImpl.java

License:Open Source License

/**
 * @param query//from w  ww.j  ava 2  s .c o  m
 *            A lucene query
 * @param spatialQuery
 *            A spatial query to filter the results by
 * @param pageSize
 *            The maximum number of results to return
 * @param pageNumber
 *            The offset (in pageSize chunks, 0-based) from the beginning of
 *            the recordset
 * @param facets
 *            The names of the facets you want to calculate
 * @param selectedFacets
 *            A map of facets which you would like to restrict the search by
 * @param sort
 *            A representation for the order results should be returned in
 * @param fetch
 *            Set the fetch profile
 * @return a Page from the resultset
 * @throws SolrServerException
 */
public final Page<T> search(final String query, final String spatialQuery, final Integer pageSize,
        final Integer pageNumber, final String[] facets, Map<String, String> facetPrefixes,
        final Map<String, String> selectedFacets, final String sort, final String fetch)
        throws SolrServerException {
    SolrQuery solrQuery = prepareQuery(query, sort, pageSize, pageNumber, selectedFacets);
    solrQuery.set("spellcheck", "true");
    solrQuery.set("spellcheck.collate", "true");
    solrQuery.set("spellcheck.count", "1");
    solrQuery.set("bq", "base.class_s:org.emonocot.model.Taxon^2.0");

    // Filter the searchable objects out
    solrQuery.addFilterQuery("base.class_searchable_b:" + isSearchableObject());

    if (spatialQuery != null && spatialQuery.trim().length() != 0) {
        solrQuery.addFilterQuery(spatialQuery);
    }

    if (facets != null && facets.length != 0) {
        solrQuery.setFacet(true);
        solrQuery.setFacetMinCount(1);
        solrQuery.setFacetSort(FacetParams.FACET_SORT_INDEX);

        for (String facet : facets) {
            if (facet.equals("base.class_s")) {
                solrQuery.setParam("f.base.class_s.facet.sort", FacetParams.FACET_SORT_COUNT);
            }
            if (facet.endsWith("_dt")) {
                /**
                 * Is a date facet. Once Solr 4.2 is released, we can implement variable length buckets, but for now
                 * stick with fixed buckets https://issues.apache.org/jira/browse/SOLR-2366
                 */

                solrQuery.add("facet.range", facet);
                solrQuery.add("f." + facet + ".facet.range.start", "NOW/DAY-1YEARS");
                solrQuery.add("f." + facet + ".facet.range.end", "NOW/DAY");
                solrQuery.add("f." + facet + ".facet.range.gap", "+1MONTH");
            } else {
                solrQuery.addFacetField(facet);
            }
            includeMissing(solrQuery, facet);
        }
        if (facetPrefixes != null) {
            for (String facet : facetPrefixes.keySet()) {
                solrQuery.add("f." + facet + ".facet.prefix", facetPrefixes.get(facet));
            }
        }
    }
    QueryResponse queryResponse = solrServer.query(solrQuery);

    List<T> results = new ArrayList<T>();
    for (SolrDocument solrDocument : queryResponse.getResults()) {
        T object = loadObjectForDocument(solrDocument);
        enableProfilePostQuery(object, fetch);
        results.add(object);
    }

    Long totalResults = new Long(queryResponse.getResults().getNumFound());
    Page<T> page = new DefaultPageImpl<T>(totalResults.intValue(), pageNumber, pageSize, results,
            queryResponse);
    if (selectedFacets != null) {
        page.setSelectedFacets(selectedFacets);
    }
    page.setSort(sort);

    return page;
}

From source file:org.emonocot.persistence.dao.hibernate.SearchableDaoImpl.java

License:Open Source License

public CellSet analyse(String rows, String cols, Integer firstCol, Integer maxCols, Integer firstRow,
        Integer maxRows, Map<String, String> selectedFacets, String[] facets, Cube cube)
        throws SolrServerException {
    SolrQuery query = new SolrQuery();
    query.setQuery("*:*");
    SolrQuery totalQuery = new SolrQuery();
    totalQuery.setQuery("*:*");

    // We're not interested in the results themselves
    query.setRows(1);//from w w w  .ja  v  a  2s.c  o m
    query.setStart(0);
    totalQuery.setRows(1);
    totalQuery.setStart(0);

    if (rows == null) {
        query.setFacet(true);
        query.setFacetMinCount(1);
        query.setFacetSort(FacetParams.FACET_SORT_INDEX);
        query.addFacetField(cube.getDefaultLevel());
        includeMissing(query, cube.getDefaultLevel());
        includeMissing(totalQuery, cube.getDefaultLevel());
        if (maxRows != null) {
            totalQuery.setFacet(true);
            totalQuery.setFacetMinCount(1);
            totalQuery.addFacetField("{!key=totalRows}" + cube.getDefaultLevel());

            query.add("f." + cube.getDefaultLevel() + ".facet.limit", maxRows.toString());
            query.add("f." + cube.getDefaultLevel() + ".facet.mincount", "1");
            if (firstRow != null) {
                query.add("f." + cube.getDefaultLevel() + ".facet.offset", firstRow.toString());
            }
        }
    } else if (cols == null) {
        query.setFacet(true);
        query.setFacetMinCount(1);
        query.setFacetSort(FacetParams.FACET_SORT_INDEX);
        query.addFacetField(rows);
        includeMissing(query, rows);
        includeMissing(totalQuery, rows);
        if (maxRows != null) {
            totalQuery.setFacet(true);
            totalQuery.setFacetMinCount(1);
            totalQuery.addFacetField("{!key=totalRows}" + rows);
            query.add("f." + rows + ".facet.limit", maxRows.toString());
            query.add("f." + rows + ".facet.mincount", "1");
            if (firstRow != null) {
                query.add("f." + rows + ".facet.offset", firstRow.toString());
            }
        }
        if (cube.getLevel(rows).isMultiValued() && cube.getLevel(rows).getHigher() != null) {
            Level higher = cube.getLevel(rows).getHigher();
            totalQuery.add("f." + rows + ".facet.prefix", selectedFacets.get(higher.getFacet()) + "_");
            query.add("f." + rows + ".facet.prefix", selectedFacets.get(higher.getFacet()) + "_");
        }
    } else {
        query.setFacet(true);
        query.setFacetMinCount(1);
        query.setFacetSort(FacetParams.FACET_SORT_INDEX);
        query.addFacetField(rows);
        includeMissing(query, rows);
        includeMissing(totalQuery, rows);
        if (maxRows != null) {
            totalQuery.setFacet(true);
            totalQuery.setFacetMinCount(1);
            totalQuery.addFacetField("{!key=totalRows}" + rows);
            query.add("f." + rows + ".facet.limit", maxRows.toString());
            query.add("f." + rows + ".facet.mincount", "1");
            if (firstRow != null) {
                query.add("f." + rows + ".facet.offset", firstRow.toString());
            }
        }
        if (cube.getLevel(rows).isMultiValued() && cube.getLevel(rows).getHigher() != null) {
            Level higher = cube.getLevel(rows).getHigher();
            totalQuery.add("f." + rows + ".facet.prefix", selectedFacets.get(higher.getFacet()) + "_");
            query.add("f." + rows + ".facet.prefix", selectedFacets.get(higher.getFacet()) + "_");
        }
        query.addFacetField(cols);
        includeMissing(query, cols);
        if (maxCols != null) {
            totalQuery.setFacet(true);
            totalQuery.setFacetMinCount(1);
            totalQuery.addFacetField("{!key=totalCols}" + cols);
            /**
             * Facet pivot does not behave the same way on columns - the limit is
             */
            //query.add("f." + cols + ".facet.limit", maxCols.toString());
            //query.add("f." + cols + ".facet.mincount", "1");
            //if (firstCol != null) {
            //   query.add("f." + cols + ".facet.offset", firstCol.toString());
            //}
        }
        if (cube.getLevel(cols).isMultiValued() && cube.getLevel(cols).getHigher() != null) {
            Level higher = cube.getLevel(cols).getHigher();
            totalQuery.add("f." + cols + ".facet.prefix", selectedFacets.get(higher.getFacet()) + "_");
            query.add("f." + cols + ".facet.prefix", selectedFacets.get(higher.getFacet()) + "_");
        }
        query.addFacetPivotField(rows + "," + cols);
    }

    if (selectedFacets != null && !selectedFacets.isEmpty()) {
        for (String facetName : selectedFacets.keySet()) {
            String facetValue = selectedFacets.get(facetName);
            if (StringUtils.isNotEmpty(facetValue)) {
                totalQuery.addFilterQuery(facetName + ":" + selectedFacets.get(facetName));
                query.addFilterQuery(facetName + ":" + selectedFacets.get(facetName));
            } else {//Subtract/Exclude documents with any value for the facet
                totalQuery.addFilterQuery("-" + facetName + ":[* TO *]");
                query.addFilterQuery("-" + facetName + ":[* TO *]");
            }
        }
    }

    if (facets != null && facets.length != 0) {
        query.setFacet(true);
        query.setFacetMinCount(1);
        query.setFacetSort(FacetParams.FACET_SORT_INDEX);

        for (String facetName : facets) {
            if (rows != null && rows.equals(facetName)) {
            } else if (cols != null && cols.equals(facetName)) {
            } else if (rows == null && facetName.equals(cube.getDefaultLevel())) {
            } else {
                includeMissing(query, facetName);
                query.addFacetField(facetName);
            }
        }
    }

    QueryResponse response = solrServer.query(query);
    QueryResponse totalResponse = solrServer.query(totalQuery);
    FacetField totalRows = null;
    FacetField totalCols = null;
    if (totalResponse.getFacetField("totalRows") != null) {
        totalRows = totalResponse.getFacetField("totalRows");
    }

    if (totalResponse.getFacetField("totalCols") != null) {
        totalCols = totalResponse.getFacetField("totalCols");
    }

    CellSet cellSet = new CellSet(response, selectedFacets, query, rows, cols, firstRow, maxRows, firstCol,
            maxCols, totalRows, totalCols, cube);

    return cellSet;
}

From source file:org.gbif.common.search.builder.SolrQueryBuilder.java

License:Apache License

/**
 * Helper method that sets the parameter for a faceted query.
 * //w  w  w . j av  a  2 s  . c  om
 * @param searchRequest the searchRequest used to extract the parameters
 * @param solrQuery this object is modified by adding the facets parameters
 */
private void applyFacetSettings(FacetedSearchRequest<P> searchRequest, SolrQuery solrQuery) {

    final BiMap<P, String> facetFieldsMapInv = facetFieldsPropertiesMap.inverse();

    if (!searchRequest.getFacets().isEmpty()) {
        // Only show facets that contains at least 1 record
        solrQuery.setFacet(true);
        // defaults if not overridden on per field basis
        solrQuery.setFacetMinCount(Objects.firstNonNull(searchRequest.getFacetMinCount(), DEFAULT_FACET_COUNT));
        solrQuery.setFacetMissing(DEFAULT_FACET_MISSING);
        solrQuery.setFacetSort(DEFAULT_FACET_SORT.toString().toLowerCase());

        for (final P facet : searchRequest.getFacets()) {
            if (!facetFieldsMapInv.containsKey(facet)) {
                LOG.warn("{} is no valid facet. Ignore", facet);
                continue;
            }
            final String field = facetFieldsMapInv.get(facet);
            if (searchRequest.isMultiSelectFacets()) {
                // use exclusion filter with same name as used in filter query
                // http://wiki.apache.org/solr/SimpleFacetParameters#Tagging_and_excluding_Filters
                solrQuery.addFacetField(FACET_FILTER_EX.replace(TAG_FIELD_PARAM, field));
            } else {
                solrQuery.addFacetField(field);
            }
            FacetField fieldDef = facetFieldDefs.get(field);
            if (fieldDef.missing() != DEFAULT_FACET_MISSING) {
                solrQuery.setParam(perFieldParamName(field, PARAM_FACET_MISSING), fieldDef.missing());
            }
            if (fieldDef.sort() != DEFAULT_FACET_SORT) {
                solrQuery.setParam(perFieldParamName(field, PARAM_FACET_SORT),
                        fieldDef.sort().toString().toLowerCase());
            }
            setFacetMethod(solrQuery, field, fieldDef.method());
        }
    }
}

From source file:org.geotools.data.solr.FieldLayerMapper.java

License:Open Source License

@Override
public List<String> createTypeNames(HttpSolrServer solrServer) throws Exception {
    List<String> names = new ArrayList<>();

    SolrQuery query = new SolrQuery();
    query.setQuery("*:*");
    query.addFacetField(field);//  w w  w .  ja v  a 2 s  .  co  m
    query.setFacet(true);
    query.setFacetMinCount(1);
    query.setFacetSort(FacetParams.FACET_SORT_INDEX);
    query.setRows(0);
    query.setParam("omitHeader", true);

    QueryResponse rsp = solrServer.query(query);
    if (LOGGER.isLoggable(Level.FINE)) {
        LOGGER.log(Level.FINE, "SOLR query done: " + query.toString());
    }
    List<Count> uniqueFacetFields = rsp.getFacetFields().get(0).getValues();
    for (Count field : uniqueFacetFields) {
        names.add(field.getName());
    }
    return names;
}

From source file:org.geotools.data.solr.SolrDataStore.java

License:Open Source License

@Override
protected List<Name> createTypeNames() throws IOException {
    try {//from   w ww  .ja  va2 s .  c  om
        if (typeNames == null || typeNames.isEmpty()) {
            typeNames = new ArrayList<Name>();
            SolrQuery query = new SolrQuery();
            query.setQuery("*:*");
            query.addFacetField(field);
            query.setFacet(true);
            query.setFacetMinCount(1);
            query.setFacetSort(FacetParams.FACET_SORT_INDEX);
            query.setRows(0);
            query.setParam("omitHeader", true);
            QueryResponse rsp = solrServer.query(query);
            if (LOGGER.isLoggable(Level.FINE)) {
                LOGGER.log(Level.FINE, "SOLR query done: " + query.toString());
            }
            List<Count> uniqueFacetFields = rsp.getFacetFields().get(0).getValues();
            for (Count field : uniqueFacetFields) {
                typeNames.add(new NameImpl(namespaceURI, field.getName()));
            }
        }
    } catch (Exception ex) {
        LOGGER.log(Level.SEVERE, ex.getMessage(), ex);
    }
    return typeNames;
}

From source file:org.hbird.business.archive.solr.SolrProducer.java

License:Apache License

private List<EntityInstance> doInitializationRequest(DataRequest body, String request) {

    SolrQuery query = new SolrQuery(request);

    query.setRows(1);/*w  w  w .ja  v a 2 s  .  c  om*/
    query.setSortField(endpoint.getSortField(), endpoint.getSortOrder());

    /** Configure facets. */
    query.setFacet(true);
    query.setQuery(request);
    query.setFacetSort(StandardArguments.COUNT);
    query.setFacetLimit(-1);
    query.setFacetMissing(false);
    query.setFacetMinCount(1);

    query.addFacetField(StandardArguments.NAME);

    query.setQueryType("basic");

    List<EntityInstance> results = new ArrayList<EntityInstance>();

    QueryResponse response;
    try {
        response = endpoint.getServer().query(query);
        if (response.getStatus() != 0) {
            LOG.error("Failed to execute retrieval request. Failed with status '{}'.", response.getStatus());
        }

        if (response.getFacetFields() != null) {

            /** For each facet, retrieve 'rows' samples. */
            for (FacetField facetfield : response.getFacetFields()) {

                if (facetfield.getValues() != null) {

                    LOG.info("Found " + facetfield.getValueCount() + " entries for facet value "
                            + facetfield.getName());

                    for (Count count : facetfield.getValues()) {

                        String applicableTo = "";
                        if (body.hasArgumentValue(StandardArguments.APPLICABLE_TO)) {
                            applicableTo = body.getArgumentValue(StandardArguments.APPLICABLE_TO, String.class);
                        }

                        SolrQuery sampleQuery = new SolrQuery("name:\"" + count.getName() + "\""
                                + createTimestampElement(body.getFrom(), body.getTo())
                                + createIsApplicableToElement(applicableTo));
                        LOG.info("Using sample query '" + sampleQuery + "' to get facet " + count.getName());
                        sampleQuery.setRows(body.getRows());
                        sampleQuery.setSortField(StandardArguments.TIMESTAMP, ORDER.desc);
                        sampleQuery.setQueryType("basic");

                        for (EntityInstance newObj : retrieve(sampleQuery)) {
                            results.add(newObj);
                            LOG.info("Added object '" + newObj.getID() + "'");
                        }
                    }
                }
            }
        }
    } catch (Exception e) {
        LOG.error("Failed to handle initialization request; query: '{}'.", request, e);
    }

    return results;
}

From source file:org.hoteia.qalingo.core.solr.service.CatalogCategorySolrService.java

License:Apache License

public CatalogCategoryResponseBean searchCatalogCategory(String searchBy, String searchText, String facetField)
        throws SolrServerException, IOException {
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setParam("rows", ROWS_DEFAULT_VALUE);

    if (StringUtils.isEmpty(searchBy)) {
        throw new IllegalArgumentException("SearchBy field can not be Empty or Blank!");
    }/*from   ww  w .  j  a v a  2 s  .  com*/

    if (StringUtils.isEmpty(searchText)) {
        solrQuery.setQuery(searchBy + ":*");
    } else {
        solrQuery.setQuery(searchBy + ":" + searchText + "*");
    }

    if (StringUtils.isNotEmpty(facetField)) {
        solrQuery.setFacet(true);
        solrQuery.setFacetMinCount(1);
        solrQuery.setFacetLimit(8);
        solrQuery.addFacetField(facetField);
    }

    logger.debug("QueryRequest solrQuery: " + solrQuery);

    SolrRequest request = new QueryRequest(solrQuery, METHOD.POST);

    QueryResponse response = new QueryResponse(catalogCategorySolrServer.request(request),
            catalogCategorySolrServer);

    logger.debug("QueryResponse Obj: " + response.toString());

    List<CatalogCategorySolr> solrList = response.getBeans(CatalogCategorySolr.class);
    CatalogCategoryResponseBean catalogCategoryResponseBean = new CatalogCategoryResponseBean();
    catalogCategoryResponseBean.setCatalogCategorySolrList(solrList);

    if (StringUtils.isNotEmpty(facetField)) {
        List<FacetField> solrFacetFieldList = response.getFacetFields();
        catalogCategoryResponseBean.setCatalogCategorySolrFacetFieldList(solrFacetFieldList);
    }

    return catalogCategoryResponseBean;
}

From source file:org.hoteia.qalingo.core.solr.service.CatalogCategorySolrService.java

License:Apache License

public CatalogCategoryResponseBean searchCatalogCategory() throws SolrServerException, IOException {
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setParam("rows", ROWS_DEFAULT_VALUE);

    solrQuery.setQuery("*");
    solrQuery.setFacet(true);//from  ww w . ja va 2 s.c o  m
    solrQuery.setFacetMinCount(1);
    solrQuery.setFacetLimit(8);
    solrQuery.addFacetField("code");

    logger.debug("QueryRequest solrQuery: " + solrQuery);

    SolrRequest request = new QueryRequest(solrQuery, METHOD.POST);

    QueryResponse response = new QueryResponse(catalogCategorySolrServer.request(request),
            catalogCategorySolrServer);

    logger.debug("QueryResponse Obj: " + response.toString());

    List<CatalogCategorySolr> solrList = response.getBeans(CatalogCategorySolr.class);
    List<FacetField> solrFacetFieldList = response.getFacetFields();

    CatalogCategoryResponseBean catalogCategoryResponseBean = new CatalogCategoryResponseBean();
    catalogCategoryResponseBean.setCatalogCategorySolrList(solrList);
    catalogCategoryResponseBean.setCatalogCategorySolrFacetFieldList(solrFacetFieldList);
    return catalogCategoryResponseBean;
}