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

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

Introduction

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

Prototype

public String getQuery() 

Source Link

Usage

From source file:edu.unc.lib.dl.ui.service.SolrQueryLayerService.java

License:Apache License

public void getChildrenCounts(List<BriefObjectMetadata> resultList, AccessGroupSet accessGroups,
        String countName, String queryAddendum, SolrQuery baseQuery) {
    long startTime = System.currentTimeMillis();
    if (resultList == null || resultList.size() == 0)
        return;//ww w  .  j  ava 2  s.  com

    String ancestorPathField = solrSettings.getFieldName(SearchFieldKeys.ANCESTOR_PATH.name());
    SolrQuery solrQuery;
    if (baseQuery == null) {
        // Create a base query since we didn't receive one
        solrQuery = new SolrQuery();
        StringBuilder query = new StringBuilder("*:*");
        try {
            // Add access restrictions to query
            addAccessRestrictions(query, accessGroups);
        } catch (AccessRestrictionException e) {
            // If the user doesn't have any access groups, they don't have access to anything, return null.
            LOG.error(e.getMessage());
            return;
        }

        solrQuery.setStart(0);
        solrQuery.setRows(0);

        solrQuery.setQuery(query.toString());
    } else {
        // Starting from a base query
        solrQuery = baseQuery.getCopy();
        // Make sure we aren't returning any normal results
        solrQuery.setRows(0);
        // Remove all facet fields so we are only getting ancestor path
        if (solrQuery.getFacetFields() != null) {
            for (String facetField : solrQuery.getFacetFields()) {
                solrQuery.removeFacetField(facetField);
            }
        }
    }

    if (queryAddendum != null) {
        solrQuery.setQuery(solrQuery.getQuery() + " AND " + queryAddendum);
    }

    solrQuery.setFacet(true);
    solrQuery.setFacetMinCount(1);
    solrQuery.addFacetField(ancestorPathField);

    Integer countPageSize;
    try {
        countPageSize = new Integer(searchSettings.getProperty("search.facet.countPageSize"));
    } catch (NumberFormatException e) {
        countPageSize = 20;
    }

    solrQuery.add("f." + ancestorPathField + ".facet.limit", Integer.toString(Integer.MAX_VALUE));
    // Sort by value rather than count so that earlier tiers will come first in case the result gets cut off
    solrQuery.setFacetSort("index");

    java.util.Map<Integer, StringBuilder> tierQueryMap = new java.util.HashMap<Integer, StringBuilder>();
    java.util.Map<Integer, List<BriefObjectMetadata>> containerMap = new java.util.HashMap<Integer, List<BriefObjectMetadata>>();

    // Pare the list of ids we are searching for and assigning counts to down to just containers
    for (BriefObjectMetadata metadataObject : resultList) {
        if (metadataObject.getPath() != null && metadataObject.getContentModel() != null
                && metadataObject.getContentModel().contains(ContentModelHelper.Model.CONTAINER.toString())) {
            CutoffFacetNode highestTier = metadataObject.getPath().getHighestTierNode();
            StringBuilder tierQuery = tierQueryMap.get(highestTier.getTier());
            List<BriefObjectMetadata> containerObjects = containerMap.get(highestTier.getTier());
            if (tierQuery == null) {
                tierQuery = new StringBuilder();
                tierQueryMap.put(highestTier.getTier(), tierQuery);

                containerObjects = new ArrayList<BriefObjectMetadata>();
                containerMap.put(highestTier.getTier(), containerObjects);
            }

            if (tierQuery.length() == 0) {
                tierQuery.append(ancestorPathField).append(":(");
            } else {
                tierQuery.append(" OR ");
            }

            tierQuery.append(SolrSettings.sanitize(highestTier.getSearchValue())).append(",*");
            containerObjects.add(metadataObject);

            // If there are a lot of results, then do a partial lookup
            if (containerObjects.size() >= countPageSize) {
                tierQuery.append(")");
                this.executeChildrenCounts(tierQuery, containerObjects, solrQuery, countName,
                        highestTier.getTier());
                LOG.info("Partial query done at " + System.currentTimeMillis() + " ("
                        + (System.currentTimeMillis() - startTime) + ")");
                containerMap.remove(highestTier.getTier());
                tierQueryMap.remove(highestTier.getTier());
            }
        }
    }

    Iterator<java.util.Map.Entry<Integer, StringBuilder>> queryIt = tierQueryMap.entrySet().iterator();
    while (queryIt.hasNext()) {
        java.util.Map.Entry<Integer, StringBuilder> tierQueryEntry = queryIt.next();
        tierQueryEntry.getValue().append(')');
        this.executeChildrenCounts(tierQueryEntry.getValue(), containerMap.get(tierQueryEntry.getKey()),
                solrQuery, countName, tierQueryEntry.getKey());
    }
    LOG.info("Child count query done at " + System.currentTimeMillis() + " ("
            + (System.currentTimeMillis() - startTime) + ")");
}

