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

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

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

Introduction

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

Prototype

public SolrQuery setRows(Integer rows)

Source Link

Usage

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);
    query.setSortField(endpoint.getSortField(), endpoint.getSortOrder());

    /** Configure facets. */
    query.setFacet(true);//from   w  ww .  ja va  2 s  . co  m
    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.hbird.business.archive.solr.SolrProducer.java

License:Apache License

protected SolrQuery createQuery(Command body, String request) {

    SolrQuery query = new SolrQuery(request);

    query.setQueryType("basic");

    if (body.hasArgumentValue(StandardArguments.ROWS)) {
        query.setRows(body.getArgumentValue(StandardArguments.ROWS, Integer.class));
    } else {/*from  www  .  j  ava  2 s  . co m*/
        query.setRows(endpoint.getRows());
    }

    if (body.hasArgumentValue(StandardArguments.SORT)) {

        ORDER sortOrder = ORDER.desc;
        if (body.hasArgumentValue(StandardArguments.SORT_ORDER)) {
            if ("ASC".equals(body.getArgumentValue(StandardArguments.SORT_ORDER, String.class))) {
                sortOrder = ORDER.asc;
            }
        }

        query.setSortField(body.getArgumentValue(StandardArguments.SORT, String.class), sortOrder);
    }

    return query;
}

From source file:org.hippoecm.hst.demo.components.SolrFaceting.java

License:Apache License

@Override
public void doBeforeRender(final HstRequest request, final HstResponse response) throws HstComponentException {

    HippoSolrClient solrClient = HstServices.getComponentManager().getComponent(HippoSolrClient.class.getName(),
            SOLR_MODULE_NAME);/*from w  w w .  ja  v  a2  s. c o  m*/
    SolrSearchParams params = new SolrSearchParams(request);

    params.setParamsOnRequestAttr();
    try {
        // set the free text query
        HippoQuery hippoQuery = solrClient.createQuery(params.getQuery());

        SolrQuery solrQuery = hippoQuery.getSolrQuery();

        String facetPath = request.getRequestContext().getResolvedSiteMapItem().getParameter("facetpath");
        if (facetPath != null) {
            // there is a facet path : Account for the constraints
            // the facet path looks like key/value/key/value 

            String[] constraints = facetPath.split("/");
            if (constraints.length % 2 != 0) {
                log.warn("Invalid constraints because not equal number of keys and values");
            } else {
                int i = 0;
                while (i < constraints.length) {
                    String facetField = constraints[i];
                    String facetValue = constraints[i + 1];
                    solrQuery.addFilterQuery(facetField + ":" + solrClient.getQueryParser().escape(facetValue));
                    i += 2;
                }
            }
        }

        // set rows to 0 : we are not interested to get results, but to get faceted navigation
        solrQuery.setRows(0);
        solrQuery.addFacetField("brand", "categories", "title");
        solrQuery.setFacetLimit(10);

        Calendar startCal = Calendar.getInstance();
        startCal.add(Calendar.YEAR, -5);

        Date startDate = startCal.getTime();
        Date endDate = Calendar.getInstance().getTime();
        solrQuery.addDateRangeFacet("date", startDate, endDate, "+1YEAR");

        // From SOLR 3.6 and higher you can also use :
        // solrQuery.addDateRangeFacet("date", startDate , endDate, "+1YEAR, +1MONTH, +1DAY");
        // This way you can create multiple buckets for 1 date field

        final HippoQueryResult result = hippoQuery.execute();

        // we do not need to bind the beans with their providers for faceting, so no need for
        // result.bindHits()

        request.setAttribute("queryResponse", result.getQueryResponse());
        request.setAttribute("query", params.getQuery());

    } catch (SolrServerException e) {
        throw new HstComponentException(e);
    }

}

From source file:org.intermine.api.searchengine.solr.SolrKeywordSearchHandler.java

License:GNU General Public License

