Example usage for org.apache.solr.client.solrj SolrQuery 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:net.yacy.search.query.QueryParams.java

License:Open Source License

private SolrQuery getBasicParams(boolean getFacets, List<String> fqs) {
    final SolrQuery params = new SolrQuery();
    params.setParam("defType", "edismax");
    params.setParam(DisMaxParams.QF, CollectionSchema.text_t.getSolrFieldName() + "^1.0");
    params.setStart(this.offset);
    params.setRows(this.itemsPerPage);
    params.setFacet(false);/*w  ww  .j av a2 s  . c o  m*/

    if (this.ranking.coeff_date == RankingProfile.COEFF_MAX) {
        // set a most-recent ordering
        params.setSort(new SortClause(CollectionSchema.last_modified.getSolrFieldName(), SolrQuery.ORDER.desc));
        //params.setSortField(CollectionSchema.last_modified.getSolrFieldName(), ORDER.desc); // deprecated in Solr 4.2
    }

    // add site facets
    fqs.addAll(getFacetsFilterQueries());
    if (fqs.size() > 0) {
        params.setFilterQueries(fqs.toArray(new String[fqs.size()]));
    }

    // set facet query attributes
    if (getFacets && this.facetfields.size() > 0) {
        params.setFacet(true);
        params.setFacetMinCount(1);
        params.setFacetLimit(FACETS_STANDARD_MAXCOUNT);
        params.setFacetSort(FacetParams.FACET_SORT_COUNT);
        params.setParam(FacetParams.FACET_METHOD, FacetParams.FACET_METHOD_fcs);
        for (String field : this.facetfields)
            params.addFacetField("{!ex=" + field + "}" + field); // params.addFacetField("{!ex=" + field + "}" + field);
        if (this.facetfields.contains(CollectionSchema.dates_in_content_dts.name())) {
            params.setParam("facet.range", CollectionSchema.dates_in_content_dts.name());
            @SuppressWarnings({ "static-access", "deprecation" })
            String start = TrieDateField
                    .formatExternal(new Date(System.currentTimeMillis() - 1000L * 60L * 60L * 24L * 3));
            @SuppressWarnings({ "static-access", "deprecation" })
            String end = TrieDateField
                    .formatExternal(new Date(System.currentTimeMillis() + 1000L * 60L * 60L * 24L * 3));
            params.setParam(
                    "f." + CollectionSchema.dates_in_content_dts.getSolrFieldName() + ".facet.range.start",
                    start);
            params.setParam(
                    "f." + CollectionSchema.dates_in_content_dts.getSolrFieldName() + ".facet.range.end", end);
            params.setParam(
                    "f." + CollectionSchema.dates_in_content_dts.getSolrFieldName() + ".facet.range.gap",
                    "+1DAY");
            params.setParam("f." + CollectionSchema.dates_in_content_dts.getSolrFieldName() + ".facet.sort",
                    "index");
            params.setParam("f." + CollectionSchema.dates_in_content_dts.getSolrFieldName() + ".facet.limit",
                    Integer.toString(FACETS_DATE_MAXCOUNT)); // the year constraint should cause that limitation already
        }
        //for (String k: params.getParameterNames()) {ArrayList<String> al = new ArrayList<>(); for (String s: params.getParams(k)) al.add(s); System.out.println("Parameter: " + k + "=" + al.toString());}
        //http://localhost:8090/solr/collection1/select?q=*:*&rows=0&facet=true&facet.field=dates_in_content_dts&f.dates_in_content_dts.facet.limit=730&f.dates_in_content_dts.facet.sort=index
    } else {
        params.setFacet(false);
    }
    params.setFields("*", "score"); // we need the score for post-ranking
    return params;
}

---

From source file:nl.info.magnolia.solr.app.SolrManagementSubApp.java

License:Open Source License

protected long getNumberOfDocumentsInSolrIndex() {
    long numberOfDocuments = 0;
    try {/*  www .  j  av  a  2 s.co m*/
        SolrQuery query = new SolrQuery("*:*");
        query.setRows(0); // don't actually request any data
        numberOfDocuments = magnoliaSolrBridge.getSolrClient().query(query).getResults().getNumFound();
    } catch (SolrServerException | IOException e) {
        LOG.error("Failed to perform query on Solr server. Returning '0' documents as default.", e);
    }
    return numberOfDocuments;
}