From source file:eu.europeana.core.BeanQueryModelFactory.java

License:EUPL

@Override
public QueryResponse getSolrResponse(SolrQuery solrQuery, boolean isBriefDoc, Map<String, String[]> params)
        throws EuropeanaQueryException { // add bean to ???
    // since we make a defensive copy before the start is decremented we must do it here
    if (solrQuery.getStart() != null && solrQuery.getStart() > 0) {
        solrQuery.setStart(solrQuery.getStart() - 1);
    }/*from  w  ww .  ja v  a  2s  . co m*/
    // set facets
    if (isBriefDoc) {
        // only show spelling-suggestion on the first result page
        if ((solrQuery.getStart() == null || solrQuery.getStart() == 0)
                && solrQuery.getFilterQueries() == null) {
            // give spelling suggestions
            solrQuery.setParam("spellcheck", true);
            solrQuery.setParam("spellcheck.collate", true);
            solrQuery.setParam("spellcheck.extendedResults", true);
            solrQuery.setParam("spellcheck.onlyMorePopular", true);
            //                solrQuery.setParam("spellcheck.count", "4");
        }
        solrQuery.setFacet(true);
        solrQuery.setFacetMinCount(1);
        //solrQuery.setFacetLimit(100); solr default is 100 so doesn't need to be set explicitly
        if (solrQuery.getRows() == null) {
            solrQuery.setRows(12);
        }
        solrQuery.addFacetField(ThemeFilter.getTheme().getRecordDefinition().getFacetFieldStrings());
        // todo now hard-coded but these values must be retrieved from the RecordDefinition later
        if (solrQuery.getFields() == null) {
            solrQuery.setFields(
                    "europeana_uri,dc_title,europeana_object,dc_creator,europeana_year,europeana_provider,"
                            + "europeana_dataProvider,europeana_language,europeana_type,dc_description,dc_type");
            //            solrQuery.setFields("*,score");
            //            solrQuery.setFields(metadataModel.getRecordDefinition().getFieldStrings());
        }
        if (solrQuery.getQueryType().equalsIgnoreCase(QueryType.SIMPLE_QUERY.toString())) {
            solrQuery.setQueryType(queryAnalyzer
                    .findSolrQueryType(solrQuery.getQuery(), ThemeFilter.getTheme().getRecordDefinition())
                    .toString());
        }
    }
    SolrQuery dCopy = addHiddenQueryFilters(solrQuery, params);
    return getSolrResponseFromServer(dCopy, false);
}

From source file:eu.europeana.core.querymodel.query.DocIdWindowPagerImpl.java

License:EUPL