private QueryResponse performSearch(InterMineAPI im, String queryString, Map<String, String> facetValues,
        List<Integer> ids, int offSet, int rowSize) {

    SolrClient solrClient = SolrClientManager.getClientInstance(im.getObjectStore());

    QueryResponse resp = null;//from  w w  w.  ja  v  a 2s  . c o m

    KeywordSearchPropertiesManager keywordSearchPropertiesManager = KeywordSearchPropertiesManager
            .getInstance(im.getObjectStore());

    Vector<KeywordSearchFacetData> facets = keywordSearchPropertiesManager.getFacets();

    Map<ClassDescriptor, Float> classBoost = keywordSearchPropertiesManager.getClassBoost();

    List<String> fieldNames = getFieldNamesFromSolrSchema(solrClient);

    try {

        SolrQuery newQuery = new SolrQuery();
        newQuery.setQuery(queryString);
        newQuery.setStart(offSet);
        newQuery.setRows(rowSize);
        newQuery.addField("score");
        newQuery.addField("id");
        newQuery.add("defType", "edismax");

        for (KeywordSearchFacetData keywordSearchFacetData : facets) {
            newQuery.addFacetField("facet_" + keywordSearchFacetData.getField());
        }

        // add faceting selections
        for (Map.Entry<String, String> facetValue : facetValues.entrySet()) {
            if (facetValue != null) {
                newQuery.addFilterQuery(facetValue.getKey() + ":" + facetValue.getValue());
            }
        }

        //limiting the query based on search bag
        if (ids != null && !ids.isEmpty()) {
            for (int id : ids) {
                newQuery.addFilterQuery("id", Integer.toString(id));
            }
        }

        String boostQuery = "";

        for (Map.Entry<ClassDescriptor, Float> boostValue : classBoost.entrySet()) {
            if (boostValue != null) {
                boostQuery += "classname:" + boostValue.getKey().getUnqualifiedName() + "^"
                        + boostValue.getValue() + " ";
            }
        }

        LOG.info("BoostQuery : " + boostQuery);

        String fieldListQuery = "";

        for (String field : fieldNames) {
            fieldListQuery = fieldListQuery + field;
            if (field.endsWith("_raw")) {
                fieldListQuery = fieldListQuery + "^2.0";
            }
            fieldListQuery = fieldListQuery + " ";
        }

        LOG.info("Field List Query : " + fieldListQuery);

        newQuery.add("bq", boostQuery);
        newQuery.add("qf", fieldListQuery);

        resp = solrClient.query(newQuery, SolrRequest.METHOD.POST);

        return resp;

    } catch (SolrServerException e) {
        LOG.error("Query performed on solr failed for search term : " + queryString, e);
        e.printStackTrace();

    } catch (IOException e) {
        LOG.error("Query performed on solr failed for search term : " + queryString, e);
        e.printStackTrace();

    }

    return resp;
}

From source file:org.intermine.web.autocompletion.AutoCompleter.java

License:GNU General Public License

/**
 * Returns n search results/*from   w w  w .  ja  v  a 2s . co m*/
 * @param query is the string used for search
 * @param field is the field in which you like to search (e.g. name)
 * @param className is the class in which you like to search (e.g. SOTerm)
 * @param n number of the first n search results
 * @return string array with search results and an error flag at position 0
 */
public String[] getFastList(String query, String field, String className, int n) {

    String status = "true";
    String[] stringResults = null;

    SolrClient solrClient = SolrClientHandler.getClientInstance(this.propertiesManager.getSolrUrl());

    QueryResponse resp = null;

    if (!"".equals(query) && !query.trim().startsWith("*")) {

        if (query.endsWith(" ")) {
            query = query.substring(0, query.length() - 1);
        }

        String[] tmp;
        if (query.contains(" ")) {
            tmp = query.replaceAll(" +", " ").trim().split(" ");
            query = new String();

            for (int i = 0; i < tmp.length; i++) {
                query += tmp[i];
                if (i < tmp.length - 1) {
                    query += "* AND " + field + ":";
                }
            }
        }

        try {

            SolrQuery newQuery = new SolrQuery();
            newQuery.setQuery(field + ":" + query + "*"); //adding a wildcard in the end
            newQuery.setRequestHandler("select");
            newQuery.setRows(n); // FIXME: hardcoded maximum
            newQuery.setFilterQueries(CLASSNAME_FIELD + ":" + className);

            resp = solrClient.query(newQuery);

            SolrDocumentList results = resp.getResults();

            stringResults = new String[results.size() + 1];

            for (int i = 1; i < results.size() + 1; i++) {

                try {
                    SolrDocument document = results.get(i - 1);

                    stringResults[i] = ((ArrayList<String>) document.getFieldValue(field)).get(0);

                } catch (Exception e) {
                    status = "No results! Please try again.";
                }
            }

            stringResults[0] = status;

            return stringResults;

        } catch (SolrServerException e) {
            e.printStackTrace();

        } catch (IOException e) {
            e.printStackTrace();
            status = "Please type in more characters to get results.";
            stringResults = new String[1];
            stringResults[0] = status;
        }

        return stringResults;
    }

    return null;
}

