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

Introduction

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

Prototype

public SolrQuery setStart(Integer start) 

Source Link

Usage

From source file:com.thinkaurelius.titan.diskstorage.solr.Solr5Index.java

License:Apache License

@Override
public List<String> query(IndexQuery query, KeyInformation.IndexRetriever informations, BaseTransaction tx)
        throws BackendException {
    List<String> result;
    String collection = query.getStore();
    String keyIdField = getKeyFieldId(collection);
    SolrQuery solrQuery = new SolrQuery("*:*");
    String queryFilter = buildQueryFilter(query.getCondition(), informations.get(collection));
    solrQuery.addFilterQuery(queryFilter);
    if (!query.getOrder().isEmpty()) {
        List<IndexQuery.OrderEntry> orders = query.getOrder();
        for (IndexQuery.OrderEntry order1 : orders) {
            String item = order1.getKey();
            SolrQuery.ORDER order = order1.getOrder() == Order.ASC ? SolrQuery.ORDER.asc : SolrQuery.ORDER.desc;
            solrQuery.addSort(new SolrQuery.SortClause(item, order));
        }//from www  .java 2s  .  c o m
    }
    solrQuery.setStart(0);
    if (query.hasLimit()) {
        solrQuery.setRows(query.getLimit());
    } else {
        solrQuery.setRows(maxResults);
    }
    try {
        QueryResponse response = solrClient.query(collection, solrQuery);

        if (logger.isDebugEnabled())
            logger.debug("Executed query [{}] in {} ms", query.getCondition(), response.getElapsedTime());

        int totalHits = response.getResults().size();

        if (!query.hasLimit() && totalHits >= maxResults)
            logger.warn("Query result set truncated to first [{}] elements for query: {}", maxResults, query);

        result = new ArrayList<String>(totalHits);
        for (SolrDocument hit : response.getResults()) {
            result.add(hit.getFieldValue(keyIdField).toString());
        }
    } catch (IOException e) {
        logger.error("Query did not complete : ", e);
        throw new PermanentBackendException(e);
    } catch (SolrServerException e) {
        logger.error("Unable to query Solr index.", e);
        throw new PermanentBackendException(e);
    }
    return result;
}

---

From source file:com.thinkbiganalytics.search.SolrSearchService.java

License:Apache License

private QueryResponse executeSearch(String query, int size, int start) {
    final String COLLECTION_LIST = "kylo-data," + SearchIndex.DATASOURCES; //Solr admin to configure beforehand
    final String ALL_FIELDS = "*";
    final String BOLD_HIGHLIGHT_START = "<font style='font-weight:bold'>";
    final String BOLD_HIGHLIGHT_END = "</font>";

    SolrQuery solrQuery = new SolrQuery();
    solrQuery.set("q", query);
    solrQuery.setRows(size);//from  w  ww  .  j a v  a  2  s .co m
    solrQuery.setStart(start);
    solrQuery.setParam("collection", COLLECTION_LIST);
    solrQuery.setHighlight(true);
    solrQuery.set("hl.fl", ALL_FIELDS);
    solrQuery.setHighlightSimplePre(BOLD_HIGHLIGHT_START);
    solrQuery.setHighlightSimplePost(BOLD_HIGHLIGHT_END);
    solrQuery.setHighlightRequireFieldMatch(false);

    try {
        return client.query("kylo-data", solrQuery);
    } catch (SolrServerException | IOException e) {
        throw new RuntimeException("Error encountered during search.");
    }
}

---

From source file:com.tripod.solr.query.StandardSolrQueryTransformer.java

License:Apache License

