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

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

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

Introduction

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

Prototype

public SolrQuery addSort(String field, ORDER order)

Source Link

Document

Adds a single sort clause to the end of the current sort information.

Usage

From source file:io.logspace.it.test.SimpleIntegrationTest.java

License:Open Source License

@Test
public void testSimpleAgent() {
    assertEquals(0, this.commitAndGetSolrDocumentCount("*:*"));

    HqAgentController.install("1", HQ_URL, QUEUE_DIRECTORY, SPACE_TOKEN, MARKER);
    TestAgent testAgent = new TestAgent();
    this.waitFor(5, SECONDS);
    AgentControllerProvider.shutdown();/*from ww  w .ja  va 2  s.  co m*/

    assertTrue(testAgent.getEventCount() > 0);
    assertEquals(testAgent.getEventCount(), this.commitAndGetSolrDocumentCount("*:*"));

    SolrQuery solrQuery = new SolrQuery("*:*");
    solrQuery.addSort("global_id", ORDER.asc);

    QueryResponse queryResponse = this.querySolr(solrQuery);

    int documentCount = 0;
    for (SolrDocument eachDocument : queryResponse.getResults()) {
        assertEquals(String.valueOf(++documentCount), eachDocument.getFirstValue("global_id"));
        assertEquals(MARKER, eachDocument.getFirstValue("marker"));
    }
}

From source file:it.damore.solr.importexport.App.java

License:Open Source License

/**
 * @param client//from w  ww . j  ava2  s . c o m
 * @param outputFile
 * @throws SolrServerException
 * @throws IOException
 */
private static void readAllDocuments(HttpSolrClient client, File outputFile)
        throws SolrServerException, IOException {

    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery("*:*");
    if (config.getFilterQuery() != null) {
        solrQuery.addFilterQuery(config.getFilterQuery());
    }
    solrQuery.setRows(0);

    solrQuery.addSort(config.getUniqueKey(), ORDER.asc); // Pay attention to this line

    String cursorMark = CursorMarkParams.CURSOR_MARK_START;

    TimeZone.setDefault(TimeZone.getTimeZone("UTC"));

    // objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, true);
    DateFormat df = new SimpleDateFormat("YYYY-MM-dd'T'HH:mm:sss'Z'");
    objectMapper.setDateFormat(df);
    objectMapper.configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS, true);

    QueryResponse r = client.query(solrQuery);

    long nDocuments = r.getResults().getNumFound();
    logger.info("Found " + nDocuments + " documents");

    if (!config.getDryRun()) {
        logger.info("Creating " + config.getFileName());

        Set<SkipField> skipFieldsEquals = config.getSkipFieldsSet().stream()
                .filter(s -> s.getMatch() == MatchType.EQUAL).collect(Collectors.toSet());
        Set<SkipField> skipFieldsStartWith = config.getSkipFieldsSet().stream()
                .filter(s -> s.getMatch() == MatchType.STARTS_WITH).collect(Collectors.toSet());
        Set<SkipField> skipFieldsEndWith = config.getSkipFieldsSet().stream()
                .filter(s -> s.getMatch() == MatchType.ENDS_WITH).collect(Collectors.toSet());

        try (PrintWriter pw = new PrintWriter(outputFile)) {
            solrQuery.setRows(200);
            boolean done = false;
            while (!done) {
                solrQuery.set(CursorMarkParams.CURSOR_MARK_PARAM, cursorMark);
                QueryResponse rsp = client.query(solrQuery);
                String nextCursorMark = rsp.getNextCursorMark();

                for (SolrDocument d : rsp.getResults()) {
                    skipFieldsEquals.forEach(f -> d.removeFields(f.getText()));
                    if (skipFieldsStartWith.size() > 0 || skipFieldsEndWith.size() > 0) {
                        Map<String, Object> collect = d.entrySet().stream()
                                .filter(e -> !skipFieldsStartWith.stream()
                                        .filter(f -> e.getKey().startsWith(f.getText())).findFirst()
                                        .isPresent())
                                .filter(e -> !skipFieldsEndWith.stream()
                                        .filter(f -> e.getKey().endsWith(f.getText())).findFirst().isPresent())
                                .collect(Collectors.toMap(e -> e.getKey(), e -> e.getValue()));
                        pw.write(objectMapper.writeValueAsString(collect));
                    } else {
                        pw.write(objectMapper.writeValueAsString(d));
                    }
                    pw.write("\n");
                }
                if (cursorMark.equals(nextCursorMark)) {
                    done = true;
                }

                cursorMark = nextCursorMark;
            }

        }
    }

}

