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(SortClause sortClause)

Source Link

Document

Adds a single sort clause to the end of the query.

Usage

From source file:com.liferay.portal.search.solr.internal.SolrIndexSearcher.java

License:Open Source License

protected void addSort(SolrQuery solrQuery, Sort[] sorts) {
    if (ArrayUtil.isEmpty(sorts)) {
        return;// w w w  .  ja  va 2s .co m
    }

    Set<String> sortFieldNames = new HashSet<>(sorts.length);

    for (Sort sort : sorts) {
        if (sort == null) {
            continue;
        }

        String sortFieldName = DocumentImpl.getSortFieldName(sort, "score");

        if (sortFieldNames.contains(sortFieldName)) {
            continue;
        }

        sortFieldNames.add(sortFieldName);

        ORDER order = ORDER.asc;

        if (sort.isReverse() || sortFieldName.equals("score")) {
            order = ORDER.desc;
        }

        solrQuery.addSort(new SortClause(sortFieldName, order));
    }
}

From source file:com.liferay.portal.search.solr.SolrIndexSearcher.java

License:Open Source License

protected void addSort(SolrQuery solrQuery, Sort[] sorts) {
    if (ArrayUtil.isEmpty(sorts)) {
        return;/* w  ww  .  j a  va2  s  . com*/
    }

    Set<String> sortFieldNames = new HashSet<String>();

    for (Sort sort : sorts) {
        if (sort == null) {
            continue;
        }

        String sortFieldName = DocumentImpl.getSortFieldName(sort, "score");

        if (sortFieldNames.contains(sortFieldName)) {
            continue;
        }

        sortFieldNames.add(sortFieldName);

        ORDER order = ORDER.asc;

        if (sort.isReverse() || sortFieldName.equals("score")) {
            order = ORDER.desc;
        }

        solrQuery.addSort(new SortClause(sortFieldName, order));
    }
}

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

License:Apache License

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

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

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

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

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

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

License:Apache License

@Override
public SolrQuery transform(final Q query) {
    final SolrQuery solrQuery = new SolrQuery(query.getQuery());
    solrQuery.setStart(query.getOffset());
    solrQuery.setRows(query.getRows());/*  w  w  w  .  ja va  2  s  .c  o m*/
    solrQuery.setParam("q.op", query.getDefaultOperator().name());

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

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

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

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

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

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

    return solrQuery;
}

From source file:de.dlr.knowledgefinder.webapp.webservice.solr.query.AbstractSolrQueryFactory.java

License:Apache License

private void addSortMethodToSolrQuery(SolrQuery solrQuery, String[] sort) {
    if (sort != null) {
        for (String s : sort) {
            tryToAddSortOrder(solrQuery, s);
        }/*  ww  w.  j a v  a2  s  .c  o m*/
    }

    if (solrQuery.getSorts().size() == 0) {
        solrQuery.addSort(getDefaultSort());
    }
}

From source file:de.dlr.knowledgefinder.webapp.webservice.solr.query.AbstractSolrQueryFactory.java

License:Apache License

private void tryToAddSortOrder(SolrQuery solrQuery, String s) {
    if (s != null && !s.equals("")) {
        String[] sortSplit = s.trim().split(" ");
        if (sortSplit.length == 2) {
            ORDER queryOrderSort = null;
            if (sortSplit[1].equals("asc")) {
                queryOrderSort = SolrQuery.ORDER.asc;
            } else if (sortSplit[1].equals("desc")) {
                queryOrderSort = SolrQuery.ORDER.desc;
            }/*from w  ww  .  j a va 2  s .  c o  m*/
            String fieldSort = sortSplit[0];
            if (queryOrderSort != null) {
                solrQuery.addSort(new SortClause(fieldSort, queryOrderSort));
            }
        }
    }
}

From source file:edu.vt.vbi.patric.common.DataApiHandler.java

License:Apache License

public SolrQuery buildSolrQuery(Map<String, String> key, String sorts, String facets, int start, int end,
        boolean highlight) {

    SolrQuery query = new SolrQuery();
    SolrInterface solr = new SolrInterface();

    // Processing key map
    query.setQuery(StringHelper.stripQuoteAndParseSolrKeywordOperator(key.get("keyword")));

    if (key.containsKey("filter") && key.get("filter") != null) {
        query.addFilterQuery(key.get("filter"));
    }/*from w  ww. j ava  2s.  c om*/
    if (key.containsKey("filter2") && key.get("filter2") != null) {
        query.addFilterQuery(key.get("filter2"));
    }

    // use SolrJoin if possible
    if (key.containsKey("join")) {
        query.addFilterQuery(key.get("join"));
    }

    if (key.containsKey("fields") && !key.get("fields").equals("")) {
        query.addField(key.get("fields"));
    }

    // sort conditions
    if (sorts != null && !sorts.equals("") && !sorts.equals("[]")) {
        try {
            JSONArray sorter = (JSONArray) new JSONParser().parse(sorts);
            for (Object aSort : sorter) {
                JSONObject jsonSort = (JSONObject) aSort;
                query.addSort(SolrQuery.SortClause.create(jsonSort.get("property").toString(),
                        jsonSort.get("direction").toString().toLowerCase()));
            }
        } catch (ParseException e) {
            LOGGER.error(e.getMessage(), e);
        }
    }

    // facet conditions
    if (facets != null && !facets.equals("") && !facets.equals("{}")) {
        query.setFacet(true).setFacetMinCount(1).setFacetLimit(-1).setFacetSort(FacetParams.FACET_SORT_COUNT)
                .set("json.nl", "map");

        try {
            JSONObject facetConditions = (JSONObject) new JSONParser().parse(facets);

            if (facetConditions.containsKey("facet.sort")) {
                String facetSort = facetConditions.get("facet.sort").toString();
                if (facetSort.equals("index")) {
                    query.setFacetSort(FacetParams.FACET_SORT_INDEX);
                }
            }

            if (facetConditions.containsKey("field_facets")) {
                String[] fieldFacets = facetConditions.get("field_facets").toString().split(",");
                query.addFacetField(fieldFacets);
            }

            if (facetConditions.containsKey("date_range_facets")
                    && !facetConditions.get("date_range_facets").equals("")) {
                String[] dateRangeFacets = facetConditions.get("date_range_facets").toString().split(",");
                for (String field : dateRangeFacets) {
                    query.addDateRangeFacet(field, solr.getRangeStartDate(), solr.getRangeEndDate(),
                            solr.getRangeDate());
                }
            }
        } catch (ParseException e) {
            LOGGER.error(e.getMessage(), e);
        }
    }

    // start & end
    query.setStart(start); // setting starting index

    if (end == -1) {
        query.setRows(MAX_ROWS);
    } else {
        query.setRows(end);
    }

    // highlight
    if (highlight) {
        query.set("hl", "on").set("hl.fl", "*");
    }

    return query;
}

