Example usage for org.apache.solr.client.solrj SolrClient query

Introduction

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

Prototype

public QueryResponse query(SolrParams params) throws SolrServerException, IOException 

Source Link

Document

Performs a query to the Solr server

Usage

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

License:Open Source License

/**
* Return search results/*from  w  ww .  j a v  a 2s . c o m*/
* @param strQuery The search query
* @param request The HTTP request
* @return Results as a collection of SearchResult
*/
public List<SearchResult> getSearchResults(String strQuery, HttpServletRequest request) {
    List<SearchResult> results = new ArrayList<SearchResult>();

    SolrClient solrServer = SolrServerService.getInstance().getSolrServer();

    if ((solrServer != null) && !strQuery.equals("")) {
        SolrQuery query = new SolrQuery();

        if ((strQuery != null) && (strQuery.length() > 0)) {
            query.setQuery(strQuery);
        }

        String[] userRoles;
        String[] roles;

        if (SecurityService.isAuthenticationEnable()) {
            // authentification on, check roles
            LuteceUser user = SecurityService.getInstance().getRegisteredUser(request);

            if (user != null) {
                userRoles = SecurityService.getInstance().getRolesByUser(user);
            } else {
                userRoles = new String[0];
            }

            roles = new String[userRoles.length + 1];
            System.arraycopy(userRoles, 0, roles, 0, userRoles.length);
            roles[roles.length - 1] = Page.ROLE_NONE;

            String filterRole = buildFilter(SearchItem.FIELD_ROLE, roles);
            // portlets roles
            //roles[roles.length - 1] = Portlet.ROLE_NONE;

            //String filterPortletRole = buildFilter( SearchItem.FIELD_PORTLET_ROLE, roles );
            query = query.addFilterQuery(filterRole); //.addFilterQuery( filterPortletRole );
        }

        try {
            QueryResponse response = solrServer.query(query);
            SolrDocumentList documentList = response.getResults();
            results = SolrUtil.transformSolrDocumentList(documentList);
        } catch (SolrServerException e) {
            AppLogService.error(e.getMessage(), e);
        } catch (IOException e) {
            AppLogService.error(e.getMessage(), e);
        }
    }

    return results;
}

---

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//www . j  a  v a  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 www.jav a 2  s .com*/
 * @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/*w w w.  j a  v a 2 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;/*  w  ww  .  j  a  va  2  s  . com*/
    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;
}

---

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

License:Open Source License

public String getDocumentHighLighting(String strDocumentId, String terms) {
    String strDocumentIdPrefixed = SolrIndexerService.getWebAppName() + SolrConstants.CONSTANT_UNDERSCORE
            + strDocumentId;/* w w  w .j  a v a  2  s  .  c  o m*/
    String xmlContent = null;
    SolrClient solrServer = SolrServerService.getInstance().getSolrServer();
    SolrQuery query = new SolrQuery(terms);
    query.setHighlight(true);
    query.setHighlightSimplePre(SOLR_HIGHLIGHT_PRE);
    query.setHighlightSimplePost(SOLR_HIGHLIGHT_POST);
    query.setHighlightFragsize(0); //return all the content, not fragments
    query.setParam("hl.fl", SolrItem.FIELD_XML_CONTENT); //return only the field xml_content HighLighting
    query.setFields(SearchItem.FIELD_UID); //return only the field uid
    query.setRows(1);
    query.addFilterQuery(SearchItem.FIELD_UID + ":" + strDocumentIdPrefixed);

    try {
        QueryResponse response = solrServer.query(query);

        if (response.getResults().size() == 1) {
            SolrHighlights highlights = new SolrHighlights(response.getHighlighting());

            if (highlights.getHighlights(strDocumentIdPrefixed).getMap().size() > 0) {
                xmlContent = highlights.getHighlights(strDocumentIdPrefixed).getMap()
                        .get(SolrItem.FIELD_XML_CONTENT).get(0);
            }
        }
    } catch (SolrServerException e) {
        AppLogService.error(e.getMessage(), e);
    } catch (IOException e) {
        AppLogService.error(e.getMessage(), e);
    }

    return xmlContent;
}

---

From source file:gr.aueb.service.EmailService.java