From source file:net.yacy.crawler.data.CrawlQueues.java

License:Open Source License

public boolean autocrawlJob() {
    if (!this.sb.getConfigBool(SwitchboardConstants.AUTOCRAWL, false)) {
        return false;
    }//from   w w w .j  a  v  a2  s . co m

    if (isPaused(SwitchboardConstants.CRAWLJOB_LOCAL_CRAWL)) {
        return false;
    }

    if (coreCrawlJobSize() > 200) {
        return false;
    }

    String rows = this.sb.getConfig(SwitchboardConstants.AUTOCRAWL_ROWS, "100");

    String dateQuery = String.format("load_date_dt:[* TO NOW-%sDAY]",
            this.sb.getConfig(SwitchboardConstants.AUTOCRAWL_DAYS, "1"));

    final SolrQuery query = new SolrQuery();
    query.add("group", "true");
    query.add("group.field", "host_s");
    query.add("group.limit", "1");
    query.add("group.main", "true");
    query.add("rows", rows);
    query.setQuery(this.sb.getConfig(SwitchboardConstants.AUTOCRAWL_QUERY, "*:*"));
    query.setFields("host_s,url_protocol_s");
    query.addSort("load_date_dt", SolrQuery.ORDER.asc);
    query.addFilterQuery(dateQuery);

    try {
        QueryResponse resp = sb.index.fulltext().getDefaultConnector().getResponseByParams(query);

        int i = 0;
        int deepRatio = Integer.parseInt(this.sb.getConfig(SwitchboardConstants.AUTOCRAWL_RATIO, "50"));
        for (SolrDocument doc : resp.getResults()) {
            boolean deep = false;
            i++;
            if (i % deepRatio == 0) {
                deep = true;
            }
            DigestURL url;
            final String u = doc.getFieldValue("url_protocol_s").toString() + "://"
                    + doc.getFieldValue("host_s").toString();
            try {
                url = new DigestURL(u);
            } catch (final MalformedURLException e) {
                continue;
            }
            final String urlRejectReason = this.sb.crawlStacker.urlInAcceptedDomain(url);
            if (urlRejectReason == null) {
                this.sb.crawlStacker.enqueueEntry(new Request(ASCII.getBytes(this.sb.peers.mySeed().hash), url,
                        null, "CRAWLING-ROOT", new Date(),
                        deep ? this.sb.crawler.defaultAutocrawlDeepProfile.handle()
                                : this.sb.crawler.defaultAutocrawlShallowProfile.handle(),
                        0, deep ? this.sb.crawler.defaultAutocrawlDeepProfile.timezoneOffset()
                                : this.sb.crawler.defaultAutocrawlShallowProfile.timezoneOffset()));
            } else {
                CrawlQueues.log.warn("autocrawl: Rejected URL '" + urlToString(url) + "': " + urlRejectReason);
            }
        }

    } catch (SolrException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }

    return true;
}

From source file:nl.knaw.huygens.facetedsearch.AbstractSolrServer.java

License:Open Source License

/**
 * Sets the sort criteria for the query.
 * @return query the SolrQuery//from   w  ww. j  av  a  2s . c om
 */