@Override
@SuppressWarnings({ "AccessingNonPublicFieldOfAnotherObject" })
public void initialize(Map<String, String[]> httpParameters, BreadcrumbFactory breadcrumbFactory, Locale locale,
        SolrQuery originalBriefSolrQuery, QueryModelFactory queryModelFactory, RecordDefinition metadataModel)
        throws SolrServerException, EuropeanaQueryException {
    this.query = originalBriefSolrQuery.getQuery();
    int fullDocUriInt = getFullDocInt(httpParameters, originalBriefSolrQuery);
    this.fullDocUriInt = fullDocUriInt;
    int solrStartRow = getSolrStart(fullDocUriInt);
    QueryResponse queryResponse = queryModelFactory.getPagingQueryResponse(originalBriefSolrQuery,
            httpParameters, solrStartRow);
    if (queryResponse.getResults() == null) {
        throw new EuropeanaQueryException("no results for this query"); // if no results are found return null to signify that docIdPage can be created.
    } else if (queryResponse.getResults().size() == 0) {
        throw new EuropeanaQueryException("no results for this query"); // if no results are found return null to signify that docIdPage can be created.
    }/*  w  w  w  .java 2  s  . c  om*/
    List<? extends DocId> list = SolrBindingService.getDocIds(queryResponse);
    final SolrDocumentList response = queryResponse.getResults();
    this.breadcrumbs = breadcrumbFactory.createList(originalBriefSolrQuery, locale); // todo comment out
    int offset = (int) response.getStart();
    int numFound = (int) response.getNumFound();
    this.numFound = numFound;
    setNextAndPrevious(fullDocUriInt, list, offset, numFound);
    this.docIdWindow = new DocIdWindowImpl(list, offset, numFound);
    if (this.hasNext) {
        this.setNextFullDocUrl(httpParameters);
    }
    if (this.hasPrevious) {
        this.setPreviousFullDocUrl(httpParameters);
    }
}

From source file:eu.europeana.core.querymodel.query.DocIdWindowPagerImpl.java

License:EUPL

private void setQueryStringForPaging(SolrQuery solrQuery, String startPage) {
    StringBuilder out = new StringBuilder();
    out.append("query=").append(encode(solrQuery.getQuery()));
    final String[] facetQueries = SolrQueryUtil.getFilterQueriesWithoutPhrases(solrQuery);
    if (facetQueries != null) {
        for (String facetTerm : facetQueries) {
            out.append("&qf=").append(facetTerm);
        }/* w  w w .  j  ava2 s  .co  m*/
    }
    out.append("&startPage=").append(startPage);
    this.queryStringForPaging = out.toString();
}

From source file:eu.europeana.core.querymodel.query.SolrQueryUtil.java

License:EUPL