From source file:org.janusgraph.diskstorage.solr.SolrIndex.java

License:Apache License

@Override
public Stream<String> query(IndexQuery query, KeyInformation.IndexRetriever information, BaseTransaction tx)
        throws BackendException {
    final String collection = query.getStore();
    final String keyIdField = getKeyFieldId(collection);
    final SolrQuery solrQuery = new SolrQuery("*:*");
    solrQuery.set(CommonParams.FL, keyIdField);
    final String queryFilter = buildQueryFilter(query.getCondition(), information.get(collection));
    solrQuery.addFilterQuery(queryFilter);
    if (!query.getOrder().isEmpty()) {
        addOrderToQuery(solrQuery, query.getOrder());
    }/* w  ww. j a  v  a  2s . c o  m*/
    solrQuery.setStart(0);
    if (query.hasLimit()) {
        solrQuery.setRows(Math.min(query.getLimit(), batchSize));
    } else {
        solrQuery.setRows(batchSize);
    }
    return executeQuery(query.hasLimit() ? query.getLimit() : null, 0, collection, solrQuery,
            doc -> doc.getFieldValue(keyIdField).toString());
}

From source file:org.janusgraph.diskstorage.solr.SolrIndex.java

License:Apache License

private SolrQuery runCommonQuery(RawQuery query, KeyInformation.IndexRetriever information, BaseTransaction tx,
        String collection, String keyIdField) throws BackendException {
    final SolrQuery solrQuery = new SolrQuery(query.getQuery()).addField(keyIdField).setIncludeScore(true)
            .setStart(query.getOffset());
    if (query.hasLimit()) {
        solrQuery.setRows(Math.min(query.getLimit(), batchSize));
    } else {//  w w w  . ja v  a 2 s.c om
        solrQuery.setRows(batchSize);
    }
    if (!query.getOrders().isEmpty()) {
        addOrderToQuery(solrQuery, query.getOrders());
    }

    for (final Parameter parameter : query.getParameters()) {
        if (parameter.value() instanceof String[]) {
            solrQuery.setParam(parameter.key(), (String[]) parameter.value());
        } else if (parameter.value() instanceof String) {
            solrQuery.setParam(parameter.key(), (String) parameter.value());
        }
    }
    return solrQuery;
}

From source file:org.kimios.kernel.controller.impl.SolrSearchController.java

License:Open Source License

private SearchResponse quickSearchIds(Session session, String query, DMEntity entity, int start, int pageSize,
        String sortField, String sortDir) {
    String documentNameQuery = QueryBuilder.documentNameQuery(query);

    SolrQuery indexQuery = new SolrQuery();

    ArrayList<String> filterQueries = new ArrayList<String>();
    if (!getSecurityAgent().isAdmin(session.getUserName(), session.getUserSource())) {
        String aclQuery = QueryBuilder.buildAclQuery(session);
        filterQueries.add(aclQuery);//  ww w. jav  a  2 s . c o m
    }
    if (entity != null) {
        DMEntity entityLoaded = dmsFactoryInstantiator.getDmEntityFactory().getEntity(entity.getUid());
        String pathQuery = "DocumentParent:" + entityLoaded.getPath() + "/*";
        filterQueries.add(pathQuery);
    }
    indexQuery.setFilterQueries(filterQueries.toArray(new String[] {}));
    if (sortField != null) {
        indexQuery.addSortField(sortField,
                SolrQuery.ORDER.valueOf((sortDir != null ? sortDir.toLowerCase() : "asc")));
    }
    indexQuery.addSortField("score", SolrQuery.ORDER.desc);
    indexQuery.setQuery(documentNameQuery);
    if (start > -1 && pageSize > -1) {
        indexQuery.setStart(start);
        indexQuery.setRows(pageSize);
    }

    SearchResponse searchResponse = solrIndexManager.executeSolrQuery(indexQuery);
    return searchResponse;
}