private SolrQuery setSort(SolrQuery query, ElaborateSearchParameters sp) {
    LinkedHashSet<SortParameter> sortParameters = sp.getSortParameters();
    for (SortParameter sortParameter : sortParameters) {
        if (StringUtils.isNotBlank(sortParameter.getFieldname())) {
            String facetName = SolrUtils.facetName(sortParameter.getFieldname());
            ORDER solrOrder = solrOrder(sortParameter.getDirection());
            query.addSort(facetName, solrOrder);
        }
    }

    LinkedHashSet<String> levelFields = Sets.newLinkedHashSet(
            ImmutableList.of(sp.getLevel1Field(), sp.getLevel2Field(), sp.getLevel3Field(), SolrFields.NAME));
    for (String sortField : levelFields) {
        query.addSort(sortField, SolrQuery.ORDER.asc);
    }
    return query;
}

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;//from  www  .j a  v  a2  s. c  om
    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;
}

From source file:org.apache.lucene.benchmark.quality.mc.SolrSearcher.java

License:Apache License

private void search(String q, String QueryID) throws SolrServerException {

    SolrQuery query = new SolrQuery(q.replace("?", ""));
    query.setParam(CommonParams.DF, defaultField);
    query.setFields("id", "score");
    query.setStart(0);/* w  w w  .j a v  a2  s .  c  o  m*/
    query.setRows(1000);
    query.setSort("score", SolrQuery.ORDER.desc);
    query.addSort("id", SolrQuery.ORDER.asc);

    int i = 0;

    for (SolrDocument document : server.query(query).getResults()) {

        String docno = (String) document.getFieldValue("id");
        Float score = (Float) document.getFieldValue("score");

        output.println(QueryID + "\tQ0\tMilliyet_0105_v00_" + docno.trim() + "\t" + i + "\t" + score + "\t"
                + getRunName());
        i++;
    }

}

From source file:org.apache.metron.solr.dao.SolrSearchDao.java

License:Apache License

protected SolrQuery buildSearchRequest(SearchRequest searchRequest, String fieldList)
        throws IOException, SolrServerException {
    SolrQuery query = new SolrQuery().setStart(searchRequest.getFrom()).setRows(searchRequest.getSize())
            .setQuery(searchRequest.getQuery());

    // handle sort fields
    for (SortField sortField : searchRequest.getSort()) {
        query.addSort(sortField.getField(), getSolrSortOrder(sortField.getSortOrder()));
    }//from   w w w  .  ja v  a 2 s. co m

    // handle search fields
    List<String> fields = searchRequest.getFields();
    if (fieldList == null) {
        fieldList = "*";
        if (fields != null) {
            fieldList = StringUtils.join(fields, ",");
        }
    }
    query.set("fl", fieldList);

    //handle facet fields
    List<String> facetFields = searchRequest.getFacetFields();
    if (facetFields != null) {
        facetFields.forEach(query::addFacetField);
    }

    query.set("collection", getCollections(searchRequest.getIndices()));

    return query;
}

From source file:org.apache.ranger.solr.SolrUtil.java

License:Apache License

public void setSortClause(SearchCriteria searchCriteria, List<SortField> sortFields, SolrQuery query) {

    // TODO: We are supporting single sort field only for now
    String sortBy = searchCriteria.getSortBy();
    String querySortBy = null;/* w  ww.j a v a  2  s  . c  o  m*/
    if (!stringUtil.isEmpty(sortBy)) {
        sortBy = sortBy.trim();
        for (SortField sortField : sortFields) {
            if (sortBy.equalsIgnoreCase(sortField.getParamName())) {
                querySortBy = sortField.getFieldName();
                // Override the sortBy using the normalized value
                searchCriteria.setSortBy(sortField.getParamName());
                break;
            }
        }
    }

    if (querySortBy == null) {
        for (SortField sortField : sortFields) {
            if (sortField.isDefault()) {
                querySortBy = sortField.getFieldName();
                // Override the sortBy using the default value
                searchCriteria.setSortBy(sortField.getParamName());
                searchCriteria.setSortType(sortField.getDefaultOrder().name());
                break;
            }
        }
    }

    if (querySortBy != null) {
        // Add sort type
        String sortType = searchCriteria.getSortType();
        ORDER order = ORDER.asc;
        if (sortType != null && sortType.equalsIgnoreCase("desc")) {
            order = ORDER.desc;

        }
        query.addSort(querySortBy, order);
    }
}