public static SolrQuery createFromQueryParams(Map<String, String[]> params, QueryAnalyzer queryAnalyzer,
        Locale locale, RecordDefinition recordDefinition) throws EuropeanaQueryException {
    SolrQuery solrQuery = new SolrQuery();
    if (params.containsKey("query") || params.containsKey("query1")) {
        if (!params.containsKey("query")) { // support advanced search
            solrQuery.setQuery(queryAnalyzer.createAdvancedQuery(params, locale));
        } else {/*  www. j a v  a2s .com*/
            if (params.containsKey("zoeken_in") && !params.get("zoeken_in")[0].equalsIgnoreCase("text")) {
                String zoekenIn = params.get("zoeken_in")[0];
                solrQuery.setQuery(zoekenIn + ":\""
                        + queryAnalyzer.sanitizeAndTranslate(params.get("query")[0], locale) + "\""); // only get the first one
            } else {
                solrQuery.setQuery(queryAnalyzer.sanitizeAndTranslate(params.get("query")[0], locale)); // only get the first one
            }
        }
    } else {
        throw new EuropeanaQueryException(QueryProblem.MALFORMED_QUERY.toString());
    }
    if (solrQuery.getQuery().trim().length() == 0) { // throw exception when no query is specified
        throw new EuropeanaQueryException(QueryProblem.MALFORMED_QUERY.toString());
    }
    if (params.containsKey("start")) {
        try {
            Integer start = Integer.valueOf(params.get("start")[0]);
            solrQuery.setStart(start);
        } catch (NumberFormatException e) {
            // if number exception is thrown take default setting 0 (hardening parameter handling)
        }
    }
    if (params.containsKey("rows")) {
        try {
            Integer rows = Integer.valueOf(params.get("rows")[0]);
            solrQuery.setRows(rows);
        } catch (NumberFormatException e) {
            // number exception is thrown take default setting 12 (hardening parameter handling)
        }
    }
    if (solrQuery.getQueryType() == null) {
        solrQuery.setQueryType(
                queryAnalyzer.findSolrQueryType(solrQuery.getQuery(), recordDefinition).toString());
    }

    // set sort field
    if (params.containsKey("sortBy") && !params.get("sortBy")[0].isEmpty()) {
        String sortField = params.get("sortBy")[0];
        if (sortField.equalsIgnoreCase("title")) {
            sortField = "sort_title";
        } else if (sortField.equalsIgnoreCase("creator")) {
            sortField = "sort_creator";
        } else if (sortField.equalsIgnoreCase("year")) {
            sortField = "sort_all_year";
        } else if (sortField.equalsIgnoreCase("random")) {
            sortField = SolrQueryUtil.createRandomSortKey();
        }

        if (params.containsKey("sortOrder") && !params.get("sortOrder")[0].isEmpty()) {
            String sortOrder = params.get("sortOrder")[0];
            if (sortOrder.equalsIgnoreCase("desc")) {
                solrQuery.setSortField(sortField, SolrQuery.ORDER.desc);
            }
        } else {
            solrQuery.setSortField(sortField, SolrQuery.ORDER.asc);
        }
    }

    //set constraints
    List<String> filterQueries = new ArrayList<String>();
    if (params.containsKey("qf")) {
        Collections.addAll(filterQueries, params.get("qf"));
    }
    if (params.containsKey("qf[]")) {
        Collections.addAll(filterQueries, params.get("qf[]"));
    }
    if (filterQueries != null) {
        for (String filterQuery : filterQueries) {
            solrQuery.addFilterQuery(filterQuery);
        }
    }
    // determine which fields will be returned
    if (params.containsKey("fl")) {
        String displayFields = params.get("fl")[0];
        if (!displayFields.isEmpty()) {
            solrQuery.setFields(displayFields);
        }
    }
    // find rq and add to filter queries
    if (params.containsKey("rq") && params.get("rq").length != 0) {
        String refineSearchFilterQuery = queryAnalyzer.createRefineSearchFilterQuery(params, locale);
        if (!refineSearchFilterQuery.isEmpty()) {
            solrQuery.addFilterQuery(refineSearchFilterQuery);
        }
    }
    solrQuery.setFilterQueries(SolrQueryUtil.getFilterQueriesAsPhrases(solrQuery));
    return solrQuery;
}

From source file:eu.prestoprime.search.Searcher.java

License:Open Source License

/**
 * Submits the SolrQuery object to SolrServer and handles sorting and
 * faceting. The portion of the results that is shown ranges from result
 * #from to #(from+resultCount)/*from  w  w  w . j  a  va 2s  .c  o m*/
 * 
 * @param query
 *            SolrQuery object
 * @param from
 *            specifies which portion of all results is shown
 * @param resultCount
 *            specifies how many results are displayed
 * @param sortField
 *            the field that is used for sorting
 * @param sortAsc
 *            sortorder, if true -> ascending, else -> descending
 * @param facetFilters
 *            Map object containing all fields to facet on as key and, if
 *            already selected, the filter value for this field
 * @return a SearchResults object containing all POJOs from the
 *         QueryResponse
 */
