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

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

  1. HOME
  2. Java
  3. org.apache.solr
  4. org.apache.solr.client.solrj.*
  5. SolrQuery
  6. 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:com.plugtree.solrmeter.model.service.impl.QueryServiceSolrJImpl.java

License:Apache License

protected SolrQuery createQuery(String q, String fq, String qt, boolean highlight, String facetFields,
        String sort, String sortOrder, Integer rows, Integer start, String otherParams) throws QueryException {
    SolrQuery query = new SolrQuery();
    if (q != null) {
        query.setQuery(q);/*ww  w  .ja va 2  s . c o  m*/
    }
    if (fq != null) {
        List<String> filterQueries = this.getFilterQueries(fq);
        for (String filterQuery : filterQueries) {
            query.addFilterQuery(filterQuery);
        }
    }
    if (qt != null) {
        query.setQueryType(qt);
    }
    query.setHighlight(highlight);
    if (facetFields == null || "".equals(facetFields)) {
        query.setFacet(false);
    } else {
        query.setFacet(true);
        List<String> facets = this.getFacets(facetFields);
        for (String facet : facets) {
            query.addFacetField(facet);
        }
    }
    if (sort != null && !"".equals(sort)) {
        query.setSortField(sort, ORDER.valueOf(sortOrder));
    }
    if (rows != null && rows < 0) {
        throw new QueryException("Rows can't be less than 0");
    } else if (rows != null) {
        query.setRows(rows);
    }
    if (start != null && start < 0) {
        throw new QueryException("Rows can't be less than 0");
    } else if (start != null) {
        query.setStart(start);
    }

    if (otherParams != null) {
        List<String> params = this.getOtherParams(otherParams);
        for (String param : params) {
            query.add(getParamName(param), getParamValue(param));
        }
    }
    return query;
}

From source file:com.riemersebastian.solrduplicate.SolrDuplicateTest.java

private void executeQueryAndShowResults() {
    LOGGER.info("List all documents with id = 'parent_1' ");
    try {/*www  .ja  v a 2 s.co  m*/
        SolrQuery query = new SolrQuery();
        query.add("q", "*:*");
        query.add("fq", "id:parent_1");
        QueryResponse response = solrClient.query(query);
        SolrDocumentList results = response.getResults();
        for (SolrDocument doc : results) {
            LOGGER.info("Found document with id = '" + doc.get("id") + "'");
        }
        LOGGER.info("Found a total of " + results.getNumFound() + " documents having id='parent_1'.");
    } catch (SolrServerException | IOException ex) {
        LOGGER.log(Level.SEVERE, "Exception while querying index!", ex);
    }
}

From source file:com.smartitengineering.common.dao.search.solr.SolrFreeTextSearchDao.java

License:Open Source License

@Override
public SearchResult<T> detailedSearch(List<QueryParameter> parameters) {
    SolrQuery query = new SolrQuery();
    for (QueryParameter param : parameters) {
        switch (param.getParameterType()) {
        case PARAMETER_TYPE_PROPERTY:
            StringLikeQueryParameter queryParameter = QueryParameterCastHelper.STRING_PARAM_HELPER.cast(param);
            if (queryParameter.getPropertyName().equals("q")) {
                String queryString = queryParameter.getValue();
                query.setQuery(queryString);
            } else {
                query.add(queryParameter.getPropertyName(), queryParameter.getValue());
            }//from www .  j ava  2 s  .  c o  m
            break;
        case PARAMETER_TYPE_ORDER_BY:
            SimpleNameValueQueryParameter<Order> parameter = QueryParameterCastHelper.SIMPLE_PARAM_HELPER
                    .cast(param);
            ORDER order = parameter.getValue().equals(Order.ASC) ? ORDER.asc : ORDER.desc;
            query.setSortField(parameter.getPropertyName(), order);
            break;
        case PARAMETER_TYPE_MAX_RESULT:
            ValueOnlyQueryParameter<Integer> valParam = QueryParameterCastHelper.VALUE_PARAM_HELPER.cast(param);
            Integer maxRows = valParam.getValue();
            query.setRows(maxRows);
            break;
        case PARAMETER_TYPE_FIRST_RESULT:
            ValueOnlyQueryParameter<Integer> firstParam = QueryParameterCastHelper.VALUE_PARAM_HELPER
                    .cast(param);
            Integer firstResult = firstParam.getValue();
            query.setStart(firstResult);
            break;
        default:
            throw new UnsupportedOperationException("Only property and order by query parameter is supported!");
        }
    }
    query.setIncludeScore(true);
    final SearchResult<MultivalueMap<String, Object>> mainResult = queryDao.getResult(query);
    final Collection<MultivalueMap<String, Object>> result = mainResult.getResult();
    final Collection<T> convertedResult = adapter
            .convertInversely(result.toArray(new MultivalueMap[result.size()]));
    Iterator<T> resultItr = convertedResult.iterator();
    while (resultItr.hasNext()) {
        T next = resultItr.next();
        if (next == null) {
            resultItr.remove();
        }
    }
    final SearchResult<T> actualResult = new SearchResult<T>(convertedResult, mainResult);
    return actualResult;
}

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());//from   w ww  .j  a va  2  s .  co 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:ddf.catalog.cache.solr.impl.DynamicSchemaResolver.java