From source file:org.codelibs.fess.helper.CrawlingSessionHelper.java

License:Apache License

public List<Map<String, String>> getSessionIdList(final SolrGroup serverGroup) {
    final List<Map<String, String>> sessionIdList = new ArrayList<Map<String, String>>();
    final FieldHelper fieldHelper = ComponentUtil.getFieldHelper();

    final SolrQuery query = new SolrQuery();
    query.setQuery("*:*");
    query.setFacet(true);/*from w ww . j  av  a  2 s.c  o m*/
    query.addFacetField(fieldHelper.segmentField);
    query.addSort(fieldHelper.segmentField, ORDER.desc);

    final QueryResponse queryResponse = serverGroup.query(query);
    final List<FacetField> facets = queryResponse.getFacetFields();
    for (final FacetField facet : facets) {
        final List<FacetField.Count> facetEntries = facet.getValues();
        if (facetEntries != null) {
            for (final FacetField.Count fcount : facetEntries) {
                final Map<String, String> map = new HashMap<String, String>(2);
                map.put(fieldHelper.segmentField, fcount.getName());
                map.put(FACET_COUNT_KEY, Long.toString(fcount.getCount()));
                sessionIdList.add(map);
            }
        }
    }
    return sessionIdList;
}

From source file:org.codelibs.fess.service.SearchService.java

License:Apache License