From source file:org.kimios.kernel.controller.impl.SolrSearchController.java

License:Open Source License

private SolrQuery parseQueryFromListCriteria(Session session, int page, int pageSize,
        List<Criteria> criteriaList, String sortField, String sortDir) throws ParseException {

    SolrQuery indexQuery = new SolrQuery();

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    sdf.setTimeZone(TimeZone.getTimeZone("UTC"));

    ArrayList<String> aclFilterQueries = new ArrayList<String>();
    ArrayList<String> filterQueries = new ArrayList<String>();
    ArrayList<String> queries = new ArrayList<String>();
    if (!getSecurityAgent().isAdmin(session.getUserName(), session.getUserSource())) {
        String aclQuery = QueryBuilder.buildAclQuery(session);
        aclFilterQueries.add(aclQuery);/*from  w w  w  . java  2s  . com*/
    }
    for (Criteria c : criteriaList) {
        if (c.getQuery() != null && c.getQuery().trim().length() > 0 || c.getRangeMin() != null
                || c.getRangeMax() != null) {
            if (c.getFieldName().equals("DocumentName")) {
                queries.add(QueryBuilder.documentNameQuery(c.getQuery()));
            } else if (c.getFieldName().equals("DocumentBody")) {
                queries.add("DocumentBody:" + ClientUtils.escapeQueryChars(c.getQuery()));
            } else if (c.getFieldName().equals("DocumentUid")) {
                filterQueries.add("DocumentUid:" + c.getQuery());
            } else if (c.getFieldName().equals("DocumentParent")) {
                filterQueries.add(QueryBuilder.documentParentQuery(c.getQuery()));
            } else if (c.getFieldName().equals("DocumentVersionUpdateDate")) {
                queries.add(QueryBuilder.documentUpdateDateQuery("DocumentVersionUpdateDate", c.getRangeMin(),
                        c.getRangeMax()));
            } else if (c.getFieldName().equals("DocumentCreationDate")) {
                queries.add(QueryBuilder.documentUpdateDateQuery("DocumentCreationDate", c.getRangeMin(),
                        c.getRangeMax()));
            } else if (c.getFieldName().equals("DocumentTypeUid")) {
                long dtUid = Long.parseLong(c.getQuery());
                List<DocumentType> items = dmsFactoryInstantiator.getDocumentTypeFactory()
                        .getChildrenDocumentType(dtUid);
                List<DocumentType> documentTypeList = new ArrayList<DocumentType>(items);
                for (DocumentType it : items) {
                    documentTypeList.addAll(dmsFactoryInstantiator.getDocumentTypeFactory()
                            .getChildrenDocumentType(it.getUid()));
                }

                StringBuilder builder = new StringBuilder();

                builder.append("DocumentTypeUid:(" + dtUid + (documentTypeList.size() > 0 ? " OR " : ""));
                int idx = 0;
                for (DocumentType dtIt : documentTypeList) {
                    builder.append(dtIt.getUid());
                    idx++;
                    if (idx < documentTypeList.size()) {
                        builder.append(" OR ");
                    }
                }
                builder.append(")");
                filterQueries.add(builder.toString());
            } else if (c.getFieldName().startsWith("MetaData")) {
                Meta meta = dmsFactoryInstantiator.getMetaFactory().getMeta(c.getMetaId());
                if (meta != null) {
                    if (meta.getMetaType() == MetaType.STRING) {

                        String metaStringQuery = "MetaDataString_" + meta.getUid() + ":*"
                                + ClientUtils.escapeQueryChars(c.getQuery().toLowerCase()) + "*";
                        queries.add(metaStringQuery);
                    }
                    if (meta.getMetaType() == MetaType.NUMBER) {
                        Double min = null;
                        Double max = null;
                        boolean toAdd = false;
                        if (c.getRangeMin() != null && c.getRangeMin().trim().length() > 0) {
                            min = Double.parseDouble(c.getRangeMin());
                            toAdd = true;
                        }
                        if (c.getRangeMax() != null && c.getRangeMax().trim().length() > 0) {
                            max = Double.parseDouble(c.getRangeMax());
                            toAdd = true;
                        }
                        if (toAdd) {
                            String metaNumberQuery = "MetaDataNumber_" + meta.getUid() + ":["
                                    + (min != null ? min : "*") + " TO " + (max != null ? max : "*") + "]";

                            queries.add(metaNumberQuery);
                        }
                    }
                    if (meta.getMetaType() == MetaType.DATE) {
                        Date min = null;
                        Date max = null;
                        boolean toAdd = false;
                        if (c.getRangeMin() != null && c.getRangeMin().trim().length() > 0) {

                            try {
                                min = sdf.parse(c.getRangeMin());
                                toAdd = true;
                            } catch (Exception e) {
                                toAdd = false;
                            }
                        }
                        if (c.getRangeMax() != null && c.getRangeMax().trim().length() > 0) {
                            try {
                                max = sdf.parse(c.getRangeMax());
                                toAdd = true;
                            } catch (Exception e) {
                                toAdd = false;
                            }
                        }
                        if (toAdd) {
                            DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
                            df.setTimeZone(TimeZone.getTimeZone("UTC"));
                            String metaDateQuery = QueryBuilder.documentUpdateDateQuery(
                                    "MetaDataDate_" + meta.getUid(), c.getRangeMin(), c.getRangeMax());

                            queries.add(metaDateQuery);
                        }
                    }
                    if (meta.getMetaType() == MetaType.BOOLEAN) {
                        String metaBoolQuery = "MetaDataBoolean_" + meta.getUid() + ":"
                                + Boolean.parseBoolean(c.getQuery());
                        queries.add(metaBoolQuery);
                    }
                }
            }
        }
    }

    indexQuery.setFilterQueries(filterQueries.toArray(new String[] {}));
    if (sortField != null) {
        indexQuery.addSortField(sortField,
                sortDir != null ? SolrQuery.ORDER.valueOf(sortDir.toLowerCase()) : SolrQuery.ORDER.asc);
    }
    indexQuery.addSortField("score", SolrQuery.ORDER.desc);
    StringBuilder sQuery = new StringBuilder();

    for (String q : queries) {
        sQuery.append("+");
        sQuery.append(q);
        sQuery.append(" ");
    }

    if (queries.size() == 0) {
        /*
        Convert filter queries in query, to get result
         */
        for (String q : filterQueries) {
            sQuery.append("+");
            sQuery.append(q);
            sQuery.append(" ");
        }

    } else {
        filterQueries.addAll(aclFilterQueries);
        indexQuery.setFilterQueries(filterQueries.toArray(new String[] {}));

    }
    log.debug("Solr Final Query: " + sQuery);
    indexQuery.setQuery(sQuery.toString());
    if (pageSize > -1 && page > -1) {
        indexQuery.setRows(pageSize);
        indexQuery.setStart(page);
    } else {
        indexQuery.setRows(Integer.MAX_VALUE);
    }

    return indexQuery;

}

From source file:org.lareferencia.xoai.services.impl.xoai.LRSetRepository.java

License:BSD License

private List<FacetField.Count> getFacetValues(String facetFieldName) {

    try {/* w  ww . j av a  2s.  c o  m*/

        SolrQuery query = new SolrQuery("*:*");
        query.setRows(0);
        query.setFacet(true);
        query.addFacetField(facetFieldName);

        QueryResponse response = solrServer.query(query);

        return response.getFacetFields().get(0).getValues();

    } catch (SolrServerException e) {

        log.error(e.getMessage(), e);

        e.printStackTrace();
    }

    List<FacetField.Count> list = new ArrayList<FacetField.Count>();

    return list;
}