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

Introduction

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

Prototype

public ModifiableSolrParams add(String name, String... val) 

Source Link

Document

Add the given values to any existing name

Usage

From source file:org.phenotips.similarity.internal.SolrSimilarPatientsFinder.java

License:Open Source License

/**
 * Generates a Solr query that tries to match patients similar to the reference.
 *
 * @param referencePatient the reference patient
 * @return a query populated with terms from the patient phenotype
 *//*  w ww  .ja  v  a2  s  .co  m*/
private SolrQuery generateQuery(Patient referencePatient, boolean prototypes) {
    SolrQuery query = new SolrQuery();
    StringBuilder q = new StringBuilder();
    // FIXME This is a very basic implementation, to be revisited
    for (Feature phenotype : referencePatient.getFeatures()) {
        if (StringUtils.isNotBlank(phenotype.getId())) {
            q.append(phenotype.getType() + ":" + ClientUtils.escapeQueryChars(phenotype.getId()) + " ");
        }
    }
    // Ignore the reference patient itself (unless reference patient is a temporary in-memory only
    // patient, e.g. a RemoteMatchingPatient created from remote patient data obtained via remote-matching API)
    if (referencePatient.getDocument() != null) {
        q.append("-document:" + ClientUtils.escapeQueryChars(referencePatient.getDocument().toString()));
    }
    q.append(prototypes ? " +" : " -").append("document:xwiki\\:data.MIM*");
    query.add(CommonParams.Q, q.toString());
    //logger.error("SOLRQUERY generated: {}", query.toString());
    return query;
}

---

From source file:org.phenotips.termrequester.db.solr.SolrDatabaseService.java

License:Open Source License

@Override
public List<Phenotype> searchPhenotypes(String text) throws IOException {
    checkUp();/*ww  w  . jav  a 2s  .  co m*/
    try {
        SolrQuery q = new SolrQuery();
        String escaped = ClientUtils.escapeQueryChars(text);
        q.add(CommonParams.Q, escaped);
        q.add(SpellingParams.SPELLCHECK_Q, text);
        q.add(DisMaxParams.PF,
                String.format("%s^20 %s^36 %s^100 %s^30 %s^15 %s^25 %s^70 %s^20 %s^3 %s^5", Schema.NAME,
                        Schema.NAME_SPELL, Schema.NAME_EXACT, Schema.NAME_PREFIX, Schema.SYNONYM,
                        Schema.SYNONYM_SPELL, Schema.SYNONYM_EXACT, Schema.SYNONYM_PREFIX, Schema.TEXT,
                        Schema.TEXT_SPELL));
        String qstring = String.format("%s^10 %s^18 %s^5 %s^6 %s^10 %s^3 %s^1 %s^2 %s^0.5", Schema.NAME,
                Schema.NAME_SPELL, Schema.NAME_STUB, Schema.SYNONYM, Schema.SYNONYM_SPELL, Schema.SYNONYM_STUB,
                Schema.TEXT, Schema.TEXT, Schema.TEXT_SPELL, Schema.TEXT_STUB);
        qstring = addStatusFilter(qstring, Phenotype.Status.SYNONYM);
        q.add(DisMaxParams.QF, qstring);
        q.add("spellcheck", Boolean.toString(true));
        q.add(SpellingParams.SPELLCHECK_COLLATE, Boolean.toString(true));
        q.add(SpellingParams.SPELLCHECK_COUNT, "100");
        q.add(SpellingParams.SPELLCHECK_MAX_COLLATION_TRIES, "3");
        q.add("lowercaseOperators", Boolean.toString(false));
        q.add("defType", "edismax");
        QueryResponse resp = server.query(q);
        List<SolrDocument> results = resp.getResults();
        List<Phenotype> retval = new ArrayList<>(results.size());
        for (SolrDocument doc : results) {
            retval.add(mapper.fromDoc(doc));
        }
        return retval;
    } catch (SolrServerException e) {
        throw new IOException(e);
    }
}

---

From source file:org.phenotips.vocabulary.internal.solr.GeneNomenclature.java

License:Open Source License