License:Open Source License

/**
 * Adds the fields that are already in the server to the cache. This method should be called
 * once the SolrServer is up to ensure the cache is synchronized with the server.
 * // w w  w .j av  a 2 s .  c  om
 * @param server
 *            the SolrServer we are working with
 */
public void addFieldsFromServer(SolrServer server) {
    if (server == null) {
        LOGGER.warn("Server is null, could not add fields to cache.");
        return;
    }

    SolrQuery query = new SolrQuery();

    // numterms=0 means retrieve everything (regular or dynamic fields)
    query.add("numterms", "0");

    /*
     * Adding this request handler allows us to query the schema dynamically. The name of the
     * request handler is provided by the schema.xml. If the name is changed in the schema.xml,
     * then this value must be changed as well.
     */
    query.setRequestHandler("/admin/luke");

    QueryResponse response = null;

    try {
        response = server.query(query);
        for (Entry<String, ?> e : ((SimpleOrderedMap<?>) (response.getResponse().get(FIELDS_KEY)))) {
            fieldsCache.add(e.getKey());
        }
    } catch (SolrServerException e) {
        LOGGER.warn("Could not update cache for field names.", e);
    } catch (SolrException e) {
        LOGGER.warn("Could not update cache for field names.", e);
    }
}

From source file:ddf.catalog.source.solr.DynamicSchemaResolver.java

License:Open Source License

/**
 * Adds the fields that are already in the server to the cache. This method should be called
 * once the SolrServer is up to ensure the cache is synchronized with the server.
 *
 * @param server/*w  ww  .ja v  a  2 s.c o m*/
 *            the SolrServer we are working with
 */
public void addFieldsFromServer(SolrServer server) {
    if (server == null) {
        LOGGER.warn("Server is null, could not add fields to cache.");
        return;
    }

    SolrQuery query = new SolrQuery();

    // numterms=0 means retrieve everything (regular or dynamic fields)
    query.add("numterms", "0");

    /*
     * Adding this request handler allows us to query the schema dynamically. The name of the
     * request handler is provided by the schema.xml. If the name is changed in the schema.xml,
     * then this value must be changed as well.
     */
    query.setRequestHandler("/admin/luke");

    try {
        QueryResponse response = server.query(query);
        for (Entry<String, ?> e : ((SimpleOrderedMap<?>) (response.getResponse().get(FIELDS_KEY)))) {
            fieldsCache.add(e.getKey());
        }
    } catch (SolrServerException | SolrException e) {
        LOGGER.warn("Could not update cache for field names.", e);
    }
}

From source file:ddf.catalog.source.solr.SolrMetacardClient.java

License:Open Source License

protected String getSortProperty(QueryRequest request, SolrQuery query) {
    SortBy sortBy = request.getQuery().getSortBy();
    String sortProperty = "";

    if (sortBy != null && sortBy.getPropertyName() != null) {
        sortProperty = sortBy.getPropertyName().getPropertyName();
        SolrQuery.ORDER order = SolrQuery.ORDER.desc;

        if (sortBy.getSortOrder() == SortOrder.ASCENDING) {
            order = SolrQuery.ORDER.asc;
        }//from w w  w  .java 2s.c  o  m

        if (Result.RELEVANCE.equals(sortProperty) || Result.DISTANCE.equals(sortProperty)) {
            query.setFields("*", RELEVANCE_SORT_FIELD);
            query.addSort(RELEVANCE_SORT_FIELD, order);
        } else if (sortProperty.equals(Result.TEMPORAL)) {
            query.addSort(resolver.getField(Metacard.EFFECTIVE, AttributeType.AttributeFormat.DATE, false),
                    order);
        } else {
            List<String> resolvedProperties = resolver.getAnonymousField(sortProperty);

            if (!resolvedProperties.isEmpty()) {
                for (String sortField : resolvedProperties) {
                    query.addSort(sortField, order);
                }

                query.add("fl", "*," + RELEVANCE_SORT_FIELD);
            } else {
                LOGGER.info(
                        "No schema field was found for sort property [{}]. No sort field was added to the query.",
                        sortProperty);
            }

        }

    }
    return sortProperty;
}

