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:fr.aliacom.obm.common.contact.ContactDaoJdbcImpl.java

License:Open Source License

private List<Contact> searchContact(AccessToken at, Collection<AddressBook> addrBooks, Connection con,
        String query, int limit, Integer offset)
        throws MalformedURLException, SQLException, LocatorClientException {

    Set<Integer> contactIds = new HashSet<Integer>();

    if (addrBooks.size() > 0) {
        SolrHelper solrHelper = solrHelperFactory.createClient(at);
        CommonsHttpSolrServer solrServer = solrHelper.getSolrContact();
        StringBuilder sb = new StringBuilder();
        sb.append("-is:archive ");
        sb.append("+addressbookId:(");
        int idx = 0;
        for (AddressBook book : addrBooks) {
            if (idx > 0) {
                sb.append(" OR ");
            }/*from   w  ww .  ja v  a2 s .c o m*/
            sb.append(book.getUid());
            idx++;
        }
        sb.append(")");
        if (query != null && !"".equals(query)) {
            sb.append(" +(displayname:(");
            sb.append(query.toLowerCase());
            sb.append("*) OR firstname:(");
            sb.append(query.toLowerCase());
            sb.append("*) OR lastname:(");
            sb.append(query.toLowerCase());
            sb.append("*) OR email:(");
            sb.append(query.toLowerCase());
            sb.append("*))");
        }
        SolrQuery params = new SolrQuery();
        params.setQuery(sb.toString());
        params.setIncludeScore(true);
        params.setRows(limit);
        params.setStart(offset);

        try {
            QueryResponse resp = solrServer.query(params);

            SolrDocumentList results = resp.getResults();
            if (logger.isDebugEnabled()) {
                logger.debug(
                        "SOLR query time for " + results.size() + " results: " + resp.getElapsedTime() + "ms.");
            }

            for (int i = 0; i < limit && i < results.size(); i++) {
                SolrDocument doc = results.get(i);
                Map<String, Object> payload = doc.getFieldValueMap();
                contactIds.add((Integer) payload.get("id"));
            }
        } catch (SolrServerException e) {
            logger.error("Error querying server for '" + sb.toString() + " url: "
                    + ClientUtils.toQueryString(params, false), e);
        }
    }

    ContactResults contactResults = loadContactsFromDB(contactIds, con, limit);

    if (!contactResults.contactMap.isEmpty()) {
        loadPhones(con, contactResults.contactMap);
        loadIMIdentifiers(con, contactResults.contactMap);
        loadWebsites(con, contactResults.contactMap);
        loadAddresses(at, con, contactResults.contactMap);
        loadEmails(con, contactResults.contactMap);
        loadBirthday(con, contactResults.contactMap);
        loadAnniversary(con, contactResults.contactMap);
    }

    return contactResults.contactList;
}

From source file:fr.aliasource.index.solr.SolrClient.java

License:GNU General Public License

private SolrParams createParams(String query) {
    SolrQuery sq = new SolrQuery();
    sq.setQuery(query);/*  ww  w.  jav a2s  .  co m*/
    sq.setFilterQueries("type:" + getType());
    sq.setIncludeScore(true);
    sq.setRows(Integer.MAX_VALUE);
    sq.addSortField("date", SolrQuery.ORDER.desc);
    return sq;
}

From source file:fr.cnes.sitools.metacatalogue.resources.opensearch.AbstractOpensearchSearchResource.java

License:Open Source License