From source file:io.logspace.hq.core.solr.utils.SolrQueryHelper.java

License:Open Source License

public static void addSort(SolrQuery solrQuery, String sort, FieldDefinitions fieldDefinitions) {
    if (sort.endsWith(" asc") || sort.endsWith(" ASC")) {
        String apiFieldName = sort.substring(0, sort.length() - 4);
        String solrFieldName = fieldDefinitions.getSolrFieldName(apiFieldName);
        solrQuery.addSort(SortClause.asc(solrFieldName));
        return;/*ww w . j  ava2 s. c  o m*/
    }

    if (sort.endsWith(" desc") || sort.endsWith(" DESC")) {
        String apiFieldName = sort.substring(0, sort.length() - 5);
        String solrFieldName = fieldDefinitions.getSolrFieldName(apiFieldName);
        solrQuery.addSort(SortClause.desc(solrFieldName));
        return;
    }

    throw new IllegalArgumentException("Invalid sort argument. Expected 'fieldname asc' or 'fieldname desc'.");
}

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

License:Apache License

public QueryResponse getSolrDocs(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 isCountOnlyQuery) {

    String solrUrl = solrServer;/*from  ww  w.jav a 2  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().setQuery("{!cache=false}" + 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 + "]");
    }
    if (solrAggrParams != null && !solrAggrParams.isEmpty() && !isCountOnlyQuery) {
        solrQuery.setGetFieldStatistics(true);
        String referenceToStatsTag = "{!stats=t1}";
        String statsTag = "{!tag=t1}";
        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()]);
        }
        SolrClientAPIExec.logger.debug("Adding stats field parameter.." + statsFieldList + "");

        if (isGroup) {
            List<String> groupFields = Lists.newArrayList();
            solrQuery.addGetFieldStatistics(statsTag + Joiner.on(",").join(statsFieldList));
            for (String aggrField : fields) {
                if (fields.contains(aggrField)) {
                    groupFields.add(aggrField);
                }
            }
            if (groupFields.size() == 1) {
                SolrClientAPIExec.logger.debug("Adding stats facet parameters.." + groupFields + "");
                for (String statsField : statsFieldList) {
                    solrQuery.addStatsFieldFacets(statsField,
                            groupFields.toArray(new String[groupFields.size()]));
                }
            } else {
                SolrClientAPIExec.logger.debug("Adding facet pivot parameters.." + groupFields + "");
                solrQuery.addFacetPivotField(referenceToStatsTag + Joiner.on(",").join(groupFields));
                solrQuery.setFacetLimit(-1);
            }
        } else {
            for (String statsField : statsFieldList) {
                solrQuery.setGetFieldStatistics(statsField);
            }
        }
        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.setFacetLimit(-1);
    } else {
        solrQuery.set(CursorMarkParams.CURSOR_MARK_PARAM, cursorMark);
        solrQuery.addSort(SolrQuery.SortClause.desc(uniqueKey));

    }
    if (!solrSortParams.isEmpty()) {
        for (SolrSortParam solrSortParam : solrSortParams) {
            String solrSortField = solrSortParam.getSortFieldName();
            ORDER solrSortDir = solrSortParam.getSortDir();
            solrQuery.addSort(solrSortField, solrSortDir);

        }
    }

    QueryResponse rsp = null;
    try {
        SolrClientAPIExec.logger.info("Submitting Query :" + solrUrl + "/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.broadleafcommerce.core.search.service.solr.SolrHelperServiceImpl.java

License:Apache License

@Override
public void attachSortClause(SolrQuery query, SearchCriteria searchCriteria, String defaultSort,
        List<Field> fields) {
    Map<String, String> solrFieldKeyMap = getSolrFieldKeyMap(searchCriteria, fields);

    String sortQuery = searchCriteria.getSortQuery();
    if (StringUtils.isBlank(sortQuery)) {
        sortQuery = defaultSort;/*from  www . j  a v  a  2 s .  c om*/
    }

    if (StringUtils.isNotBlank(sortQuery)) {
        String[] sortFields = sortQuery.split(",");
        for (String sortField : sortFields) {
            String field = sortField.split(" ")[0];
            if (solrFieldKeyMap.containsKey(field)) {
                field = solrFieldKeyMap.get(field);
            }
            ORDER order = "desc".equals(sortField.split(" ")[1]) ? ORDER.desc : ORDER.asc;

            if (field != null) {
                query.addSort(new SortClause(field, order));
            }
        }
    }
}