public static List<Email> getEmails(List<String> keywords) {
    String query = getEmailServiceQuery(keywords);
    SolrQuery solrQuery;/*ww w.j  a v  a 2  s.  c om*/
    solrQuery = new SolrQuery();
    if (query.startsWith(" AND")) {
        query = query.substring(4);
    }
    if (query.startsWith("AND")) {
        query = query.substring(3);
    }
    solrQuery.setQuery(query);
    if (!query.equals("")) {
        solrQuery.setHighlight(true).setHighlightSnippets(1).setHighlightSimplePost("</strong>")
                .setHighlightSimplePre("<strong>"); //set other params as needed
        solrQuery.setParam("hl.fl", "content_t");
        solrQuery.setParam("hl.requireFieldMatch", "true");

    }

    solrQuery.setRows(15);
    String urlString = "http://195.251.252.8:8983/solr/mail";
    //SolrClient server = new HttpSolrClient.Builder(urlString).build();
    SolrClient server = new HttpSolrClient(urlString);
    QueryResponse response = null;
    try {
        response = server.query(solrQuery);

    } catch (Exception e) {
        System.out.println(e);
    }
    SolrDocumentList rs = response.getResults();
    long numFound = rs.getNumFound();
    int numResultsDisplay = (int) numFound;
    ArrayList<Email> items = new ArrayList<Email>();

    ListIterator<SolrDocument> iter = rs.listIterator();

    while (iter.hasNext()) {
        SolrDocument doc = iter.next();
        String id = doc.get("messageId").toString();
        String from = doc.get("from").toString();
        String sentDate = doc.get("sentDate").toString();
        String subject = doc.get("subject").toString();
        String content = doc.get("content").toString();

        items.add(new Email(id, from, sentDate, subject, content));
    }
    return items;
}

---

From source file:net.yacy.cora.federate.solr.instance.ServerShard.java

License:Open Source License

/**
 * Performs a query to the Solr server/*from w  ww.j a  va 2 s  . c  o  m*/
 * @param params  an object holding all key/value parameters to send along the request
 * @throws IOException 
 */
@Override
public QueryResponse query(final SolrParams params) throws SolrServerException, IOException {
    List<SolrClient> qs = this.shards.server4read();
    if (qs.size() == 1) {
        return qs.get(0).query(params);
    }

    // concurrently call all shards
    final Collection<QueryResponse> qrl = new ConcurrentLinkedQueue<QueryResponse>();
    List<Thread> t = new ArrayList<Thread>();
    for (final SolrClient s : qs) {
        Thread t0 = new Thread() {
            @Override
            public void run() {
                this.setName("ServerShard.query/1(" + params.toString() + ")");
                QueryResponse rsp;
                try {
                    rsp = s.query(params);
                } catch (final Throwable e) {
                    return;
                }
                qrl.add(rsp);
            }
        };
        t0.start();
        t.add(t0);
    }
    for (Thread t0 : t) {
        try {
            t0.join();
        } catch (final InterruptedException e) {
        }
    }

    // prepare combined response
    return ResponseAccumulator.combineResponses(qrl);
}

---

From source file:org.apache.drill.exec.store.solr.SolrClientAPIExec.java

License:Apache License

public QueryResponse getNumFound(String solrServer, String solrCoreName, StringBuilder filters,
        String uniqueKey, List<String> responseFieldList) {
    String solrUrl = solrServer;//from  ww  w .  ja v  a  2 s  .  c  o  m
    if (solrCoreName != null) {
        solrUrl = solrServer + solrCoreName;
    }
    SolrClient solrClient = new HttpSolrClient(solrUrl);
    SolrQuery solrQuery = new SolrQuery().setQuery("*:*").setStart(0).setRows(0)
            .addSort(SolrQuery.SortClause.desc(uniqueKey));

    if (filters != null && filters.length() > 0) {
        solrQuery.setParam("fq", filters.toString());
        SolrClientAPIExec.logger.debug("Filter query [ " + filters.toString() + " ]");
    }
    if (responseFieldList != null) {
        if (!responseFieldList.contains(uniqueKey)) {
            responseFieldList.add(uniqueKey);
        }
    } else {
        responseFieldList = Lists.newArrayListWithCapacity(1);
        responseFieldList.add(uniqueKey);
    }
    solrQuery.setParam("fl", Joiner.on(",").join(responseFieldList));
    QueryResponse rsp = null;
    try {
        SolrClientAPIExec.logger
                .info("Submitting Solr warming up query :" + solrUrl + "/select" + solrQuery.toQueryString());

        rsp = solrClient.query(solrQuery);
        solrClient.close();

        SolrClientAPIExec.logger
                .info("Response recieved from [ " + solrServer + " ] in " + rsp.getQTime() + "ms.");
        SolrClientAPIExec.logger.info("Number of documents found :: " + rsp.getResults().getNumFound());
    } catch (SolrServerException | IOException e) {
        SolrClientAPIExec.logger
                .error("Unable to determine number of documents in the solr core :: " + e.getMessage());
    }

    return rsp;
}

---

From source file:org.apache.drill.exec.store.solr.SolrClientAPIExec.java

License:Apache License