From source file:ddf.catalog.source.solr.SolrMetacardClientImpl.java

License:Open Source License

private void addDistanceSort(SolrQuery query, String sortField, SolrQuery.ORDER order,
        SolrFilterDelegate delegate) {/* w  ww . java2  s.  com*/
    if (delegate.isSortedByDistance()) {
        query.addSort(DISTANCE_SORT_FUNCTION, order);
        query.setFields("*", RELEVANCE_SORT_FIELD, DISTANCE_SORT_FIELD + ":" + DISTANCE_SORT_FUNCTION);
        query.add(SORT_FIELD_KEY, sortField);
        query.add(POINT_KEY, delegate.getSortedDistancePoint());
    }
}

From source file:edu.cornell.mannlib.vitro.webapp.search.controller.PagedSearchController.java

License:Open Source License

private SolrQuery getQuery(String queryText, int hitsPerPage, int startIndex, VitroRequest vreq) {
    // Lowercase the search term to support wildcard searches: Solr applies no text
    // processing to a wildcard search term.
    SolrQuery query = new SolrQuery(queryText);

    query.setStart(startIndex).setRows(hitsPerPage);

    // ClassGroup filtering param
    String classgroupParam = (String) vreq.getParameter(PARAM_CLASSGROUP);

    // rdf:type filtering param
    String typeParam = (String) vreq.getParameter(PARAM_RDFTYPE);

    if (!StringUtils.isBlank(classgroupParam)) {
        // ClassGroup filtering
        log.debug("Firing classgroup query ");
        log.debug("request.getParameter(classgroup) is " + classgroupParam);
        query.addFilterQuery(VitroSearchTermNames.CLASSGROUP_URI + ":\"" + classgroupParam + "\"");

        //with ClassGroup filtering we want type facets
        query.add("facet", "true");
        query.add("facet.limit", "-1");
        query.add("facet.field", VitroSearchTermNames.RDFTYPE);

    } else if (!StringUtils.isBlank(typeParam)) {
        // rdf:type filtering
        log.debug("Firing type query ");
        log.debug("request.getParameter(type) is " + typeParam);
        query.addFilterQuery(VitroSearchTermNames.RDFTYPE + ":\"" + typeParam + "\"");

        //with type filtering we don't have facets.            
    } else {//from  w  ww. j  a va2s  .  c om
        //When no filtering is set, we want ClassGroup facets
        query.add("facet", "true");
        query.add("facet.limit", "-1");
        query.add("facet.field", VitroSearchTermNames.CLASSGROUP_URI);
    }

    log.debug("Query = " + query.toString());
    return query;
}

From source file:edu.unc.lib.dl.search.solr.service.SolrSearchService.java

License:Apache License

/**
 * Constructs a SolrQuery object from the search state specified within a SearchRequest object. The request may
 * optionally request to retrieve facet results in addition to search results.
 * //from   w  w w  .j  ava2s  .  c  o m
 * @param searchRequest
 * @param isRetrieveFacetsRequest
 * @return
 */