private SearchResults search(SolrQuery query, final int from, final int resultCount,
        final P4SortField sortField, final boolean sortAsc, Map<Schema.P4FacetField, String> facetFilters) {

    QueryResponse response = new QueryResponse();
    SearchResults results = new SearchResults();

    SolrQueryUtils.setResultRange(query, from, resultCount);

    // TODO deal with sorting on multivalued fields -> copyfield of one
    // value to a dedicated sortfield is done in P4IndexObject's respective
    // setters
    if (sortField == null) {
        LOGGER.debug("SortField is NULL! setting sortTitle and descending");
        SolrQueryUtils.setSortField(query, P4SortField.TITLE, sortAsc);
    } else {
        LOGGER.debug("SortField is " + sortField.getFieldName() + ". SortAsc? " + sortAsc);
        SolrQueryUtils.setSortField(query, sortField, sortAsc);
    }

    if (facetFilters == null) {
        SolrQueryUtils.enableFacets(query);
        facetFilters = SolrQueryUtils.getDefaultFacetMap();
    } else {
        SolrQueryUtils.setFacets(query, facetFilters);
    }

    try {
        LOGGER.debug("Query = " + query.getQuery());

        response = SolrServerConnection.getInstance().getSolrServer().query(query);

        results = ResultProcessor.extractResults(response, facetFilters);
        // ResultProcessor.setSelectedFacets(results, facetFilters);

        // set query params in results object
        results.getParams().setQuery(query.getQuery());
        results.getParams().setFrom(from);
        results.getParams().setResultCount(resultCount);
        results.getParams()
                .setSortField(sortField != null ? sortField.getFieldName() : P4SortField.TITLE.getFieldName());
        results.getParams().setSortAscending(sortAsc);

    } catch (SolrServerException e) {
        LOGGER.fatal(e.getMessage());
        LOGGER.fatal("Invalid Query = '" + query.getQuery() + "'.");
        results.setErrorMessage(e.getMessage());
    }

    return results;
}

From source file:eu.prestoprime.search.Searcher.java

License:Open Source License

/**
 * Queries Solr for auto-complete suggestions for an entered term. See
 * SearchHandler "suggest" in solrConfig.xml for tweaking.
 * //w ww . j  a  va2s. c o m
 * @param term
 * @return
 */
public P4Suggestions getSuggestion(String term) {
    P4Suggestions suggs = new P4Suggestions(term);
    QueryResponse response = new QueryResponse();
    SolrQuery query = new SolrQuery(term);
    query.setQueryType("/suggest");

    try {
        response = SolrServerConnection.getInstance().getSolrServer().query(query);
        if (response.getSpellCheckResponse() != null
                && !response.getSpellCheckResponse().getSuggestionMap().entrySet().isEmpty()) {
            Map<String, Suggestion> resultMap = response.getSpellCheckResponse().getSuggestionMap();
            for (Entry<String, Suggestion> entry : resultMap.entrySet()) {
                suggs.suggestions.add(new P4Suggestion(entry.getKey(), entry.getValue().getAlternatives()));
            }
        }
    } catch (SolrServerException e) {
        LOGGER.fatal(e);
        LOGGER.fatal("Could not query Solr for suggestions. Query = '" + query.getQuery() + "'.");
    }
    return suggs;
}

From source file:fi.vm.sade.organisaatio.service.search.OrganisaatioSearchService.java

License:EUPL

