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

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

Introduction

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

Prototype

public SolrQuery setFacet(boolean b) 

Source Link

Document

enable/disable faceting.

Usage

From source file:uk.ac.ebi.phis.service.ImageService.java

License:Apache License

public String getImages(String term, String phenotype, String mutantGene, String anatomy, String expressedGene,
        String sex, String taxon, String imageType, String sampleType, String stage, String visualisationMethod,
        String samplePreparation, String imagingMethod, Integer rows, Integer start, String genericGene,
        String chromosome, String strand, Long position, Long startPosition, Long endPosition, String hostName)
        throws SolrServerException, PhisQueryException {

    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery("*:*");
    // boosted queries
    String bq = "";
    String qf = "";
    if (term != null) {
        solrQuery.setQuery("(" + ImageDTO.GENERIC_SEARCH + ":" + handleSpecialCharacters(term) + " OR "
                + ImageDTO.GENERIC_SEARCH_ANCESTORS + ":" + handleSpecialCharacters(term) + ")");
        if (term.contains(" ")) {
            String[] splittedQuery = term.split(" ");
            String query = ImageDTO.GENERIC_SEARCH + ":" + org.apache.commons.lang3.StringUtils
                    .join(splittedQuery, "^10 " + ImageDTO.GENERIC_SEARCH + ":");
            bq += ImageDTO.GENERIC_SEARCH + ":\"" + term + "\"^100 " + handleSpecialCharacters(query) + " "
                    + ImageDTO.GENERIC_SEARCH_ANCESTORS + ":\"" + term + "\"^1 "
                    + ImageDTO.GENERIC_SEARCH_ANCESTORS + ":" + org.apache.commons.lang3.StringUtils
                            .join(splittedQuery, "^0.1 " + ImageDTO.GENERIC_SEARCH_ANCESTORS + ":");
            qf += ImageDTO.GENERIC_SEARCH;
        } else {/*  www.  j a  v  a 2  s.  c om*/
            solrQuery.addFilterQuery("(" + ImageDTO.GENERIC_SEARCH + ":" + handleSpecialCharacters(term)
                    + " OR " + ImageDTO.GENERIC_SEARCH_ANCESTORS + ":" + handleSpecialCharacters(term) + ")");
        }
    }
    if (phenotype != null) {
        phenotype = handleSpecialCharacters(phenotype);
        bq += ImageDTO.PHENOTYPE_ID_BAG + ":\"" + phenotype + "\"^100 " + ImageDTO.PHENOTYPE_FREETEXT_BAG
                + ":\"" + phenotype + "\"^70 " + ImageDTO.PHENOTYPE_LABEL_BAG + ":\"" + phenotype + "\"^100 "
                + ImageDTO.PHENOTYPE_ANCESTORS + ":\"" + phenotype + "\"^0.001 "
                + ImageDTO.PHENOTYPE_SYNONYMS_BAG + ":\"" + phenotype + "\"^0.1 ";
        solrQuery.addFilterQuery(ImageDTO.PHENOTYPE_ID_BAG + ":\"" + phenotype + "\" OR "
                + ImageDTO.PHENOTYPE_FREETEXT_BAG + ":\"" + phenotype + "\" OR " + ImageDTO.PHENOTYPE_LABEL_BAG
                + ":\"" + phenotype + "\" OR " + ImageDTO.PHENOTYPE_ANCESTORS + ":\"" + phenotype + "\"");
    }
    if (visualisationMethod != null) {
        visualisationMethod = handleSpecialCharacters(visualisationMethod);
        bq += ImageDTO.VISUALISATION_METHOD_ID + ":\"" + visualisationMethod + "\"^100 "
                + ImageDTO.VISUALISATION_METHOD_LABEL + ":\"" + visualisationMethod + "\"^100 "
                + ImageDTO.VISUALISATION_METHOD_ANCESTORS + ":\"" + visualisationMethod + "\"^0.001 ";
        solrQuery.addFilterQuery(ImageDTO.VISUALISATION_METHOD_ID + ":\"" + visualisationMethod + "\" OR "
                + ImageDTO.VISUALISATION_METHOD_LABEL + ":\"" + visualisationMethod + "\" OR "
                + ImageDTO.VISUALISATION_METHOD_ANCESTORS + ":\"" + visualisationMethod + "\"");
    }
    if (samplePreparation != null) {
        samplePreparation = handleSpecialCharacters(samplePreparation);
        bq += ImageDTO.SAMPLE_PREPARATION_ID + ":\"" + samplePreparation + "\"^100 "
                + ImageDTO.SAMPLE_PREPARATION_LABEL + ":\"" + samplePreparation + "\"^100 "
                + ImageDTO.SAMPLE_PREPARATION_ANCESTORS + ":\"" + samplePreparation + "\"^0.001 ";
        solrQuery.addFilterQuery(ImageDTO.SAMPLE_PREPARATION_ID + ":\"" + samplePreparation + "\" OR "
                + ImageDTO.SAMPLE_PREPARATION_LABEL + ":\"" + samplePreparation + "\" OR "
                + ImageDTO.SAMPLE_PREPARATION_ANCESTORS + ":\"" + samplePreparation + "\"");
    }
    if (imagingMethod != null) {
        imagingMethod = handleSpecialCharacters(imagingMethod);
        bq = ImageDTO.IMAGING_METHOD_LABEL_ANALYSED + ":\"" + imagingMethod + "\"^100 "
                + ImageDTO.IMAGING_METHOD_ID + ":\"" + imagingMethod + "\"^100 "
                + ImageDTO.IMAGING_METHOD_ANCESTORS + ":\"" + imagingMethod + "\"^0.001 ";
        solrQuery.addFilterQuery(ImageDTO.IMAGING_METHOD_LABEL_ANALYSED + ":\"" + imagingMethod + "\" OR "
                + ImageDTO.IMAGING_METHOD_ID + ":\"" + imagingMethod + "\" OR "
                + ImageDTO.IMAGING_METHOD_ANCESTORS + ":\"" + imagingMethod + "\"");
    }
    if (anatomy != null) {
        anatomy = handleSpecialCharacters(anatomy);
        bq += ImageDTO.GENERIC_ANATOMY + ":\"" + anatomy + "\"^100 " + ImageDTO.GENERIC_ANATOMY_ANCESTORS
                + ":\"" + anatomy + "\"^0.001 ";
        solrQuery.addFilterQuery(ImageDTO.GENERIC_ANATOMY + ":\"" + anatomy + "\" OR "
                + ImageDTO.GENERIC_ANATOMY_ANCESTORS + ":\"" + anatomy + "\"");
    }
    if (!bq.equals("")) {
        solrQuery.set("defType", "edismax");
        solrQuery.set("bq", bq);
    }
    if (!qf.equals("")) {
        solrQuery.set("qf", qf);
    }
    // Non-boosted queries
    if (mutantGene != null) {
        mutantGene = handleSpecialCharacters(mutantGene);
        solrQuery.addFilterQuery(ImageDTO.GENE_ID + ":\"" + mutantGene + "\" OR " + ImageDTO.GENE_SYMBOL + ":\""
                + mutantGene + "\"");
    }
    if (hostName != null) {
        solrQuery.addFilterQuery(ImageDTO.HOST_NAME + ":\"" + hostName + "\"");
    }
    if (genericGene != null) {
        genericGene = handleSpecialCharacters(genericGene);
        solrQuery.addFilterQuery(ImageDTO.GENE_ID + ":\"" + genericGene + "\" OR " + ImageDTO.GENE_SYMBOL
                + ":\"" + genericGene + "\" OR " + ImageDTO.EXPRESSED_GF_ID_BAG + ":\"" + genericGene + "\" OR "
                + ImageDTO.EXPRESSED_GF_SYMBOL_BAG + ":\"" + genericGene + "\" OR "
                + ImageDTO.MUTANT_GENE_ID_BAG + ":\"" + genericGene + "\" OR " + ImageDTO.MUTANT_GENE_SYMBOL_BAG
                + ":\"" + genericGene + "\" OR " + ImageDTO.MUTANT_GENE_SYNONYMS_BAG + ":\"" + genericGene
                + "\"");
    }
    if (expressedGene != null) {
        expressedGene = handleSpecialCharacters(expressedGene);
        solrQuery.addFilterQuery(ImageDTO.EXPRESSED_GF_ID_BAG + ":\"" + expressedGene + "\" OR "
                + ImageDTO.EXPRESSED_GF_SYMBOL_BAG + ":\"" + expressedGene + "\"");
    }
    if (taxon != null) {
        taxon = handleSpecialCharacters(taxon);
        solrQuery.addFilterQuery(
                ImageDTO.TAXON + ":\"" + taxon + "\" OR " + ImageDTO.NCBI_TAXON_ID + ":\"" + taxon + "\"");
    }
    if (imageType != null) {
        imageType = handleSpecialCharacters(imageType);
        solrQuery.addFilterQuery(ImageDTO.IMAGE_TYPE + ":\"" + imageType + "\"");
    }
    if (sampleType != null) {
        sampleType = handleSpecialCharacters(sampleType);
        solrQuery.addFilterQuery(ImageDTO.SAMPLE_TYPE + ":\"" + sampleType + "\"");
    }
    if (stage != null) {
        stage = handleSpecialCharacters(stage);
        solrQuery.addFilterQuery(ImageDTO.STAGE + ":\"" + stage + "\" OR " + ImageDTO.STAGE_ID + ":\"" + stage
                + "\" OR " + ImageDTO.STAGE_ANCESTORS + ":\"" + stage + "\" OR " + ImageDTO.STAGE_FACET + ":\""
                + stage + "\"");
    }
    if (sex != null) {
        sex = handleSpecialCharacters(sex);
        solrQuery.addFilterQuery(ImageDTO.SEX + ":\"" + sex + "\"");
    }
    if (chromosome != null) {
        solrQuery.addFilterQuery(ImageDTO.CHROMOSOME + ":" + chromosome);
    }
    if (position != null) {
        solrQuery.addFilterQuery("(" + ImageDTO.END_POS + ":[* TO " + position + "] AND " + ImageDTO.START_POS
                + ":[" + position + " TO *])");
    }
    if (strand != null) {
        solrQuery.addFilterQuery(ImageDTO.STRAND + ":\"" + strand + "\"");
    }
    if (startPosition != null && endPosition != null) {
        solrQuery.addFilterQuery(ImageDTO.START_POS + ":[" + startPosition + " TO " + endPosition + "] OR "
                + ImageDTO.END_POS + ":[" + startPosition + " TO " + endPosition + "]");
        ;
    } else if (startPosition != null && endPosition == null || startPosition == null && endPosition != null) {
        throw new PhisQueryException(PhisQueryException.START_END_POS);
    }
    if (rows != null) {
        solrQuery.setRows(rows);
    } else
        solrQuery.setRows(100);

    if (start != null) {
        solrQuery.set("start", start);
    }
    solrQuery.set("wt", "json");
    solrQuery.setFacet(true);
    solrQuery.addFacetField(ImageDTO.STAGE_FACET);
    solrQuery.addFacetField(ImageDTO.IMAGING_METHOD_LABEL);
    solrQuery.addFacetField(ImageDTO.TAXON);
    solrQuery.addFacetField(ImageDTO.SAMPLE_TYPE);
    solrQuery.addFacetField(ImageDTO.IMAGE_GENERATED_BY);
    solrQuery.addFacetField(ImageDTO.HOST_NAME);
    solrQuery.addFacetField(ImageDTO.IMAGE_TYPE);
    solrQuery.setFacetMinCount(0);

    solrQuery.set("facet.pivot.mincount", 0);

    // add pivot facets to get the number of image types per 
    solrQuery.set("facet.pivot", ImageDTO.SAMPLE_TYPE + "," + ImageDTO.IMAGE_TYPE);

    System.out.println("\nSolr URL : " + solr.getBaseURL() + "/select?" + solrQuery);
    log.info("Solr URL in getImages : " + solr.getBaseURL() + "/select?" + solrQuery);

    try {
        return JSONRestUtil.getResults(getQueryUrl(solrQuery)).toString();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (URISyntaxException e) {
        e.printStackTrace();
    }

    return "Couldn't get anything back from solr.";
}

From source file:xc.mst.action.browse.BrowseRecords.java

License:Open Source License

/**
 * Search for records//  w  w w.ja  v a  2s .  com
 */
public String browse() {
    RecordService recordService = (RecordService) MSTConfiguration.getInstance().getBean("RecordService");
    if (log.isDebugEnabled()) {
        log.debug("User entered query::" + query);
    }
    try {
        SolrQuery solrQuery = new SolrQuery();

        // If Query is empty retrieve all records
        if ((query == null) || (query.equals(""))) {
            solrQuery.setQuery("*:*");
        } else {
            if (!StringUtils.isEmpty(identifier)) {
                String qFld = getIdentifiers().get(identifier);
                if (query.indexOf(" ") != -1) {
                    query = "(" + query + ")";
                }
                if (qFld != null) {
                    query = query.replaceAll(":", "\\\\:"); // replacing with \\: and solr ends up thinking the token before : is a field
                                                            //  warning:  replacing the 1st : (the delim between field and text) breaks
                                                            //             the search, no results returned.
                    String q = new String(qFld + ":" + query);
                    solrQuery.setQuery(q);
                    if (log.isDebugEnabled()) {
                        LOG.debug("*** browse() ident=" + qFld + " query=" + q);
                    }
                } else {
                    if (log.isDebugEnabled()) {
                        LOG.debug("*** NO field associated with IDENTIFIER! " + " query=" + query
                                + " identifier=" + identifier);
                    }
                    // solr schema: <copyField source="*_key"  dest="text" />
                    if (query.indexOf(" ") != -1) {
                        query = "(" + query + ")";
                    }
                    // TODO having trouble getting this working, leave as a TODO for now, and drop back to default search on record_id.
                    // (should never get here anyways, an identifier will always be picked.
                    //solrQuery.setQuery("text:"+ query);
                    solrQuery.setQuery(query.replaceAll(":", "\\\\:"));
                }
            } else {
                if (log.isDebugEnabled()) {
                    LOG.debug("*** NO IDENTIFIER FOUND! " + " query=" + query);
                }
                solrQuery.setQuery("*:*");
            }
        }

        StringTokenizer nameTokenizer = new StringTokenizer(selectedFacetNames, "|");
        StringTokenizer valueTokenizer = new StringTokenizer(selectedFacetValues, "|");

        while (nameTokenizer.hasMoreTokens()) {
            String name = nameTokenizer.nextToken();
            String value = valueTokenizer.nextToken();
            addFilterQuery(solrQuery, name, value);
        }

        // Add selected facet to query
        if (addFacetName != null && addFacetName.length() > 0) {
            addFilterQuery(solrQuery, addFacetName, addFacetValue);
            // Add facet names and values to | separated list
            selectedFacetNames = selectedFacetNames + "|" + addFacetName;
            selectedFacetValues = selectedFacetValues + "|" + addFacetValue;
        }

        // Remove selected facet from query
        if (removeFacetName != null && removeFacetName.length() > 0) {
            solrQuery.removeFilterQuery(
                    removeFacetName + ":\"" + removeFacetValue.replaceAll(":", "\\\\:") + "\"");
        }

        if (log.isDebugEnabled()) {
            log.debug("Query after adding/removing facet ::" + query);
            log.debug("After Adding facet names ::" + selectedFacetNames);
            log.debug("After Adding facet values ::" + selectedFacetValues);
        }
        // Create facet names and values List
        StringTokenizer facetNameTokenizer = new StringTokenizer(selectedFacetNames, "|");
        List<String> facetNamesList = new ArrayList<String>();

        StringTokenizer facetValueTokenizer = new StringTokenizer(selectedFacetValues, "|");
        List<String> facetValuesList = new ArrayList<String>();

        StringBuffer newSelectedFacetNames = new StringBuffer();
        StringBuffer newSelectedFacetValues = new StringBuffer();
        String myNameToken = "";
        String myValueToken = "";
        while (facetNameTokenizer.hasMoreTokens()) {
            myNameToken = facetNameTokenizer.nextToken();
            myValueToken = facetValueTokenizer.nextToken();
            if (removeFacetName != null && removeFacetName.length() > 0) {
                // Create facet names String separated by |
                if (!(removeFacetName.equalsIgnoreCase(myNameToken)
                        && removeFacetValue.equalsIgnoreCase(myValueToken))) {
                    newSelectedFacetNames.append("|");
                    newSelectedFacetNames.append(myNameToken);
                    facetNamesList.add(myNameToken);

                    newSelectedFacetValues.append("|");
                    newSelectedFacetValues.append(myValueToken);
                    facetValuesList.add(myValueToken);
                }
            } else {
                facetNamesList.add(myNameToken);
                facetValuesList.add(myValueToken);
            }
        }

        if (removeFacetValue != null && removeFacetValue.length() > 0) {
            selectedFacetNames = newSelectedFacetNames.toString();
            selectedFacetValues = newSelectedFacetValues.toString();
        }

        if (log.isDebugEnabled()) {
            log.debug("After removing facet names(final):" + selectedFacetNames);
            log.debug("After removing facet values(final):" + selectedFacetValues);
        }

        // Query formation
        solrQuery.setFacet(true).setFacetMinCount(1);
        solrQuery.addFacetField("status");
        solrQuery.addFacetField("provider_name");
        solrQuery.addFacetField("service_name");
        solrQuery.addFacetField("format_name");
        solrQuery.addFacetField("set_name");
        solrQuery.addFacetField("error");

        // Fields to load
        solrQuery.addField(RecordService.FIELD_RECORD_ID);
        solrQuery.addField(RecordService.FIELD_FORMAT_ID);
        solrQuery.addField(RecordService.FIELD_PROVIDER_ID);
        solrQuery.addField(RecordService.FIELD_SERVICE_ID);
        solrQuery.addField(RecordService.FIELD_HARVEST_SCHEDULE_NAME);
        solrQuery.addField(RecordService.FIELD_ERROR);
        solrQuery.addField(RecordService.FIELD_PROCESSED_FROM);
        solrQuery.addField(RecordService.FIELD_SUCCESSOR);
        solrQuery.addField(RecordService.FIELD_OAI_IDENTIFIER);

        getIdentifiers();

        rowEnd = rowStart + numberOfResultsToShow;

        // In initial page load, we are not going to show any records. Only facets will be shown
        if (isInitialLoad) {
            solrQuery.setStart(0);
            solrQuery.setRows(0);
        } else {
            solrQuery.setStart(rowStart);
            solrQuery.setRows(numberOfResultsToShow);
        }
        BrowseRecordService browseRecordService = (BrowseRecordService) MSTConfiguration.getInstance()
                .getBean("BrowseRecordService");
        result = browseRecordService.search(solrQuery);

        if (log.isDebugEnabled()) {
            log.debug("Search result::" + result);
        }

        if ((result != null) && (rowEnd > result.getTotalNumberOfResults())) {
            rowEnd = result.getTotalNumberOfResults();
        }

        // Add facet name and value list to SolrBrowseResult(result) object for display in UI
        if (result != null) {
            for (int i = 0; i < facetNamesList.size(); i++) {
                // Get successor/predecessor of the record to display its information
                if (facetNamesList.get(i).equalsIgnoreCase("successor")) {
                    successorRecord = recordService.getById(Long.parseLong(facetValuesList.get(i)));
                }
                if (facetNamesList.get(i).equalsIgnoreCase("processed_from")) {

                    predecessorRecord = recordService.getById(Long.parseLong(facetValuesList.get(i)));
                }

                result.addFacetFilter(new FacetFilter(facetNamesList.get(i), facetValuesList.get(i)));
            }
        }
    } catch (DatabaseConfigException dce) {
        log.error(
                "Search failed. Problem with connecting to database using the parameters in configuration file.",
                dce);
        errorType = "error";
        addFieldError("dbError",
                "Search failed.Problem with connecting to database using the parameters in configuration file.");
        return INPUT;
    } catch (IndexException ie) {
        log.error("Search failed. Problem with connecting to Solr server. Check the path to solr folder.", ie);
        errorType = "error";
        addFieldError("dbError",
                "Search failed. Problem with connecting to Solr server. Check the path to solr folder.");
        return INPUT;
    }

    return SUCCESS;
}