protected SolrQuery generateSearch(SearchRequest searchRequest) {
    SearchState searchState = (SearchState) searchRequest.getSearchState();
    SolrQuery solrQuery = new SolrQuery();
    StringBuilder termQuery = new StringBuilder();

    // Generate search term query string
    addSearchFields(searchState, termQuery);

    // Add range Fields to the query
    addRangeFields(searchState, termQuery);

    // No query terms given, make it an everything query
    StringBuilder query = new StringBuilder();
    if (termQuery.length() == 0) {
        query.append("*:* ");
    } else {
        query.append('(').append(termQuery).append(')');
    }

    // Add access restrictions to query
    try {
        addAccessRestrictions(query, searchRequest.getAccessGroups());
    } catch (AccessRestrictionException e) {
        // If the user doesn't have any access groups, they don't have access to anything, return null.
        LOG.debug("User had no access groups", e);
        return null;
    }

    // Add query
    solrQuery.setQuery(query.toString());

    if (searchState.getResultFields() != null) {
        for (String field : searchState.getResultFields()) {
            String solrFieldName = solrSettings.getFieldName(field);
            if (solrFieldName != null)
                solrQuery.addField(solrFieldName);
        }
    }

    if (searchState.getRollup() != null && searchState.getRollup()) {
        solrQuery.set(GroupParams.GROUP, true);
        if (searchState.getRollupField() == null)
            solrQuery.set(GroupParams.GROUP_FIELD, solrSettings.getFieldName(SearchFieldKeys.ROLLUP_ID.name()));
        else
            solrQuery.set(GroupParams.GROUP_FIELD, solrSettings.getFieldName(searchState.getRollupField()));

        solrQuery.set(GroupParams.GROUP_TOTAL_COUNT, true);
        if (searchState.getFacetsToRetrieve() != null && searchState.getFacetsToRetrieve().size() > 0) {
            solrQuery.set(GroupParams.GROUP_FACET, true);
        }
    }

    // Add sort parameters
    List<SearchSettings.SortField> sortFields = searchSettings.sortTypes.get(searchState.getSortType());
    if (sortFields != null) {
        for (int i = 0; i < sortFields.size(); i++) {
            SearchSettings.SortField sortField = sortFields.get(i);
            SolrQuery.ORDER sortOrder = SolrQuery.ORDER.valueOf(sortField.getSortOrder());
            if (!searchState.getSortNormalOrder())
                sortOrder = sortOrder.reverse();
            solrQuery.addSort(solrSettings.getFieldName(sortField.getFieldName()), sortOrder);
        }
    }

    // Set requested resource types
    String resourceTypeFilter = this.getResourceTypeFilter(searchState.getResourceTypes());
    if (resourceTypeFilter != null) {
        solrQuery.addFilterQuery(resourceTypeFilter);
    }

    // Turn on faceting
    if (searchRequest.isRetrieveFacets()) {
        solrQuery.setFacet(true);
        solrQuery.setFacetMinCount(1);
        if (searchState.getBaseFacetLimit() != null)
            solrQuery.setFacetLimit(searchState.getBaseFacetLimit());

        if (searchState.getFacetsToRetrieve() != null) {
            // Add facet fields
            for (String facetName : searchState.getFacetsToRetrieve()) {
                String facetField = solrSettings.getFieldName(facetName);
                if (facetField != null)
                    solrQuery.addFacetField(solrSettings.getFieldName(facetName));
            }
        }
    }

    // Override the base facet limit if overrides are given.
    if (searchState.getFacetLimits() != null) {
        for (Entry<String, Integer> facetLimit : searchState.getFacetLimits().entrySet()) {
            solrQuery.add("f." + solrSettings.getFieldName(facetLimit.getKey()) + ".facet.limit",
                    facetLimit.getValue().toString());
        }
    }

    // Add facet limits
    Map<String, Object> facets = searchState.getFacets();
    if (facets != null) {
        Iterator<Entry<String, Object>> facetIt = facets.entrySet().iterator();
        while (facetIt.hasNext()) {
            Entry<String, Object> facetEntry = facetIt.next();

            if (facetEntry.getValue() instanceof String) {
                LOG.debug("Adding facet " + facetEntry.getKey() + " as a String");
                // Add Normal facets
                solrQuery.addFilterQuery(solrSettings.getFieldName(facetEntry.getKey()) + ":\""
                        + SolrSettings.sanitize((String) facetEntry.getValue()) + "\"");
            } else {
                LOG.debug("Adding facet " + facetEntry.getKey() + " as a "
                        + facetEntry.getValue().getClass().getName());
                facetFieldUtil.addToSolrQuery(facetEntry.getValue(), solrQuery);
            }
        }
    }

    // Scope hierarchical facet results to the highest tier selected within the facet tree
    if (searchRequest.isRetrieveFacets() && searchRequest.isApplyCutoffs()
            && searchState.getFacetsToRetrieve() != null) {
        Set<String> facetsQueried = searchState.getFacets().keySet();
        // Apply closing cutoff to all cutoff facets that are being retrieved but not being queried for
        for (String fieldKey : searchState.getFacetsToRetrieve()) {
            if (!facetsQueried.contains(fieldKey)) {
                facetFieldUtil.addDefaultFacetPivot(fieldKey, solrQuery);
            }
        }

        // Add individual facet field sorts if they are present.
        if (searchState.getFacetSorts() != null) {
            for (Entry<String, String> facetSort : searchState.getFacetSorts().entrySet()) {
                solrQuery.add("f." + solrSettings.getFieldName(facetSort.getKey()) + ".facet.sort",
                        facetSort.getValue());
            }
        }
    }

    // Set Navigation options
    if (searchState.getStartRow() != null)
        solrQuery.setStart(searchState.getStartRow());
    if (searchState.getRowsPerPage() != null)
        solrQuery.setRows(searchState.getRowsPerPage());

    return solrQuery;
}