public List<OrganisaatioPerustieto> searchHierarchy(final SearchCriteria searchCriteria) {
    long time = System.currentTimeMillis();
    final List<String> kunta = searchCriteria.getKunta();
    final List<String> restrictionList = searchCriteria.getOidRestrictionList();
    final String organisaatioTyyppi = searchCriteria.getOrganisaatioTyyppi();
    final List<String> kieli = searchCriteria.getKieli();
    String searchStr = searchCriteria.getSearchStr();
    String oid = searchCriteria.getOid();

    SolrQuery q = createOrgQuery(searchCriteria, kunta, restrictionList, organisaatioTyyppi, kieli, searchStr,
            oid);/* w  w  w . j  a v  a 2  s .  co m*/

    q.set("fl", OID, PATH);
    // max rows to return
    q.setRows(10000);
    try {
        QueryResponse response = solr.query(q, METHOD.POST);

        LOG.debug("Sending query: " + q.getQuery() + ", filters: " + Joiner.on(" ").join(q.getFilterQueries()));
        LOG.debug("Search matched {} results, fetching docs...", response.getResults().getNumFound());
        if (response.getResults().getNumFound() == 0) {
            // short circuit no results here
            return Lists.newArrayList();
        }
        Set<String> oids = Sets.newHashSet();
        Set<String> paths = Sets.newHashSet();
        for (SolrDocument doc : response.getResults()) {
            if (!rootOrganisaatioOid.equals(doc.getFieldValue(OID))) {
                paths.add((String) doc.getFieldValue(OID));
            }

            if (!searchCriteria.getSkipParents()) {
                for (Object path : doc.getFieldValues(PATH)) {
                    if (!rootOrganisaatioOid.equals(path)) {
                        oids.add((String) path);
                    }
                }
            }
            oids.add((String) doc.getFirstValue(OID));
        }

        // get the actual docs
        q = new SolrQuery("*:*");
        q.setFields("*");
        addDateFilters(searchCriteria, q);

        // filter out oph (TODO do not index oph)
        q.addFilterQuery(String.format("-%s:%s", OID, rootOrganisaatioOid));

        // filter out types in upper hierarchy
        if (organisaatioTyyppi != null && organisaatioTyyppi.length() > 0) {
            final Set<String> limitToTypes = orgTypeLimit.get(organisaatioTyyppi);
            q.addFilterQuery(String.format("%s:(%s)", ORGANISAATIOTYYPPI, Joiner.on(" ").join(limitToTypes)));
        }

        // restrictions
        if (restrictionList.size() > 0) {
            // filter based on restriction list
            q.addFilterQuery(String.format("%s:(%s)", PATH, Joiner.on(" ").join(restrictionList)));
        }

        String query = String.format("%s:(%s)", OID, Joiner.on(" ").join(oids));
        if (paths.size() > 0) {
            query = query + String.format(" %s:(%s)", PATH, Joiner.on(" ").join(paths));
        }
        q.setQuery(query);
        q.setRows(10000);

        response = solr.query(q, METHOD.POST);

        LOG.debug("Search time :{} ms.", (System.currentTimeMillis() - time));

        final SolrDocumentToOrganisaatioPerustietoTypeFunction converter = new SolrDocumentToOrganisaatioPerustietoTypeFunction(
                oids);

        final List<OrganisaatioPerustieto> result = Lists
                .newArrayList(Lists.transform(response.getResults(), converter));

        LOG.debug("Total time :{} ms.", (System.currentTimeMillis() - time));
        return result;
    } catch (SolrServerException e) {
        LOG.error("Error executing search, q={}", q.getQuery());
        throw new RuntimeException(e);
    }
}

From source file:fr.gael.dhus.service.SearchService.java

License:Open Source License

/**
 * Search.//from  www . j  a  va2 s  .  co  m
 * <p>
 * Set `start` and `rows` values in the SolrQuery parameter to paginate the results.<br>
 * <strong>If no `rows` have been set, solr will only return 10 documents, no more.</strong>
 * <p>
 * To get the total number of document matching the given query, use {@code res.getNumFound()}.
 *
 * @param query a SolrQuery with at least a 'q' parameter set.
 * @return A list of solr document matching the given query.
 */
@PreAuthorize("hasRole('ROLE_SEARCH')")
public SolrDocumentList search(SolrQuery query) {
    Objects.requireNonNull(query);

    query.setQuery(solrDao.updateQuery(query.getQuery()));
    try {
        return solrDao.search(query).getResults();
    } catch (SolrServerException | IOException ex) {
        LOGGER.error(ex);
        throw new DHusSearchException("An exception occured while searching", ex);
    }
}

From source file:gwap.search.SolrSearchBean.java

License:Open Source License

public void submitQuery() {
    log.info("Updating Results");

    results = null;/*  w  w  w  .ja v  a  2  s .  co  m*/
    SolrQuery solrQuery = generateQuery();
    if (solrQuery == null)
        return;
    paginationControl.setResultsPerPage(RESULTS_PER_PAGE);
    solrQuery.setRows(paginationControl.getResultsPerPage());
    solrQuery.setStart(paginationControl.getFirstResult());
    try {
        QueryResponse response = solrServer.query(solrQuery, METHOD.POST);
        results = response.getResults();
        paginationControl.setNumResults(results.getNumFound());
        dirty = false;
        log.info("Got #0 results for query '#1'", results.getNumFound(), solrQuery.getQuery());
    } catch (SolrException e) {
        log.info("Could not complete query", e);
    } catch (SolrServerException e) {
        log.info("Could not complete query", e);
    }
}