public List<Map<String, Object>> getDocumentList(final String query, final int start, final int rows,
        final FacetInfo facetInfo, final GeoInfo geoInfo, final MoreLikeThisInfo mltInfo,
        final String[] responseFields, final String[] docValuesFields, final boolean forUser) {
    if (start > queryHelper.getMaxSearchResultOffset()) {
        throw new ResultOffsetExceededException("The number of result size is exceeded.");
    }/* w ww.j  ava2s.com*/

    final long startTime = System.currentTimeMillis();

    final SolrGroup solrGroup = solrGroupManager.getSolrGroup(QueryType.QUERY);

    QueryResponse queryResponse = null;
    final SolrQuery solrQuery = new SolrQuery();
    final SearchQuery searchQuery = queryHelper.build(query, forUser);
    final String q = searchQuery.getQuery();
    if (StringUtil.isNotBlank(q)) {
        // fields
        solrQuery.setFields(responseFields);
        // query
        solrQuery.setQuery(q);
        solrQuery.setStart(start);
        solrQuery.setRows(rows);
        solrQuery.set("mm", searchQuery.getMinimumShouldMatch());
        solrQuery.set("defType", searchQuery.getDefType());
        for (final Map.Entry<String, String[]> entry : queryHelper.getQueryParamMap().entrySet()) {
            solrQuery.set(entry.getKey(), entry.getValue());
        }
        // filter query
        if (searchQuery.hasFilterQueries()) {
            solrQuery.addFilterQuery(searchQuery.getFilterQueries());
        }
        // sort
        final SortField[] sortFields = searchQuery.getSortFields();
        if (sortFields.length != 0) {
            for (final SortField sortField : sortFields) {
                solrQuery.addSort(sortField.getField(),
                        Constants.DESC.equals(sortField.getOrder()) ? SolrQuery.ORDER.desc
                                : SolrQuery.ORDER.asc);
            }
        } else if (queryHelper.hasDefaultSortFields()) {
            for (final SortField sortField : queryHelper.getDefaultSortFields()) {
                solrQuery.addSort(sortField.getField(),
                        Constants.DESC.equals(sortField.getOrder()) ? SolrQuery.ORDER.desc
                                : SolrQuery.ORDER.asc);
            }
        }
        // highlighting
        if (queryHelper.getHighlightingFields() != null && queryHelper.getHighlightingFields().length != 0) {
            for (final String hf : queryHelper.getHighlightingFields()) {
                solrQuery.addHighlightField(hf);
            }
            solrQuery.setHighlightSnippets(queryHelper.getHighlightSnippetSize());
        }
        // shards
        if (queryHelper.getShards() != null) {
            solrQuery.setParam("shards", queryHelper.getShards());
        }
        // geo
        if (geoInfo != null && geoInfo.isAvailable()) {
            solrQuery.addFilterQuery(geoInfo.toGeoQueryString());
            final String additionalGeoQuery = queryHelper.getAdditionalGeoQuery();
            if (StringUtil.isNotBlank(additionalGeoQuery)) {
                solrQuery.addFilterQuery(additionalGeoQuery);
            }
        }
        // facets
        if (facetInfo != null) {
            solrQuery.setFacet(true);
            if (facetInfo.field != null) {
                for (final String f : facetInfo.field) {
                    if (queryHelper.isFacetField(f)) {
                        solrQuery.addFacetField(f);
                    } else {
                        throw new FessSolrQueryException("EFESS0002", new Object[] { f });
                    }
                }
            }
            if (facetInfo.query != null) {
                for (final String fq : facetInfo.query) {
                    final String facetQuery = queryHelper.buildFacetQuery(fq);
                    if (StringUtil.isNotBlank(facetQuery)) {
                        solrQuery.addFacetQuery(facetQuery);
                    } else {
                        throw new FessSolrQueryException("EFESS0003", new Object[] { fq, facetQuery });
                    }
                }
            }
            if (facetInfo.limit != null) {
                solrQuery.setFacetLimit(Integer.parseInt(facetInfo.limit));
            }
            if (facetInfo.minCount != null) {
                solrQuery.setFacetMinCount(Integer.parseInt(facetInfo.minCount));
            }
            if (facetInfo.missing != null) {
                solrQuery.setFacetMissing(Boolean.parseBoolean(facetInfo.missing));
            }
            if (facetInfo.prefix != null) {
                solrQuery.setFacetPrefix(facetInfo.prefix);
            }
            if (facetInfo.sort != null && queryHelper.isFacetSortValue(facetInfo.sort)) {
                solrQuery.setFacetSort(facetInfo.sort);
            }
        }
        // mlt
        if (mltInfo != null) {
            final String mltField = queryHelper.getMoreLikeThisField(mltInfo.field);
            if (mltField != null) {
                solrQuery.set("mlt", true);
                if (mltInfo.count != null) {
                    solrQuery.set("mlt.count", Integer.parseInt(mltInfo.count));
                }
                solrQuery.set("mlt.fl", mltField);
            }
        }

        if (queryHelper.getTimeAllowed() >= 0) {
            solrQuery.setTimeAllowed(queryHelper.getTimeAllowed());
        }
        final Set<Entry<String, String[]>> paramSet = queryHelper.getRequestParameterSet();
        if (!paramSet.isEmpty()) {
            for (final Map.Entry<String, String[]> entry : paramSet) {
                solrQuery.set(entry.getKey(), entry.getValue());
            }
        }

        if (docValuesFields != null) {
            for (final String docValuesField : docValuesFields) {
                solrQuery.add(Constants.DCF, docValuesField);
            }
        }

        queryResponse = solrGroup.query(solrQuery, SolrRequest.METHOD.POST);
    }
    final long execTime = System.currentTimeMillis() - startTime;

    final QueryResponseList queryResponseList = ComponentUtil.getQueryResponseList();
    queryResponseList.init(queryResponse, rows);
    queryResponseList.setSearchQuery(q);
    queryResponseList.setSolrQuery(solrQuery.toString());
    queryResponseList.setExecTime(execTime);
    return queryResponseList;
}