---

From source file:nl.knaw.dans.common.solr.converter.SolrQueryRequestConverter.java

License:Apache License

public static SolrQuery convert(SearchRequest request) throws SolrSearchEngineException {
    SolrQuery queryObj = new SolrQuery();

    // set query//from w w w.  j  a  va2s. c  o  m
    String query = "";
    String qstr = request.getQuery().getQueryString();
    if (qstr != null)
        query += qstr;
    FieldSet<?> fieldQueries = request.getFieldQueries();
    if (fieldQueries != null) {
        for (Field<?> fieldQuery : fieldQueries) {
            query += fieldQueryToString(fieldQuery) + " ";
        }
    }
    queryObj.setQuery(query);

    // set filter queries
    FieldSet<?> filterQueries = request.getFilterQueries();
    if (filterQueries != null) {
        int i = 0;
        String[] fq = new String[filterQueries.size()];
        for (Field<?> field : filterQueries) {
            fq[i] = fieldQueryToString(field);
            i++;
        }
        queryObj.setFilterQueries(fq);
    }

    // set sort fields
    List<SortField> sortFields = request.getSortFields();
    if (sortFields != null) {
        for (SortField sortField : sortFields) {
            ORDER order;
            if (sortField.getValue().equals(SortOrder.DESC))
                order = ORDER.desc;
            else
                order = ORDER.asc;
            String sortFieldName = sortField.getName();
            if (sortField.getSortType().equals(SortType.BY_RELEVANCE_SCORE))
                sortFieldName = "score";
            queryObj.addSortField(sortFieldName, order);
        }
    }

    // faceting enabled
    Set<String> facetFields = request.getFacetFields();
    boolean enableFaceting = facetFields != null && facetFields.size() > 0;
    queryObj.setFacet(enableFaceting);
    if (enableFaceting) {
        for (String facetField : facetFields) {
            queryObj.addFacetField(facetField);
        }
    }

    // hit highlighting
    queryObj.setHighlight(request.isHighlightingEnabled());

    // paging
    queryObj.setRows(request.getLimit());
    queryObj.setStart(request.getOffset());

    // misc settings
    queryObj.setIncludeScore(true);

    return queryObj;
}

---

From source file:nl.knaw.huygens.timbuctoo.index.solr.SolrIndex.java

License:Open Source License

private void addResultsOfPartialQuery(List<String> ids, List<Map<String, Object>> results,
        List<SolrQuery.SortClause> sortClauses) throws SearchException {
    StringBuilder queryBuilder = new StringBuilder(Entity.INDEX_FIELD_ID);
    queryBuilder.append(" : (");
    boolean isFirst = true;
    for (String id : ids) {
        if (!isFirst) {
            queryBuilder.append(" OR ");
        }/*from w  ww.  j a  v  a 2  s.  c  om*/
        queryBuilder.append(id);
        isFirst = false;
    }
    queryBuilder.append(")");

    SolrQuery query = new SolrQuery(queryBuilder.toString());

    query.setRows(ids.size());
    query.setSorts(sortClauses);

    results.addAll(getMultiRawResults(query));
}

---

From source file:no.sesat.search.query.token.SolrTokenEvaluator.java

License:Open Source License

/**
 * Search solr and find out if the given tokens are company, firstname, lastname etc
 * @param query//from   w w w  .  ja  v  a2 s .  c om
 */