protected Representation opensearchQuery(Representation repr, Form query, SolrServer server,
        ThesaurusSearcher searcher) {//from  w  w  w  .ja  va 2 s  .  c o  m
    SolrQuery solrQuery = new SolrQuery();

    Integer count = getIntegerParameter(query, OpenSearchQuery.COUNT);
    Integer startIndex = getIntegerParameter(query, OpenSearchQuery.START_INDEX);
    Integer startPage = getIntegerParameter(query, OpenSearchQuery.START_PAGE);

    int start = count * (startPage - 1) + startIndex - 1; // index in solr start at 0, not a 1
    if (start < 0) {
        start = 0;
    }
    int rows = count;

    solrQuery.setStart(start);
    solrQuery.setRows(rows);
    solrQuery.add("df", "searchTerms");

    // addGeometryCriteria(solrQuery, query);
    try {
        setQuery(solrQuery, query);
        setFacet(solrQuery);

        getLogger().log(Level.INFO, "SOLR query : " + solrQuery.toString());

        QueryResponse rsp = server.query(solrQuery);

        boolean isAuthenticated = getClientInfo().isAuthenticated();
        SitoolsSettings settings = getSettings();
        String applicationBaseUrl = settings.getPublicHostDomain() + application.getAttachementRef();

        // Reference ref = new Reference(getRequest().getResourceRef().getBaseRef());
        Reference ref = new Reference(applicationBaseUrl + "/" + getReference().getLastSegment());

        ref.setQuery(query.getQueryString());

        repr = new GeoJsonMDEORepresentation(rsp, isAuthenticated, applicationBaseUrl, ref, 1,
                OpenSearchQuery.START_INDEX.getParamName(), OpenSearchQuery.COUNT.getParamName(),
                searcher.getAllConceptsAsMap(getLanguage()), thesaurusFacetFields);
    } catch (SolrServerException e) {
        throw new ResourceException(Status.SERVER_ERROR_INTERNAL, "Error while querying solr index", e);
    } catch (Exception e) {
        throw new ResourceException(Status.SERVER_ERROR_INTERNAL, "Error while querying solr index", e);
    }
    return repr;
}

From source file:fr.gael.dhus.database.DatabasePostInit.java

License:Open Source License

private void doReindex() {
    boolean reindex = Boolean.getBoolean("dhus.solr.reindex");
    LOGGER.info("Full solr reindex (dhus.solr.reindex) requested by user ({})", reindex);

    if (reindex) {
        searchService.fullReindex();/*from w w  w  . j a v  a  2  s  .  c om*/
    } else {
        boolean fixUUIDs = Boolean.getBoolean("dhus.solr.fixuuids");
        LOGGER.info("Solr reindex to fix UUIDs (dhus.solr.fixuuids) requested by user ({})", fixUUIDs);
        if (fixUUIDs) {
            SolrQuery query = new SolrQuery("-uuid:*"); // Select all not having a UUID
            query.setRows(10_000_000); // 10M products to be returned (may cause an OOM exception)
            searchService.partialReindex(query, false);
        }
    }
}

From source file:fr.gael.dhus.search.SearchResult.java

License:Open Source License

void initQuery() {
    if (query == null) {
        SolrQuery query = new SolrQuery();
        query.setQuery(BOOST_FUNCTION_SECTION + squery);
        query.setRows(fetchSize);
        if (this.filterQuery != null) {
            query.addFilterQuery(this.filterQuery);
        }//from w w w.  j av  a 2s  .c  o m

        if (Boolean.parseBoolean(System.getProperty("solr.filter.user", "false"))) {
            SecurityService secuService = ApplicationContextProvider.getBean(SecurityService.class);

            User user = secuService.getCurrentUser();
            if (user == null) {
                user = ApplicationContextProvider.getBean(UserDao.class).getRootUser();
            }
            query.add(SolrUtils.CURRENT_USER_ID, user.getId().toString());
        }

        QueryResponse rsp;
        try {
            rsp = server.query(query, SolrRequest.METHOD.POST);
        } catch (SolrServerException e) {
            logger.error("Error in query \"" + query + "\" : " + e.getMessage());
            totalResults = 0;
            this.query = query;
            return;
            // throw new DHusSearchException ("Cannot execute query", e);
        } catch (SolrException e) {
            logger.error("Error in query \"" + query + "\" : " + e.getMessage());
            totalResults = 0;
            this.query = query;
            return;
            // throw new DHusSearchException ("Cannot execute query", e);
        }
        totalResults = rsp.getResults().getNumFound();
        this.query = query;
    }
}