private SolrQuery produceDynamicSolrParams(Map<String, String> staticOptions, String originalQuery,
        Integer rows, String sort, String customFilter) {
    String escapedQuery = ClientUtils.escapeQueryChars(originalQuery.trim());

    SolrQuery params = new SolrQuery(escapedQuery);
    for (Map.Entry<String, String> option : staticOptions.entrySet()) {
        params.set(option.getKey(), option.getValue());
    }//from w  ww  .j a  va 2 s.  com
    params.setRows(rows);
    if (StringUtils.isNotBlank(sort)) {
        params.add(CommonParams.SORT, sort);
    }
    params.add(CommonParams.FQ, StringUtils.defaultIfBlank(customFilter, "status:Approved"));
    return params;
}

---

From source file:org.reuseware.sokan.index.solr.SolrControler.java

License:Open Source License

/**
 * Executes the given Solr query.//from  w  ww .  jav  a 2s.c o m
 * 
 * @param query the Solr query
 * @return the query result
 */
public QueryResponse query(SolrQuery query) {
    if (query == null) {
        return null;
    }
    QueryResponse rsp = null;
    query.add("debugQuery", "true");
    try {
        rsp = solrServer.query(query);
    } catch (Exception e) {
        SokanIndexPlugin.logError("", e);
    }

    if (rsp == null) {
        return null;
    }
    return rsp;
}

---

From source file:org.roda.core.index.utils.SolrUtils.java

private static void setSolrFacetParameterSort(SolrQuery query, FacetParameter facetParameter) {
    if (FacetParameter.DEFAULT_SORT != facetParameter.getSort()) {
        query.add(String.format("f.%s.facet.sort", facetParameter.getName()),
                getSolrFacetParameterSortValue(facetParameter.getSort()));
    }//from   w  w  w .ja  v  a 2 s  .  c  om
}

---

From source file:org.roda.core.index.utils.SolrUtils.java

private static void setQueryFacetParameter(SolrQuery query, SimpleFacetParameter facetParameter) {
    query.addFacetField(facetParameter.getName());

    query.add(String.format("f.%s.facet.mincount", facetParameter.getName()),
            String.valueOf(facetParameter.getMinCount()));
    query.add(String.format("f.%s.facet.limit", facetParameter.getName()),
            String.valueOf(facetParameter.getLimit()));

}

---

From source file:org.roda.core.index.utils.SolrUtils.java

/**
 * WARNING: this should only be used to debug/tests only
 * /*from ww w .java2s . co m*/
 * @return
 * @throws IOException
 * @throws SolrServerException
 */
public static QueryResponse executeSolrQuery(SolrClient index, String collection, String solrQueryString)
        throws SolrServerException, IOException {
    LOGGER.trace("query string: {}", solrQueryString);
    SolrQuery query = new SolrQuery();
    for (String string : solrQueryString.split("&")) {
        String[] split = string.split("=");
        query.add(split[0], split[1]);
    }
    LOGGER.trace("executeSolrQuery: {}", query);
    return index.query(collection, query);
}

---

From source file:org.rsc.liferay.solr.SolrIndexSearcher.java

License:Open Source License