@SuppressWarnings("unchecked")
private Map<String, List<TokenMatch>> query(final String query) throws EvaluationException {

    LOG.trace("queryFast( " + query + " )");
    Map<String, List<TokenMatch>> result = null;

    if (query != null && 0 < query.length()) {

        try {
            result = (Map<String, List<TokenMatch>>) CACHE_QUERY.getFromCache(query, REFRESH_PERIOD);

        } catch (NeedsRefreshException nre) {

            boolean updatedCache = false;
            result = new HashMap<String, List<TokenMatch>>();
            String url = null;

            try {
                final String token = query.replaceAll("\"", "");

                // set up query
                final SolrQuery solrQuery = new SolrQuery().setQuery("list_entry_shingle:\"" + token + "\"")
                        .setRows(INITIAL_ROWS_TO_FETCH);

                // when the root logger is set to DEBUG do not limit connection times
                if (Logger.getRootLogger().getLevel().isGreaterOrEqual(Level.INFO)) {
                    // default timeout is half second. TODO make configuration.
                    solrQuery.setTimeAllowed(500);
                }

                // query for hits
                QueryResponse response = factory.getSolrServer().query(solrQuery);
                final int numberOfHits = (int) response.getResults().getNumFound();

                boolean more = false;
                do {
                    DUMP.info(solrQuery.toString());

                    final SolrDocumentList docs = response.getResults();

                    // iterate through docs
                    for (SolrDocument doc : docs) {

                        final String name = (String) doc.getFieldValue("list_name");
                        final String exactname = EXACT_PREFIX + name;

                        // remove words made solely of characters that the parser considers whitespace
                        final String hit = ((String) doc.getFieldValue("list_entry"))
                                .replaceAll("\\b" + SKIP_REGEX + "+\\b", " ");

                        final String synonym = (String) doc.getFieldValue("list_entry_synonym");

                        if (factory.usesListName(name, exactname)) {

                            addMatch(name, hit, synonym, query, result);

                            if (hit.equalsIgnoreCase(query.trim())) {

                                addMatch(exactname, hit, synonym, query, result);
                            }
                        }
                    }

                    int rest = numberOfHits - INITIAL_ROWS_TO_FETCH;
                    if (!more && rest > 0) {
                        more = true;
                        solrQuery.setStart(INITIAL_ROWS_TO_FETCH);
                        solrQuery.setRows(rest);
                        // query
                        response = factory.getSolrServer().query(solrQuery);
                    } else {
                        more = false;
                    }
                } while (more);

                result = Collections.<String, List<TokenMatch>>unmodifiableMap(result);
                CACHE_QUERY.putInCache(query, result);
                updatedCache = true;

            } catch (SolrServerException ex) {
                LOG.error(ex.getMessage(), ex);
                throw new EvaluationException(ERR_QUERY_FAILED + url, ex);

            } finally {
                if (!updatedCache) {
                    CACHE_QUERY.cancelUpdate(query);
                }
            }
        }
    } else {
        result = Collections.<String, List<TokenMatch>>emptyMap();
    }
    return result;
}

---

From source file:org.aksw.simba.bengal.triple2nl.nlp.relation.BoaPatternSelector.java

License:Apache License

/**
 * Returns all patterns from the index and their features for reverb and the
 * wordnet distance and the overall boa-boaScore.
 * //from   w  w  w . ja  v  a  2 s  .  c  om
 * @param propertyUri
 *            the property URI
 * @return a list of patterns
 */
private static Set<Pattern> querySolrIndex(String propertyUri) {

    Map<Integer, Pattern> patterns = new HashMap<>();

    try {

        SolrQuery query = new SolrQuery("uri:\"" + propertyUri + "\"");
        query.addField("REVERB");
        query.addField("WORDNET_DISTANCE");
        query.addField("SUPPORT_NUMBER_OF_PAIRS_LEARNED_FROM");
        query.addField("pos");
        query.addField("boa-score");
        query.addField("nlr-var");
        query.addField("nlr-no-var");
        query.setRows(10000);
        QueryResponse response = server.query(query);
        SolrDocumentList docList = response.getResults();

        // return the first list of types
        for (SolrDocument d : docList) {

            Pattern pattern = new Pattern();
            pattern.naturalLanguageRepresentation = (String) d.get("nlr-var");
            pattern.naturalLanguageRepresentationWithoutVariables = (String) d.get("nlr-no-var");
            pattern.features.put("REVERB", Double.valueOf((String) d.get("REVERB")));
            pattern.features.put("WORDNET_DISTANCE", Double.valueOf((String) d.get("WORDNET_DISTANCE")));
            pattern.features.put("SUPPORT_NUMBER_OF_PAIRS_LEARNED_FROM",
                    Double.valueOf((String) d.get("SUPPORT_NUMBER_OF_PAIRS_LEARNED_FROM")));
            pattern.posTags = (String) d.get("pos");
            pattern.boaScore = Double.valueOf((String) d.get("boa-score"));
            pattern.naturalLanguageScore = calculateNaturalLanguageScore(pattern);

            // since ?D? and ?R? are removed so two patterns might look the
            // same
            if (isSuitable(pattern)) {

                // merge the pattern
                if (patterns.containsKey(pattern.hashCode())) {

                    Pattern p = patterns.get(pattern.hashCode());
                    p.features.put("REVERB", pattern.features.get("REVERB") + p.features.get("REVERB"));
                    p.features.put("WORDNET_DISTANCE",
                            pattern.features.get("WORDNET_DISTANCE") + p.features.get("WORDNET_DISTANCE"));
                    p.features.put("SUPPORT_NUMBER_OF_PAIRS_LEARNED_FROM",
                            pattern.features.get("SUPPORT_NUMBER_OF_PAIRS_LEARNED_FROM")
                                    + p.features.get("SUPPORT_NUMBER_OF_PAIRS_LEARNED_FROM"));
                    p.boaScore += pattern.boaScore;
                    p.naturalLanguageScore += pattern.naturalLanguageScore;
                    patterns.put(pattern.hashCode(), p);
                } else {

                    patterns.put(pattern.hashCode(), pattern);
                }
            }
        }
    } catch (SolrServerException e) {

        System.out.println("Could not execute query: " + e);
        e.printStackTrace();
    }
    return new HashSet<>(patterns.values());
}