From source file:fr.gael.dhus.server.http.webapp.search.controller.SearchController.java

License:Open Source License

@PreAuthorize("hasRole('ROLE_SEARCH')")
@RequestMapping(value = "/")
public void search(Principal principal, @RequestParam(value = "q") String original_query,
        @RequestParam(value = "rows", defaultValue = "") String rows_str,
        @RequestParam(value = "start", defaultValue = "") String start_str,
        @RequestParam(value = "format", defaultValue = "") String format,
        @RequestParam(value = "orderby", required = false) String orderby, HttpServletResponse res)
        throws IOException, XMLStreamException, SolrServerException {
    ServerConfiguration dhusServer = configurationManager.getServerConfiguration();

    String query = convertQuery(original_query);
    LOGGER.info("Rewritten Query: {}", query);

    boolean json = "json".equalsIgnoreCase(format);

    SolrQuery solrQuery = new SolrQuery(query);
    solrQuery.setParam("wt", "xslt").setParam("tr", "opensearch_atom.xsl")
            .setParam("dhusLongName", configurationManager.getNameConfiguration().getLongName())
            .setParam("dhusServer", dhusServer.getExternalUrl())
            .setParam("type", json ? "application/json" : "application/xml")
            .setParam("originalQuery", original_query);

    if (json) {/*from  w w  w .j  a  va2 s  .c  o m*/
        solrQuery.setParam("format", "json");
    }

    if (rows_str != null && !rows_str.isEmpty()) {
        try {
            int rows = Integer.parseInt(rows_str);
            if (ROW_LIMIT != UNLIMITED_SEARCH_ROWS && rows > ROW_LIMIT) {
                String errorMessage = String
                        .format("Parameter `rows` exceeds the maximum value (%d) in search request", ROW_LIMIT);
                LOGGER.warn(errorMessage);
                res.sendError(HttpServletResponse.SC_BAD_REQUEST, errorMessage);
                return;
            }
            solrQuery.setRows(rows);
        } catch (NumberFormatException nfe) {
            /* noting to do : keep the default value */
        }
    }
    if (start_str != null && !start_str.isEmpty()) {
        try {
            int start = Integer.parseInt(start_str);
            solrQuery.setStart(start);
        } catch (NumberFormatException nfe) {
            /* noting to do : keep the default value */
        }
    }
    // If `orderby` param is not defined, default to ordering by ingestiondate desc.
    // Define `orderby` to `""` (empty string) to order by the full text search score.
    if (orderby == null) {
        solrQuery.setSort("ingestiondate", SolrQuery.ORDER.desc);
    } else if (!orderby.isEmpty()) {
        solrQuery.setParam("sort", orderby.toLowerCase());
    }

    try (InputStream is = solrDao.streamSelect(solrQuery)) {
        try (ServletOutputStream os = res.getOutputStream()) {
            res.setStatus(HttpServletResponse.SC_OK);
            if ("json".equalsIgnoreCase(format)) {
                res.setContentType("application/json");
                xmlToJson(is, os);
            } else {
                res.setContentType("application/xml");
                IOUtils.copy(is, os);
            }
        }
    } catch (Exception e) {
        res.addHeader("cause-message", String.format("%s : %s", e.getClass().getSimpleName(), e.getMessage()));
        throw e;
    }
}

From source file:fr.paris.lutece.plugins.search.solr.business.SolrSearchEngine.java

License:Open Source License

/**
 * Return the result with facets. Does NOT support authentification yet.
 * @param strQuery the query/*w ww.  ja  va 2  s .c  o m*/
 * @param facetQueries The selected facets
 * @param sortName The facet name to sort by
 * @param sortOrder "asc" or "desc"
 * @param nLimit Maximal number of results.
 * @return the result with facets
 */