@Override
public SolrQuery transform(final Q query) {
    final SolrQuery solrQuery = new SolrQuery(query.getQuery());
    solrQuery.setStart(query.getOffset());
    solrQuery.setRows(query.getRows());/*from  ww w .j  a  v  a 2 s  .  c om*/
    solrQuery.setParam("q.op", query.getDefaultOperator().name());

    if (query.getReturnFields() != null) {
        query.getReturnFields().stream().forEach(f -> solrQuery.addField(f.getName()));
    }

    if (query.getHighlightFields() != null && !query.getHighlightFields().isEmpty()) {
        solrQuery.setHighlight(true);
        query.getHighlightFields().stream().forEach(hf -> solrQuery.addHighlightField(hf.getName()));
    }

    if (query.getFacetFields() != null) {
        query.getFacetFields().stream().forEach(ff -> solrQuery.addFacetField(ff.getName()));
    }

    if (query.getSorts() != null) {
        for (Sort sort : query.getSorts()) {
            SolrQuery.ORDER solrOrder = sort.getSortOrder() == SortOrder.ASC ? SolrQuery.ORDER.asc
                    : SolrQuery.ORDER.desc;
            SolrQuery.SortClause sortClause = new SolrQuery.SortClause(sort.getField().getName(), solrOrder);
            solrQuery.addSort(sortClause);
        }
    }

    if (query.getFilterQueries() != null) {
        query.getFilterQueries().stream().forEach(fq -> solrQuery.addFilterQuery(fq));
    }

    if (query.getParams() != null) {
        query.getParams().entrySet().stream().forEach(e -> solrQuery.add(e.getKey(), e.getValue()));
    }

    return solrQuery;
}

---

From source file:com.ushahidi.swiftriver.core.solr.repository.DropDocumentRepositoryImpl.java

License:Open Source License

private SolrQuery getPreparedSolrQuery(String searchTerm, Pageable pageable) {
    // Calculate the start row
    Integer start = pageable.getPageNumber() * pageable.getPageSize();

    SolrQuery solrQuery = new SolrQuery();
    solrQuery.set("q", searchTerm);
    solrQuery.set("defType", "edismax");
    solrQuery.set("stopwords", true);
    solrQuery.set("lowercaseOperators", true);
    solrQuery.setStart(start);
    solrQuery.setRows(pageable.getPageSize());

    return solrQuery;
}

---

From source file:com.villemos.ispace.solr.SolrProducer.java

License:Open Source License

/**
 * Retrieves a number of entries from the repository, based on the configured
 * query. /*from   w  w  w.j  a v a 2  s.co  m*/
 * 
 * @param exchange
 * @throws SolrServerException 
 * @throws InvocationTargetException 
 * @throws IllegalAccessException 
 * @throws IllegalArgumentException 
 * @throws RemoteException 
 */