public QueryResponse getSolr4Docs(String solrServer, String solrCoreName, String uniqueKey, List<String> fields,
        Long solrDocFectCount, String cursorMark, StringBuilder filters, List<SolrAggrParam> solrAggrParams,
        List<SolrSortParam> solrSortParams, List<String> aggrFieldNames, boolean isGroup,
        boolean useFacetPivotFromGroupCount) {

    String solrUrl = solrServer;/*ww w . ja  va2 s .  c o  m*/
    if (solrCoreName != null) {
        solrUrl = solrServer + solrCoreName;
    }
    SolrClient solrClient = new HttpSolrClient(solrUrl);
    String fieldStr = null;
    String[] fieldListArr = null;
    List<String> statsFieldList = Lists.newArrayList();

    SolrQuery solrQuery = new SolrQuery().setTermsRegexFlag("case_insensitive").setQuery(uniqueKey + ":*")
            .setRows(0);

    if (filters.length() > 0) {
        solrQuery.setParam("fq", filters.toString());
        SolrClientAPIExec.logger.debug("Filter query [ " + filters.toString() + " ]");
    }

    if (!fields.isEmpty()) {
        fieldStr = Joiner.on(",").join(fields);
        solrQuery.setParam("fl", fieldStr);
        solrQuery.setRows(solrDocFectCount.intValue());
        SolrClientAPIExec.logger.debug("Response field list [" + fieldStr + "]");
    }
    // facet.pivot={!stats=s1}category,manufacturer
    // stats.field={!key=avg_price tag=s1 mean=true}price
    // stats.field={!tag=s1 min=true max=true}user_rating

    if (solrAggrParams != null && !solrAggrParams.isEmpty() && !useFacetPivotFromGroupCount) {
        solrQuery.setGetFieldStatistics(true);
        for (SolrAggrParam solrAggrParam : solrAggrParams) {
            String statsField = solrAggrParam.getFieldName();
            if (!fields.contains(statsField)) {
                statsField = uniqueKey;
            }
            if (!statsFieldList.contains(statsField)) {
                statsFieldList.add(statsField);
            }
            fields.remove(statsField);
        }
        if (!fields.isEmpty()) {
            fieldListArr = fields.toArray(new String[fields.size()]);
        }

        for (String statsField : statsFieldList) {
            solrQuery.setGetFieldStatistics(statsField);
            SolrClientAPIExec.logger.debug("Adding stats field parameter.. [ " + statsField + " ]");
            if (isGroup) {
                List<String> groupFields = Lists.newArrayList();
                for (String aggrField : aggrFieldNames) {
                    if (fields.contains(aggrField)) {
                        groupFields.add(aggrField);
                    }
                }
                SolrClientAPIExec.logger.debug("Adding stats facet parameters.. [ " + groupFields + " ]");
                solrQuery.addStatsFieldFacets(statsField, groupFields.toArray(new String[groupFields.size()]));
            }

        }
        solrQuery.setRows(0);
    } else if (isGroup) {
        fieldListArr = fields.toArray(new String[fields.size()]);
        solrQuery.setFacet(true);
        if (fields.size() == 1) {
            solrQuery.addFacetField(fieldListArr);
            solrQuery.setFacetLimit(-1);
        } else {
            solrQuery.addFacetPivotField(Joiner.on(",").join(fields));
        }
        solrQuery.setRows(0);
        solrQuery.setFacetMinCount(1);

        // solrQuery.set(GroupParams.GROUP, true);
        // solrQuery.set(GroupParams.GROUP_FIELD, fieldListArr);
        // solrQuery.set(GroupParams.GROUP_MAIN, true);
        // solrQuery.set(GroupParams.GROUP_FORMAT, "simple");
        // solrQuery.set("group.ngroups", "true");
    }
    if (!solrSortParams.isEmpty()) {
        for (SolrSortParam solrSortParam : solrSortParams) {
            String solrSortField = solrSortParam.getSortFieldName();
            ORDER solrSortDir = solrSortParam.getSortDir();
            solrQuery.addSort(solrSortField, solrSortDir);

        }
    } else {
        solrQuery.set(CursorMarkParams.CURSOR_MARK_PARAM, cursorMark);
        solrQuery.setSort(SolrQuery.SortClause.desc(uniqueKey));
    }
    QueryResponse rsp = null;
    try {
        SolrClientAPIExec.logger
                .info("Submitting Query :" + solrServer + "/select" + solrQuery.toQueryString());

        rsp = solrClient.query(solrQuery);

        SolrClientAPIExec.logger.info("Response recieved from [ " + solrServer + " ] core [ " + solrCoreName
                + " ] in " + rsp.getQTime() + " MS.");

    } catch (SolrServerException | IOException e) {
        SolrClientAPIExec.logger
                .debug("Error occured while fetching results from solr server " + e.getMessage());
    } finally {
        try {
            solrClient.close();
        } catch (IOException e) {
            SolrClientAPIExec.logger
                    .debug("Error occured while closing connection of solr server " + e.getMessage());
        }
    }

    return rsp;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• »