public SolrFacetedResult getFacetedSearchResults(String strQuery, String[] facetQueries, String sortName,
        String sortOrder, int nLimit, int nCurrentPageIndex, int nItemsPerPage, Boolean bSpellCheck) {
    SolrFacetedResult facetedResult = new SolrFacetedResult();

    SolrClient solrServer = SolrServerService.getInstance().getSolrServer();
    List<SolrSearchResult> results = new ArrayList<SolrSearchResult>();
    Hashtable<Field, List<String>> myValuesList = new Hashtable<Field, List<String>>();

    if (solrServer != null) {
        SolrQuery query = new SolrQuery(strQuery);
        query.setHighlight(true);
        query.setHighlightSimplePre(SOLR_HIGHLIGHT_PRE);
        query.setHighlightSimplePost(SOLR_HIGHLIGHT_POST);
        query.setHighlightSnippets(SOLR_HIGHLIGHT_SNIPPETS);
        query.setHighlightFragsize(SOLR_HIGHLIGHT_FRAGSIZE);
        query.setFacet(true);
        query.setFacetLimit(SOLR_FACET_LIMIT);
        //            query.setFacetMinCount( 1 );

        for (Field field : SolrFieldManager.getFacetList().values()) {
            //Add facet Field
            if (field.getEnableFacet()) {
                if (field.getName().equalsIgnoreCase("date")
                        || field.getName().toLowerCase().endsWith("_date")) {
                    query.setParam("facet.date", field.getName());
                    query.setParam("facet.date.start", SOLR_FACET_DATE_START);
                    query.setParam("facet.date.gap", SOLR_FACET_DATE_GAP);
                    query.setParam("facet.date.end", SOLR_FACET_DATE_END);
                    query.setParam("facet.date.mincount", "0");
                } else {
                    query.addFacetField(field.getSolrName());
                    query.setParam("f." + field.getSolrName() + ".facet.mincount",
                            String.valueOf(field.getFacetMincount()));
                }
                myValuesList.put(field, new ArrayList<String>());
            }
        }

        //Facet intersection
        List<String> treeParam = new ArrayList<String>();

        for (FacetIntersection intersect : SolrFieldManager.getIntersectionlist()) {
            treeParam.add(intersect.getField1().getSolrName() + "," + intersect.getField2().getSolrName());
        }

        //(String []) al.toArray (new String [0]);
        query.setParam("facet.tree", (String[]) treeParam.toArray(new String[0]));
        query.setParam("spellcheck", bSpellCheck);

        //sort order
        if ((sortName != null) && !"".equals(sortName)) {
            if (sortOrder.equals("asc")) {
                query.setSort(sortName, ORDER.asc);
            } else {
                query.setSort(sortName, ORDER.desc);
            }
        } else {
            for (Field field : SolrFieldManager.getSortList()) {
                if (field.getDefaultSort()) {
                    query.setSort(field.getName(), ORDER.desc);
                }
            }
        }

        //Treat HttpRequest
        //FacetQuery
        if (facetQueries != null) {
            for (String strFacetQuery : facetQueries) {
                //                    if ( strFacetQuery.contains( DATE_COLON ) )
                //                    {
                //                        query.addFilterQuery( strFacetQuery );
                //                    }
                //                    else
                //                    {
                String myValues[] = strFacetQuery.split(":", 2);
                if (myValues != null && myValues.length == 2) {
                    myValuesList = getFieldArrange(myValues, myValuesList);
                }
                //strFacetQueryWithColon = strFacetQuery.replaceFirst( SolrConstants.CONSTANT_COLON, COLON_QUOTE );
                //strFacetQueryWithColon += SolrConstants.CONSTANT_QUOTE;
                //                        query.addFilterQuery( strFacetQuery );
                //                    }
            }

            for (Field tmpFieldValue : myValuesList.keySet()) {
                List<String> strValues = myValuesList.get(tmpFieldValue);
                String strFacetString = "";
                if (strValues.size() > 0) {
                    strFacetString = extractQuery(strValues, tmpFieldValue.getOperator());
                    if (tmpFieldValue.getName().equalsIgnoreCase("date")
                            || tmpFieldValue.getName().toLowerCase().endsWith("_date")) {
                        strFacetString = strFacetString.replaceAll("\"", "");
                    }
                    query.addFilterQuery(tmpFieldValue.getName() + ":" + strFacetString);
                }
            }
        }

        try {

            // count query
            query.setRows(0);
            QueryResponse response = solrServer.query(query);

            int nResults = (int) response.getResults().getNumFound();
            facetedResult.setCount(nResults > nLimit ? nLimit : nResults);

            query.setStart((nCurrentPageIndex - 1) * nItemsPerPage);
            query.setRows(nItemsPerPage > nLimit ? nLimit : nItemsPerPage);

            query.setParam("defType", DEF_TYPE);
            String strWeightValue = generateQueryWeightValue();
            query.setParam("qf", strWeightValue);

            response = solrServer.query(query);

            //HighLight
            Map<String, Map<String, List<String>>> highlightsMap = response.getHighlighting();
            SolrHighlights highlights = null;

            if (highlightsMap != null) {
                highlights = new SolrHighlights(highlightsMap);
            }

            //resultList
            List<SolrItem> itemList = response.getBeans(SolrItem.class);
            results = SolrUtil.transformSolrItemsToSolrSearchResults(itemList, highlights);

            //set the spellcheckresult
            facetedResult.setSolrSpellCheckResponse(response.getSpellCheckResponse());

            //Date facet
            if ((response.getFacetDates() != null) && !response.getFacetDates().isEmpty()) {
                facetedResult.setFacetDateList(response.getFacetDates());
            }

            //FacetField
            facetedResult.setFacetFields(response.getFacetFields());

            //Facet intersection (facet tree)
            NamedList<Object> resp = (NamedList<Object>) response.getResponse().get("facet_counts");

            if (resp != null) {
                NamedList<NamedList<NamedList<Integer>>> trees = (NamedList<NamedList<NamedList<Integer>>>) resp
                        .get("trees");
                Map<String, ArrayList<FacetField>> treesResult = new HashMap<String, ArrayList<FacetField>>();

                if (trees != null) {
                    for (Entry<String, NamedList<NamedList<Integer>>> selectedFacet : trees) { //Selected Facet (ex : type,categorie )
                                                                                               //System.out.println(selectedFacet.getKey());

                        ArrayList<FacetField> facetFields = new ArrayList<FacetField>(
                                selectedFacet.getValue().size());

                        for (Entry<String, NamedList<Integer>> facetField : selectedFacet.getValue()) {
                            FacetField ff = new FacetField(facetField.getKey());

                            //System.out.println("\t" + facetField.getKey());
                            for (Entry<String, Integer> value : facetField.getValue()) { // Second Level
                                ff.add(value.getKey(), value.getValue());

                                //System.out.println("\t\t" + value.getKey() + " : " + value.getValue());
                            }

                            facetFields.add(ff);
                        }

                        treesResult.put(selectedFacet.getKey(), facetFields);
                    }
                }

                facetedResult.setFacetIntersection(treesResult);
            }
        } catch (SolrServerException e) {
            AppLogService.error(e.getMessage(), e);
        } catch (IOException e) {
            AppLogService.error(e.getMessage(), e);
        }
    } else {
        facetedResult.setFacetFields(new ArrayList<FacetField>());
    }

    facetedResult.setSolrSearchResults(results);

    return facetedResult;
}