---

From source file:org.ala.dao.FulltextSearchDaoImplSolr.java

License:Open Source License

private QueryResponse getSolrQueryResponse(SolrQuery solrQuery, String[] filterQuery, Integer pageSize,
        Integer startIndex, String sortField, String sortDirection) throws Exception {
    if (logger.isDebugEnabled()) {
        logger.debug(solrQuery.getQuery());
    }//  w ww.j  a  va  2s  .c  o m

    // set the facet query if set
    addFqs(solrQuery, filterQuery);

    solrQuery.setRows(pageSize);
    solrQuery.setStart(startIndex);
    solrQuery.setSortField(sortField, ORDER.valueOf(sortDirection));

    // do the Solr search
    return solrUtils.getSolrServer().query(solrQuery); // can throw exception
}

---

From source file:org.ala.dao.FulltextSearchDaoImplSolr.java

License:Open Source License

/**
 * @see org.ala.dao.FulltextSearchDao#writeSpeciesByRegionAndHigherTaxon(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.io.OutputStream)
 */// www.j a  va  2s .  c o m
public int writeSpeciesByRegionAndHigherTaxon(String regionType, String regionName, String rank,
        List<String> higherTaxa, OutputStream output) throws Exception {
    int resultsCount = 0;
    try {
        StringBuffer queryStringBuffer = constructQueryForRegion(regionType, regionName, rank, higherTaxa,
                false);
        SolrQuery solrQuery = new SolrQuery();
        solrQuery.setQueryType("standard");
        solrQuery.setRows(maxDownloadForConcepts);
        solrQuery.setQuery(queryStringBuffer.toString());

        int startIndex = 0;
        int pageSize = 1000;

        SearchResultsDTO results = doSolrQuery(solrQuery, (String[]) null, pageSize, startIndex, "score",
                "asc");
        CSVWriter csvWriter = new CSVWriter(new OutputStreamWriter(output), '\t', '"');

        csvWriter.writeNext(new String[] { "GUID", "Scientific name", "Taxon rank", "Common name",
                "Conservation status in Australia", "Conservation status in ACT", "Conservation status in NSW",
                "Conservation status in NT", "Conservation status in QLD", "Conservation status in SA",
                "Conservation status in TAS", "Conservation status in VIC", "Conservation status in WA" });

        while (results.getResults().size() > 0 && resultsCount <= maxDownloadForConcepts) {
            logger.debug("Start index: " + startIndex);
            List<SearchTaxonConceptDTO> concepts = results.getResults();
            for (SearchTaxonConceptDTO concept : concepts) {
                resultsCount++;
                String[] record = new String[] { concept.getGuid(), concept.getName(), concept.getRank(),
                        concept.getCommonNameSingle(), concept.getConservationStatusAUS(),
                        concept.getConservationStatusACT(), concept.getConservationStatusNSW(),
                        concept.getConservationStatusNT(), concept.getConservationStatusQLD(),
                        concept.getConservationStatusSA(), concept.getConservationStatusTAS(),
                        concept.getConservationStatusVIC(), concept.getConservationStatusWA(), };
                csvWriter.writeNext(record);
                csvWriter.flush();
            }
            startIndex += pageSize;
            results = doSolrQuery(solrQuery, null, pageSize, startIndex, "score", "asc");
        }

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

---

From source file:org.ala.dao.FulltextSearchDaoImplSolr.java

License:Open Source License

/**
 * Retrieves a simple count using the supplied query 
 * /*from ww  w  .  j  ava2  s  .c  om*/
 * @param query
 * @return
 * @throws SolrServerException
 */
private int doCountQuery(String query) throws Exception {

    logger.info("Count query:  " + query);

    //do a query to retrieve a count
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQueryType("standard");
    solrQuery.setFacet(false);
    solrQuery.setFacetMinCount(0);
    solrQuery.setFacetLimit(10000);
    solrQuery.setRows(0);
    solrQuery.setStart(0);
    solrQuery.setQuery(query);

    QueryResponse qr = solrUtils.getSolrServer().query(solrQuery); // can throw exception
    SolrDocumentList sdl = qr.getResults();
    return (int) sdl.getNumFound();
}

---

From source file:org.ala.dao.FulltextSearchDaoImplSolr.java

License:Open Source License

/**
 * Helper method to create SolrQuery object and add facet settings
 *
 * @return solrQuery the SolrQuery//  www.  j a  va  2s.  c o  m
 */
protected SolrQuery initSolrQuery(String[] facets) {
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQueryType("standard");
    if (facets == null) {
        //use the default set
        solrQuery.setFacet(true);
        solrQuery.addFacetField("idxtype");
        solrQuery.addFacetField("australian_s");
        solrQuery.addFacetField("speciesGroup");
        solrQuery.addFacetField("speciesSubgroup");
        //solrQuery.addFacetField("kingdom");
        solrQuery.addFacetField("rank");
        //solrQuery.addFacetField("rankId");
        //solrQuery.addFacetField("pestStatus");
        //        solrQuery.addFacetField("conservationStatus");
        solrQuery.addFacetField("conservationStatusAUS");
        solrQuery.addFacetField("conservationStatusACT");
        solrQuery.addFacetField("conservationStatusNSW");
        solrQuery.addFacetField("conservationStatusNT");
        solrQuery.addFacetField("conservationStatusQLD");
        solrQuery.addFacetField("conservationStatusSA");
        solrQuery.addFacetField("conservationStatusTAS");
        solrQuery.addFacetField("conservationStatusVIC");
        solrQuery.addFacetField("conservationStatusWA");
        solrQuery.addFacetField("category_m_s");
        solrQuery.addFacetField("category_NSW_m_s");
        solrQuery.addFacetField("category_ACT_m_s");
        solrQuery.addFacetField("category_QLD_m_s");
        solrQuery.addFacetField("category_SA_m_s");
        solrQuery.addFacetField("category_NT_m_s");
        solrQuery.addFacetField("category_TAS_m_s");
        solrQuery.addFacetField("category_WA_m_s");
        solrQuery.addFacetField("category_VIC_m_s");
    } else {
        solrQuery.addFacetField(facets);
    }

    solrQuery.setFacetMinCount(1);
    solrQuery.setRows(10);
    solrQuery.setStart(0);

    //add highlights
    solrQuery.setHighlight(true);
    solrQuery.setHighlightFragsize(80);
    solrQuery.setHighlightSnippets(2);
    solrQuery.setHighlightSimplePre("<strong>");
    solrQuery.setHighlightSimplePost("</strong>");
    solrQuery.add("hl.usePhraseHighlighter", "true");
    solrQuery.addHighlightField("commonName");
    solrQuery.addHighlightField("scientificName");
    solrQuery.addHighlightField("pestStatus");
    solrQuery.addHighlightField("conservationStatus");
    solrQuery.addHighlightField("simpleText");
    solrQuery.addHighlightField("content");

    return solrQuery;
}

---

• «
• 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
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• »