protected Hits doSearch(SearchContext searchContext, Query query) throws Exception {

    SolrQuery solrQuery = translateQuery(searchContext.getCompanyId(), query, searchContext.getSorts(),
            searchContext.getStart(), searchContext.getEnd());

    Map<String, Facet> facets = searchContext.getFacets();

    for (Facet facet : facets.values()) {
        if (facet.isStatic()) {
            continue;
        }//from   w  w w  .j  av a  2 s .  c  om

        FacetConfiguration facetConfiguration = facet.getFacetConfiguration();

        if (facet instanceof RangeFacet) {
            solrQuery.addFacetField(facetConfiguration.getFieldName());

            JSONObject dataJSONObject = facetConfiguration.getData();

            JSONArray rangesJSONArray = dataJSONObject.getJSONArray("ranges");

            if (rangesJSONArray == null) {
                continue;
            }

            for (int i = 0; i < rangesJSONArray.length(); i++) {
                JSONObject rangeJSONObject = rangesJSONArray.getJSONObject(i);

                String range = rangeJSONObject.getString("range");

                String facetQuery = facetConfiguration.getFieldName() + StringPool.COLON + range;

                solrQuery.addFacetQuery(facetQuery);
            }
        } else {
            solrQuery.addFacetField(facetConfiguration.getFieldName());
        }

        String facetSort = FacetParams.FACET_SORT_COUNT;

        String order = facetConfiguration.getOrder();

        if (order.equals("OrderValueAsc")) {
            facetSort = FacetParams.FACET_SORT_INDEX;
        }

        solrQuery.add("f." + facetConfiguration.getFieldName() + ".facet.sort", facetSort);
    }

    solrQuery.setFacetLimit(-1);

    QueryResponse queryResponse = _solrServer.query(solrQuery, METHOD.POST);

    boolean allResults = false;

    if (solrQuery.getRows() == 0) {
        allResults = true;
    }

    List<FacetField> facetFields = queryResponse.getFacetFields();

    if (facetFields != null) {
        for (FacetField facetField : facetFields) {
            Facet facet = facets.get(facetField.getName());

            FacetCollector facetCollector = null;

            if (facet instanceof RangeFacet) {
                facetCollector = new SolrFacetQueryCollector(facetField.getName(),
                        queryResponse.getFacetQuery());
            } else {
                facetCollector = new SolrFacetFieldCollector(facetField.getName(), facetField);
            }

            facet.setFacetCollector(facetCollector);
        }
    }

    return subset(solrQuery, query, query.getQueryConfig(), queryResponse, allResults);
}

---

From source file:org.sakaiproject.nakamura.search.solr.SolrResultSetFactory.java

License:Apache License

/**
 * @param request// w  ww  . j a va 2 s.  com
 * @param query
 * @param queryString
 * @return
 */
@SuppressWarnings("unchecked")
private SolrQuery buildQuery(SlingHttpServletRequest request, String queryString, Map<String, Object> options) {
    // build the query
    SolrQuery solrQuery = new SolrQuery(queryString);
    long[] ranges = SolrSearchUtil.getOffsetAndSize(request, options);
    solrQuery.setStart((int) ranges[0]);
    solrQuery.setRows((int) ranges[1]);

    // add in some options
    if (options != null) {
        for (Entry<String, Object> option : options.entrySet()) {
            String key = option.getKey();
            Object val = option.getValue();
            if (CommonParams.SORT.equals(key)) {
                parseSort(solrQuery, String.valueOf(val));
            } else if (val instanceof Object[]) {
                for (Object v : (Object[]) val) {
                    solrQuery.add(key, String.valueOf(v));
                }
            } else if (val instanceof Iterable) {
                for (Object v : (Iterable<Object>) val) {
                    solrQuery.add(key, String.valueOf(v));
                }
            } else {
                solrQuery.add(key, String.valueOf(val));
            }
        }
    }
    return solrQuery;
}

---

From source file:org.schedoscope.metascope.index.SolrQueryExecutor.java

License:Apache License

/**
 * Perform a query on the metascope solr index. Builds up the query string
 * from the given parameters and sends request to solr server
 * /*from  www .  jav a 2 s.co m*/
 * @param params
 *          the parameters which are included in the filter query
 * @return a SolrQueryResult object containing the result of the query
 */