From source file:fr.paris.lutece.plugins.search.solr.business.SolrSearchEngine.java

License:Open Source License

/**
 * Return the result geojseon and uid/*from   w  w w.j  ava  2  s .  c  om*/
 * @param strQuery the query
 * @param facetQueries The selected facets
 * @param nLimit Maximal number of results.
 * @return the results geojson and uid
 */
public List<SolrSearchResult> getGeolocSearchResults(String strQuery, String[] facetQueries, int nLimit) {
    SolrClient solrServer = SolrServerService.getInstance().getSolrServer();
    if (solrServer != null) {
        String strFields = "*" + SolrItem.DYNAMIC_GEOJSON_FIELD_SUFFIX + "," + SearchItem.FIELD_UID;
        SolrQuery query = new SolrQuery(strQuery);
        query.setParam("fl", strFields);

        //Treat HttpRequest
        //FacetQuery
        if (facetQueries != null) {
            for (String strFacetQuery : facetQueries) {
                if (strFacetQuery.contains(DATE_COLON)) {
                    query.addFilterQuery(strFacetQuery);
                } else {
                    String strFacetQueryWithColon;
                    strFacetQueryWithColon = strFacetQuery.replaceFirst(SolrConstants.CONSTANT_COLON,
                            COLON_QUOTE);
                    strFacetQueryWithColon += SolrConstants.CONSTANT_QUOTE;
                    query.addFilterQuery(strFacetQueryWithColon);
                }
            }
        }

        query.setStart(0);
        query.setRows(nLimit);
        QueryResponse response;
        try {
            response = solrServer.query(query);
        } catch (SolrServerException | IOException e) {
            AppLogService.error("Solr getGeolocSearchResults error: " + e.getMessage(), e);
            return new ArrayList<SolrSearchResult>();
        }
        //resultList
        List<SolrItem> itemList = response.getBeans(SolrItem.class);
        return SolrUtil.transformSolrItemsToSolrSearchResults(itemList, null);
    } else {
        return new ArrayList<SolrSearchResult>();
    }
}