protected void retrieve(Exchange exchange) throws SolrServerException, IllegalArgumentException,
        IllegalAccessException, InvocationTargetException, RemoteException {

    /** Configure the request. 
     * 
     * One keywords are supported 
     *   FROMLAST. Will be replaced with the timestamp of the last retrieval (initial is 0). 
     */
    String queryString = endpoint.getQuery();
    queryString = queryString.replaceAll("FROMLAST", Long.toString(lastRetrievalTime));
    SolrQuery query = new SolrQuery(queryString);
    configureQuery(query);

    if (queryString.equals("*:*")) {
        query.setQueryType("basic");
    }

    /** If we are asked for facets, then add the facets. */
    if (endpoint.getFacets()) {
        query.setFacet(true);
        query.addFacetField(endpoint.getFacetField());
    }

    /** Search and set result set. Notice that this will return the results upto the 
     * configured number of rows. More results may thus be in the repository. */

    /** Data is either returned as a batch contained in the body of the exchange, or as
     * a stream send to the callback object in the body. The exchange header field 
     * 'solr.stream' is used to indicate which delivery mode is used. */
    if (endpoint.isStream() == false) {

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

        exchange.getOut().getHeaders().put(SolrOptions.count, (int) response.getResults().getNumFound());
        if (endpoint.isCount() == false) {
            ResultSet results;
            try {
                results = Utilities.getResultSet(response, query.getRows(), queryString);
                exchange.getOut().setBody(results);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    } else {
        /***/
        Statistics statistics = new Statistics();

        int maxNumberOfHits = query.getRows();

        /** When streaming, we retrieve in chunks. */
        int streamBatchSize = 100 > maxNumberOfHits ? maxNumberOfHits : 100;
        query.setRows(streamBatchSize);
        Integer index = query.getStart() == null ? 0 : query.getStart();

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

        int numberOfHits = (int) response.getResults().getNumFound();
        if (numberOfHits > maxNumberOfHits) {
            numberOfHits = maxNumberOfHits;
        }

        boolean deliverOnes = false;

        do {
            ResultSet set;
            try {
                set = Utilities.getResultSet(response, maxNumberOfHits, queryString);

                /** Update the statistics. */
                statistics.maxScore = statistics.maxScore > set.statistics.maxScore ? statistics.maxScore
                        : set.statistics.maxScore;
                statistics.totalFound = set.statistics.totalFound;
                statistics.totalRequested = set.statistics.totalRequested;
                statistics.queryTime += set.statistics.queryTime;
                statistics.totalReturned += set.statistics.totalReturned;

                /** Deliver latest statistics. */
                Exchange newExchange = new DefaultExchange(endpoint.getCamelContext());
                newExchange.getIn().setBody(statistics);
                endpoint.getCamelContext().createProducerTemplate().send("direct:results", newExchange);

                /** Deliver the data that is the same for each sequential query, i.e. facets and suggestions. */
                if (deliverOnes == false) {
                    for (Facet facet : set.facets) {
                        newExchange = new DefaultExchange(endpoint.getCamelContext());
                        newExchange.getIn().setBody(facet);
                        endpoint.getCamelContext().createProducerTemplate().send("direct:results", newExchange);
                    }
                    for (Suggestion suggestion : set.suggestions) {
                        newExchange = new DefaultExchange(endpoint.getCamelContext());
                        newExchange.getIn().setBody(suggestion);
                        endpoint.getCamelContext().createProducerTemplate().send("direct:results", newExchange);
                    }

                    deliverOnes = true;
                }

                /** Deliver the found information objects. */
                for (Object document : set.informationobjects) {
                    newExchange = new DefaultExchange(endpoint.getCamelContext());
                    newExchange.getIn().setBody(document);
                    endpoint.getCamelContext().createProducerTemplate().send("direct:results", newExchange);
                }
                index += streamBatchSize;

                if (numberOfHits > index && statistics.totalReturned < statistics.totalFound) {
                    query.setStart(index);

                    long numberMissing = numberOfHits - statistics.totalReturned;
                    if (numberMissing < streamBatchSize) {
                        query.setRows((int) numberMissing);
                    }

                    response = endpoint.getServer().query(query);
                } else {
                    break;
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }

        } while (true);
    }
}

---

From source file:com.zb.app.external.lucene.solr.utils.BaseSolrQueryConvert.java

License:Open Source License

public static SolrQuery createSuggestQuery(SuggestQuery query) {
    SolrQuery solrQuery = new SolrQuery();
    StringBuilder sb = new StringBuilder();
    sb.append("suggest:").append(query.getPrefix()).append("*");
    solrQuery.setQuery(sb.toString());/*  w w  w  .  j  a v a2s  .  co  m*/
    solrQuery.addField(query.getField());
    if (StringUtils.isNotEmpty(query.getSortFiled())) {
        solrQuery.addSort(query.getSortFiled(), SolrQuery.ORDER.desc);
    }
    solrQuery.setStart(0);
    solrQuery.setRows(100);

    // solrQuery.set("qt", "/terms");
    // solrQuery.setFacet(true);
    // solrQuery.setFacetMinCount(1);
    // solrQuery.setFacetLimit(10);
    // solrQuery.setFacetPrefix(query.getField(), query.getPrefix());
    // solrQuery.setFacetSort(query.getSortFiled());
    // solrQuery.setRows(0);
    // solrQuery.setQuery("*");

    // solrQuery.setTerms(true);
    // solrQuery.setTermsLimit(10);
    // solrQuery.setTermsMinCount(1);
    // solrQuery.setTermsPrefix(query.getPrefix());
    // solrQuery.setTermsRegexFlag(query.getField());
    // solrQuery.setTermsSortString(query.getSortFiled());
    return solrQuery;
}

---

From source file:com.zb.app.external.lucene.solr.utils.BaseSolrQueryConvert.java

License:Open Source License

protected static SolrQuery createSearchQuery(List<String> params, List<String> fiters,
        SearchQuery searchQuery) {//w ww .  j  a v  a2  s  .  c  o  m
    SolrQuery solrQuery = new SolrQuery();
    String query = null;
    if (Argument.isEmpty(params)) {
        query = ("*:*");
    } else {
        query = StringUtils.join(params, " AND ");
        if (!StringUtils.join(params.toArray()).contains("*")) {
            solrQuery.setRequestHandler("/browse");
        }
    }
    if (Argument.isNotEmpty(fiters)) {
        solrQuery.setFilterQueries(StringUtils.join(fiters, " AND "));
    }
    solrQuery.setQuery(query);
    solrQuery.setStart(searchQuery.getStart());
    solrQuery.setRows(searchQuery.getRows());
    if (StringUtils.isNotBlank(searchQuery.getSortFiled())) {
        solrQuery.addSort(searchQuery.getSortFiled(), searchQuery.getOrderBy());
    }
    return solrQuery;
}

---

From source file:cz.incad.vdk.client.tools.Search.java

License:Open Source License

public String getAsXML() throws JSONException {

    try {// w  w w.  j  a  v  a  2 s  . c  om

        String q = req.getParameter("q");
        SolrQuery query = new SolrQuery();
        if (q == null || q.equals("")) {
            q = "*:*";
            query.setSort("_version_", SolrQuery.ORDER.desc);
        }
        query.setQuery(q);
        query.set("q.op", "AND");
        query.setFacet(true);
        query.setStart(getStart());
        query.setRows(getRows());

        if (LoggedController.isLogged(req)) {
            query.addFacetField(opts.getStrings("user_facets"));
        }
        query.addFacetField(opts.getStrings("facets"));

        query.setFacetMinCount(1);

        JSONObject others = opts.getJSONObject("otherParams");
        Iterator keys = others.keys();
        while (keys.hasNext()) {
            String key = (String) keys.next();
            Object val = others.get(key);
            if (val instanceof Integer) {
                query.set(key, (Integer) val);
            } else if (val instanceof String) {
                query.set(key, (String) val);
            } else if (val instanceof Boolean) {
                query.set(key, (Boolean) val);
            }

        }
        addFilters(query);

        return IndexerQuery.xml(query);
    } catch (IOException ex) {
        LOGGER.log(Level.SEVERE, null, ex);
        return null;
    }
}

---

From source file:cz.zcu.kiv.eegdatabase.logic.search.FulltextSearchService.java

License:Apache License

/**
 * Configures the query to be processed.
 * @param inputQuery The query string.//from w  ww. j  a va 2  s  . c o m
 * @param start Index of the first returned result.
 * @param count Number of results we wish to display.
 * @return Configured query.
 */
private SolrQuery configureQuery(String inputQuery, ResultCategory category, int start, int count) {
    SolrQuery query = new SolrQuery();
    query.setQuery(inputQuery);
    if (category != null && !category.equals(ResultCategory.ALL)) {
        query.addFilterQuery(IndexField.CLASS.getValue() + ":\"" + category.getValue() + "\"");
    }
    query.setStart(start);
    query.setRows(count);
    query.setHighlightSimplePre(FullTextSearchUtils.HIGHLIGHTED_TEXT_BEGIN);
    query.setHighlightSimplePost(FullTextSearchUtils.HIGHLIGHTED_TEXT_END);
    return query;
}

---

From source file:datacite.oai.provider.service.MDSSearchServiceSolrImpl.java

License:Open Source License

static SolrQuery constructSolrQuery(Date updateDateFrom, Date updateDateTo, String setspec, int offset,
        int length) throws ServiceException {
    SolrQuery query = new SolrQuery();
    query.setQuery("*:*");
    query.setRows(length);//from  w  ww .  j  a v a2 s . c o  m
    query.setStart(offset);
    query.setSortField("updated", ORDER.asc);

    setspec = StringUtils.trimToEmpty(setspec);
    if (setspec.contains(Constants.Set.BASE64_PART_DELIMITER)) {
        String split[] = setspec.split(Constants.Set.BASE64_PART_DELIMITER, 2);
        setspec = split[0];
        String base64 = split[1];
        String solrfilter = new String(Base64.decodeBase64(base64));
        logger.info("decoded base64 setspec: " + solrfilter);
        solrfilter = solrfilter.replaceAll("^[?&]+", "");

        List<NameValuePair> params = URLEncodedUtils.parse(solrfilter, Charset.defaultCharset());
        for (NameValuePair param : params) {
            String name = param.getName();
            String value = param.getValue();
            if (name.equals("q"))
                query.setQuery(value);
            else if (name.equals("fq"))
                query.addFilterQuery(value);
            else
                throw new ServiceException("parameter '" + name + "' is not supported");
        }
    }

    if (setspec != null && setspec.trim().length() > 0) {
        setspec = setspec.trim().toUpperCase();

        String field = setspec.contains(".") ? "datacentre_symbol" : "allocator_symbol";
        query.addFilterQuery(field + ":" + setspec);
    }

    String from = dateFormat.format(updateDateFrom);
    String to = dateFormat.format(updateDateTo);

    query.addFilterQuery("updated:[" + from + " TO " + to + "]");

    query.setParam(CommonParams.QT, "/api");

    return query;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• »