public SolrQueryResult query(Map<String, String> params) {
    SolrQuery query = new SolrQuery();

    /* enable facetting */
    query.setFacet(true);

    /* list of all filters; key: name to display, value: entity parameter */
    List<SolrQueryParameter> filter = new ArrayList<SolrQueryParameter>();

    /* list of partition filter */
    List<SolrQueryParameter> partitionFilter = new ArrayList<SolrQueryParameter>();

    /*
     * list of filter which have been set by the user (key = filtername, value =
     * list of selections)
     */
    Map<String, List<String>> activeFilterValues = new HashMap<String, List<String>>();

    /*
     * determine on which type is searched for (either 'Table' or 'Partition')
     */
    String typeFilterValue = params.get(TYPE);
    filter.add(new SolrQueryParameter(FILTER_TYPE, TYPE, FilterType.EXCLUSIVE, FacetSort.COUNT));
    if (typeFilterValue != null && typeFilterValue.equalsIgnoreCase(TYPE_PARTITION)) {
        typeFilterValue = TYPE_PARTITION;
        for (String parameter : fieldEntityService.findDistinctParameters()) {
            partitionFilter.add(new SolrQueryParameter("Parameter: " + parameter, parameter + "_s",
                    FilterType.AND, FacetSort.INDEX));
        }
        for (SolrQueryParameter pFilter : partitionFilter) {
            query.addFacetField(pFilter.getName());
            query.add("f." + pFilter.getName() + ".facet.sort", "index");
            String filterValue = params.get(pFilter.getName());
            if (filterValue != null && !filterValue.isEmpty()) {
                query.addFilterQuery(pFilter.getName() + ":" + "(" + filterValue.replace(",", " AND ") + ")");
            }

        }
    } else {
        typeFilterValue = TYPE_TABLE;
    }
    query.addFilterQuery("{!tag=" + TYPE + "}" + TYPE + ":" + typeFilterValue);
    query.addFacetField("{!ex=" + TYPE + "}" + TYPE);

    /* set solr search query parameter 'q' */
    String searchQueryValue = params.get(URLUtil.SEARCH_QUERY_PARAM);
    if (searchQueryValue == null || searchQueryValue.isEmpty()) {
        searchQueryValue = "*";
        query.setQuery(searchQueryValue);
    } else {
        String[] queryTerms = searchQueryValue.trim().split(" ");
        String queryTerm = "";
        for (String term : queryTerms) {
            if (term.isEmpty()) {
                continue;
            }

            if (!queryTerm.isEmpty()) {
                queryTerm += " AND ";
            }
            queryTerm += "*" + term + "*";
        }
        query.setQuery(queryTerm);
        query.setHighlight(true);
        query.setHighlightSimplePre("<b>");
        query.setHighlightSimplePost("</b>");
        query.setHighlightSnippets(100);
        query.set("hl.fl", "*");
    }

    /* set the remaining filters */
    for (SolrQueryParameter queryFilter : facetFields) {
        filter.add(queryFilter);
        String value = params.get(queryFilter.getName());

        String filterQuery = "";
        String facetField = "";
        if (queryFilter.isExcludeFromFacet()) {
            if (value != null) {
                String[] multipleFilter = value.split(",");
                value = "(";
                for (int i = 0; i < multipleFilter.length; i++) {
                    String filterValue = cleanseValue(multipleFilter[i]).replace(" ", "*");
                    value += "(" + filterValue + ")";
                    if (i < multipleFilter.length - 1) {
                        value += " " + getOperator(queryFilter.getFilterType()) + " ";
                    }
                }
                value += ")";
            }
            filterQuery = "{!tag=" + queryFilter.getName() + "}" + queryFilter.getName() + ":" + value;
            facetField = "{!ex=" + queryFilter.getName() + "}" + queryFilter.getName();
        } else {
            if (value != null) {
                String[] multipleFilter = value.split(",");
                value = "(";
                for (int i = 0; i < multipleFilter.length; i++) {
                    String filterValue = cleanseValue(multipleFilter[i]).replace(" ", "*");
                    value += "(" + filterValue + ")";
                    if (i < multipleFilter.length - 1) {
                        value += " " + getOperator(queryFilter.getFilterType()) + " ";
                    }
                }
                value += ")";
            }
            filterQuery = queryFilter.getName() + ":" + value;
            facetField = queryFilter.getName();
        }

        if (value != null && !value.isEmpty()) {
            query.addFilterQuery(filterQuery);
        }
        query.addFacetField(facetField);

        if (queryFilter.getFacetSort().equals(FacetSort.INDEX)) {
            query.add("f." + queryFilter.getName() + ".facet.sort", "index");
        }
        query.add("f." + queryFilter.getName() + ".facet.limit", "-1");
    }

    /* set facet queries */
    Map<String, String> facetQueryMap = new HashMap<String, String>();
    long now = System.currentTimeMillis() / 1000;
    for (SolrFacetQuery solrFacetQuery : facetQueries) {
        for (SolrHourRange range : solrFacetQuery.getRanges()) {
            long from = range.getFrom() == Long.MAX_VALUE ? 0 : now - (range.getFrom() * 3600);
            String facetQueryString = solrFacetQuery.getName() + ":[" + from + " TO " + now + "]";
            query.addFacetQuery("{!ex=" + solrFacetQuery.getName() + "}" + facetQueryString);
            facetQueryMap.put(solrFacetQuery.getName() + range.getName(), facetQueryString);
        }
        String value = params.get(solrFacetQuery.getName());
        if (value != null) {
            String fq = "{!tag=" + solrFacetQuery.getName() + "}"
                    + facetQueryMap.get(solrFacetQuery.getName() + value);
            query.addFilterQuery(fq);
        }
    }

    /* always sort the entities (for a deterministic view) */
    query.setSort(ID, ORDER.asc);

    /* set pagination information */
    int page = getPageParameter(params);
    int elements = getElementsParameter(params);
    query.setRows(elements);
    query.setStart((page - 1) * elements);

    /* execute the query */
    QueryResponse queryResponse = null;
    try {
        queryResponse = solrClient.query(query);
    } catch (Exception e) {
        e.printStackTrace();
    }

    SolrDocumentList list = queryResponse.getResults();

    /* get table / view entities from local repository */
    List<SolrQueryResultEntity> resultEntities = new LinkedList<SolrQueryResultEntity>();
    String resultType = "";
    for (SolrDocument solrDocument : list) {
        String id = (String) solrDocument.get(ID);

        if (typeFilterValue.equalsIgnoreCase(TYPE_PARTITION)) {
            if (!searchQueryValue.equals("*")) {
                resultEntities.add(new SolrQueryResultEntity(viewEntityService.findByUrlPath(id),
                        queryResponse.getHighlighting().get(id)));
            } else {
                resultEntities.add(new SolrQueryResultEntity(viewEntityService.findByUrlPath(id)));
            }
            resultType = TYPE_PARTITION;
        } else if (typeFilterValue.equalsIgnoreCase(TYPE_TABLE)) {
            if (!searchQueryValue.equals("*")) {
                resultEntities.add(new SolrQueryResultEntity(tableEntityService.findByFqdn(id),
                        queryResponse.getHighlighting().get(id)));
            } else {
                resultEntities.add(new SolrQueryResultEntity(tableEntityService.findByFqdn(id)));
            }
        }
    }
    if (resultType.isEmpty()) {
        resultType = TYPE_TABLE;
    }

    filter.addAll(partitionFilter);

    /* get the facet values and counts */
    Map<String, List<SolrFacet>> facetValues = new HashMap<String, List<SolrFacet>>();
    for (SolrQueryParameter f : filter) {
        if (!f.getName().equals(URLUtil.SEARCH_QUERY_PARAM)) {
            List<SolrFacet> values = new ArrayList<SolrFacet>();
            FacetField facet = queryResponse.getFacetField(f.getName());
            for (Count count : facet.getValues()) {
                values.add(new SolrFacet(count.getName(), count.getCount()));
            }
            facetValues.put(f.getName(), values);
        }
    }

    /* remove the type filter */
    filter.remove(0);

    for (SolrFacetQuery solrFacetQuery : facetQueries) {
        filter.add(new SolrQueryParameter(solrFacetQuery.getDisplayName(), solrFacetQuery.getName(),
                FilterType.EXCLUSIVE));
        List<SolrFacet> values = new ArrayList<SolrFacet>();
        for (SolrHourRange range : solrFacetQuery.getRanges()) {
            long facetQueryCount = getFacetQueryCount(queryResponse, "{!ex=" + solrFacetQuery.getName() + "}"
                    + facetQueryMap.get(solrFacetQuery.getName() + range.getName()));
            values.add(new SolrFacet(range.getName(), facetQueryCount));
        }
        facetValues.put(solrFacetQuery.getName(), values);
    }

    /* get the active filter values which have been selected by the user */
    addToActiveFilterValues(activeFilterValues, params, filter);

    /* build and return the result */
    SolrQueryResult result = new SolrQueryResult().withResultEntities(resultEntities).withResultType(resultType)
            .withFilters(filter).withFacetValues(facetValues).withActiveFilterValues(activeFilterValues)
            .withSearchQuery(searchQueryValue).withPage(page).withElements(elements)
            .withTotalPages((int) Math.ceil(((double) list.getNumFound()) / elements))
            .withTotalResults(list.getNumFound());
    return result;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• »