From source file:fr.paris.lutece.plugins.search.solr.business.SolrSearchEngine.java

License:Open Source License

/**
 * Return the suggestion terms/*from   w w w.  j av  a2  s .  c  o  m*/
 * @param term the terms of search
 * @return The spell checker response
 */
public SpellCheckResponse getSpellChecker(String term) {
    SpellCheckResponse spellCheck = null;
    SolrClient solrServer = SolrServerService.getInstance().getSolrServer();

    SolrQuery query = new SolrQuery(term);
    //Do not return results (optimization)
    query.setRows(0);
    //Activate spellChecker
    query.setParam("spellcheck", "true");
    //The request handler used
    query.setRequestHandler("/" + SOLR_SPELLCHECK_HANDLER);
    //The number of suggest returned

    query.setParam("spellcheck.count", "1"); // TODO
                                             //Returns the frequency of the terms

    query.setParam("spellcheck.extendedResults", "true"); // TODO
                                                          //Return the best suggestion combinaison with many words

    query.setParam("spellcheck.collate", "true"); // TODO

    try {
        QueryResponse response = solrServer.query(query);
        spellCheck = response.getSpellCheckResponse();
    } catch (SolrServerException e) {
        AppLogService.error(e.getMessage(), e);
    } catch (IOException e) {
        AppLogService.error(e.getMessage(), e);
    }

    return spellCheck;
}

From source file:fr.paris.lutece.plugins.search.solr.business.SolrSearchEngine.java

License:Open Source License

public QueryResponse getJsonpSuggest(String terms, String callback) {
    QueryResponse response = null;/*from  www.  j a v  a  2s. c om*/
    SolrClient solrServer = SolrServerService.getInstance().getSolrServer();

    SolrQuery query = new SolrQuery(terms);
    query.setParam("wt", "json");
    query.setParam("json.wrf", callback);
    query.setRows(10);
    query.setRequestHandler("/" + SOLR_AUTOCOMPLETE_HANDLER);

    try {
        response = solrServer.query(query);
    } catch (SolrServerException e) {
        AppLogService.error(e.getMessage(), e);
    } catch (IOException e) {
        AppLogService.error(e.getMessage(), e);
    }

    return response;
}