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

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

  1. HOME
  2. Java
  3. org.apache.solr
  4. org.apache.solr.client.solrj.*
  5. SolrQuery
  6. setQuery

Introduction

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

Prototype

public SolrQuery setQuery(String query)

Source Link

Usage

From source file:org.gbif.common.search.builder.SolrQueryBuilder.java

License:Apache License

public SolrQuery build(final SearchRequest<P> searchRequest) {
    SolrQuery solrQuery = new SolrQuery();
    // q param//from   w w w. j a  v  a2  s .  c  om
    solrQuery.setQuery(queryBuilder.build(searchRequest));
    // paging
    setQueryPaging(searchRequest, solrQuery);
    // sets the default, alternative query
    solrQuery.set(ALT_QUERY_PARAM, DEFAULT_QUERY);
    // filters
    setQueryFilter(searchRequest, solrQuery);
    // highlight
    setHighLightParams(searchRequest, solrQuery);
    // sorting
    setPrimarySortOrder(solrQuery);
    // set shards/for distributed search
    setRequestHandler(solrQuery, requestHandler);

    LOG.debug("Solr query build: {}", solrQuery);
    return solrQuery;
}

From source file:org.gbif.occurrence.download.file.OccurrenceFileWriterJob.java

/**
 * Creates a SolrQuery that contains the query parameter as the filter query value.
 *//*from   w  w  w .  j a  v a 2 s .  c  om*/
private SolrQuery createSolrQuery(String query) {
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery(SolrConstants.DEFAULT_QUERY);
    if (!Strings.isNullOrEmpty(query)) {
        solrQuery.addFilterQuery(query);
    }
    return solrQuery;
}

From source file:org.geotools.data.solr.FieldLayerMapper.java

License:Open Source License

@Override
public List<String> createTypeNames(HttpSolrServer solrServer) throws Exception {
    List<String> names = new ArrayList<>();

    SolrQuery query = new SolrQuery();
    query.setQuery("*:*");
    query.addFacetField(field);/*from www  . java 2  s .com*/
    query.setFacet(true);
    query.setFacetMinCount(1);
    query.setFacetSort(FacetParams.FACET_SORT_INDEX);
    query.setRows(0);
    query.setParam("omitHeader", true);

    QueryResponse rsp = solrServer.query(query);
    if (LOGGER.isLoggable(Level.FINE)) {
        LOGGER.log(Level.FINE, "SOLR query done: " + query.toString());
    }
    List<Count> uniqueFacetFields = rsp.getFacetFields().get(0).getValues();
    for (Count field : uniqueFacetFields) {
        names.add(field.getName());
    }
    return names;
}

From source file:org.geotools.data.solr.SolrDataStore.java

License:Open Source License

/**
 * Retrieve SOLR attribute for specific type <br/>
 * Two SOLR LukeRequest are needed to discover SOLR fields and theirs schema for dynamic and
 * static kinds. <br/>//from   w  w  w .j  a v  a 2 s .  c  o m
 * For each discovered field a SOLR request is needed to verify if the field has no values in
 * the actual type, this information will be stored in {@link SolrAttribute#setEmpty}. <br/>
 * SolrJ not extracts information about uniqueKey so custom class
 * {@link ExtendedFieldSchemaInfo} is used. <br/>
 * MultiValued SOLR field is mapped as String type
 * 
 * @param layerName the type to use to query the SOLR field {@link SolrDataStore#field}
 * 
 * @see {@link SolrUtils#decodeSolrFieldType}
 * @see {@link ExtendedFieldSchemaInfo#ExtendedFieldSchemaInfo}
 * 
 */
public ArrayList<SolrAttribute> getSolrAttributes(String layerName) {
    if (solrAttributes.isEmpty()) {
        solrAttributes = new ArrayList<SolrAttribute>();
        try {
            LukeRequest lq = new LukeRequest();
            lq.setShowSchema(true);
            LukeResponse processSchema = lq.process(solrServer);

            lq = new LukeRequest();
            lq.setShowSchema(false);
            LukeResponse processField = lq.process(solrServer);
            Map<String, FieldInfo> fis = processField.getFieldInfo();
            SortedSet<String> keys = new TreeSet<String>(fis.keySet());
            for (String k : keys) {
                FieldInfo fieldInfo = fis.get(k);
                String name = fieldInfo.getName();
                String type = fieldInfo.getType();

                SolrQuery query = new SolrQuery();
                query.setQuery("*:*");
                query.setRows(0);
                query.addFilterQuery(this.field + ":*");
                if (layerName != null && layerName.isEmpty()) {
                    query.addFilterQuery(name + ":" + layerName);
                } else {
                    query.addFilterQuery(name + ":*");
                }
                QueryResponse rsp = solrServer.query(query);
                long founds = rsp.getResults().getNumFound();

                FieldTypeInfo fty = processSchema.getFieldTypeInfo(type);
                if (fty != null) {
                    Class<?> objType = SolrUtils.decodeSolrFieldType(fty.getClassName());
                    if (objType != null) {
                        ExtendedFieldSchemaInfo extendedFieldSchemaInfo = new SolrUtils.ExtendedFieldSchemaInfo(
                                processSchema, processField, name);
                        SolrAttribute at = new SolrAttribute(name, objType);
                        if (extendedFieldSchemaInfo.getUniqueKey()) {
                            at.setPk(true);
                            at.setUse(true);
                        }
                        if (extendedFieldSchemaInfo.getMultivalued()
                                && !Geometry.class.isAssignableFrom(at.getType())) {
                            at.setType(String.class);
                        }
                        at.setEmpty(founds == 0);
                        solrAttributes.add(at);
                    } else {
                        if (LOGGER.isLoggable(Level.FINE)) {
                            LOGGER.log(Level.FINE,
                                    "Skipping attribute " + fty.getName()
                                            + " as we don't know how to map its type to a java object "
                                            + fty.getClassName());
                        }
                    }
                }
            }
            // Reorder fields: empty after
            List<BeanComparator> sortFields = Arrays.asList(new BeanComparator("empty"),
                    new BeanComparator("name"));
            ComparatorChain multiSort = new ComparatorChain(sortFields);
            Collections.sort(solrAttributes, multiSort);
        } catch (Exception ex) {
            LOGGER.log(Level.SEVERE, ex.getMessage(), ex);
        }
    }
    return solrAttributes;
}

From source file:org.geotools.data.solr.SolrDataStore.java

License:Open Source License

@Override
protected List<Name> createTypeNames() throws IOException {
    try {//from   www. j  a v  a 2s.  c  o m
        if (typeNames == null || typeNames.isEmpty()) {
            typeNames = new ArrayList<Name>();
            SolrQuery query = new SolrQuery();
            query.setQuery("*:*");
            query.addFacetField(field);
            query.setFacet(true);
            query.setFacetMinCount(1);
            query.setFacetSort(FacetParams.FACET_SORT_INDEX);
            query.setRows(0);
            query.setParam("omitHeader", true);
            QueryResponse rsp = solrServer.query(query);
            if (LOGGER.isLoggable(Level.FINE)) {
                LOGGER.log(Level.FINE, "SOLR query done: " + query.toString());
            }
            List<Count> uniqueFacetFields = rsp.getFacetFields().get(0).getValues();
            for (Count field : uniqueFacetFields) {
                typeNames.add(new NameImpl(namespaceURI, field.getName()));
            }
        }
    } catch (Exception ex) {
        LOGGER.log(Level.SEVERE, ex.getMessage(), ex);
    }
    return typeNames;
}

From source file:org.geotools.data.solr.SolrDataStore.java

License:Open Source License

/**
 * Builds the SolrJ query with support of subset of fields, limit/offset, sorting, OGC filter
 * encoding and viewParams <br>/*ww w .j av a 2s . c o  m*/
 * The SOLR query always need the order by PK field to enable pagination and efficient data
 * retrieving <br>
 * Currently only additional "q" and "fq" SOLR parameters can be passed using vireParams, this
 * conditions are added in AND with others
 * 
 * @param featureType the feature type to query
 * @param q the OGC query to translate in SOLR request
 * 
 * @see {@link Hints#VIRTUAL_TABLE_PARAMETERS}
 * 
 */
protected SolrQuery select(SimpleFeatureType featureType, Query q) {
    SolrQuery query = new SolrQuery();
    query.setParam("omitHeader", true);
    try {
        // Column names
        if (q.getPropertyNames() != null) {
            for (String prop : q.getPropertyNames()) {
                query.addField(prop);
            }
        }
        query.setQuery("*:*");

        // Encode limit/offset, if necessary
        if (q.getStartIndex() != null && q.getStartIndex() >= 0) {
            query.setStart(q.getStartIndex());
        }
        if (q.getMaxFeatures() > 0) {
            query.setRows(q.getMaxFeatures());
        }

        // Sort
        ORDER naturalSortOrder = ORDER.asc;
        if (q.getSortBy() != null) {
            for (SortBy sort : q.getSortBy()) {
                if (sort.getPropertyName() != null) {
                    query.addSort(sort.getPropertyName().getPropertyName(),
                            sort.getSortOrder().equals(SortOrder.ASCENDING) ? ORDER.asc : ORDER.desc);
                } else {
                    naturalSortOrder = sort.getSortOrder().equals(SortOrder.ASCENDING) ? ORDER.asc : ORDER.desc;
                }
            }
        }

        // Always add natural sort by PK to support pagination
        query.addSort(getPrimaryKey(featureType.getTypeName()).getName(), naturalSortOrder);

        // Encode OGC filer
        FilterToSolr f2s = initializeFilterToSolr(featureType);
        String fq = this.field + ":" + featureType.getTypeName();
        Filter simplified = SimplifyingFilterVisitor.simplify(q.getFilter());
        String ffq = f2s.encodeToString(simplified);
        if (ffq != null && !ffq.isEmpty()) {
            fq = fq + " AND " + ffq;
        }
        query.setFilterQueries(fq);

        // Add viewpPrams
        addViewparams(q, query);

    } catch (Exception e) {
        LOGGER.log(Level.SEVERE, e.getMessage(), e);
    }
    return query;
}

From source file:org.geotools.data.solr.SolrDataStore.java

License:Open Source License

/**
 * Builds the SolrJ count query with support of limit/offset, OGC filter encoding and viewParams <br>
 * Currently only additional "q" and "fq" SOLR parameters can be passed using viewParams, this
 * conditions are added in AND with others
 * //from   w  w  w.  j a  v a2  s.co m
 * @param featureType the feature type to query
 * @param q the OGC query to translate in SOLR request
 * 
 * @see {@link Hints#VIRTUAL_TABLE_PARAMETERS}
 * 
 */
protected SolrQuery count(SimpleFeatureType featureType, Query q) {
    SolrQuery query = new SolrQuery();
    query.setParam("omitHeader", true);
    query.setQuery("*:*");
    query.setFields(this.getPrimaryKey(featureType.getName().getLocalPart()).getName());
    try {

        // Encode limit/offset, if necessary

        if (q.getStartIndex() != null && q.getStartIndex() >= 0) {
            query.setStart(q.getStartIndex());
        }
        query.setRows(0);

        // Encode OGC filer
        FilterToSolr f2s = initializeFilterToSolr(featureType);
        String fq = this.field + ":" + featureType.getTypeName();
        String ffq = f2s.encodeToString(q.getFilter());
        if (ffq != null && !ffq.isEmpty()) {
            fq = fq + " AND " + ffq;
        }
        query.setFilterQueries(fq);

        // Add viewparams parameters
        addViewparams(q, query);

    } catch (Exception e) {
        LOGGER.log(Level.SEVERE, e.getMessage(), e);
    }
    return query;
}

From source file:org.hara.sodra.index.SodraServer.java

License:Apache License

public SolrDocumentList search(String query) throws SolrServerException, IOException {
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery(query);
    QueryResponse response = client.query(indexName, solrQuery);
    return response.getResults();
}

From source file:org.hbird.business.archive.solr.SolrProducer.java

License:Apache License

private List<EntityInstance> doInitializationRequest(DataRequest body, String request) {

    SolrQuery query = new SolrQuery(request);

    query.setRows(1);/*from  ww  w  .jav  a 2  s .c o  m*/
    query.setSortField(endpoint.getSortField(), endpoint.getSortOrder());

    /** Configure facets. */
    query.setFacet(true);
    query.setQuery(request);
    query.setFacetSort(StandardArguments.COUNT);
    query.setFacetLimit(-1);
    query.setFacetMissing(false);
    query.setFacetMinCount(1);

    query.addFacetField(StandardArguments.NAME);

    query.setQueryType("basic");

    List<EntityInstance> results = new ArrayList<EntityInstance>();

    QueryResponse response;
    try {
        response = endpoint.getServer().query(query);
        if (response.getStatus() != 0) {
            LOG.error("Failed to execute retrieval request. Failed with status '{}'.", response.getStatus());
        }

        if (response.getFacetFields() != null) {

            /** For each facet, retrieve 'rows' samples. */
            for (FacetField facetfield : response.getFacetFields()) {

                if (facetfield.getValues() != null) {

                    LOG.info("Found " + facetfield.getValueCount() + " entries for facet value "
                            + facetfield.getName());

                    for (Count count : facetfield.getValues()) {

                        String applicableTo = "";
                        if (body.hasArgumentValue(StandardArguments.APPLICABLE_TO)) {
                            applicableTo = body.getArgumentValue(StandardArguments.APPLICABLE_TO, String.class);
                        }

                        SolrQuery sampleQuery = new SolrQuery("name:\"" + count.getName() + "\""
                                + createTimestampElement(body.getFrom(), body.getTo())
                                + createIsApplicableToElement(applicableTo));
                        LOG.info("Using sample query '" + sampleQuery + "' to get facet " + count.getName());
                        sampleQuery.setRows(body.getRows());
                        sampleQuery.setSortField(StandardArguments.TIMESTAMP, ORDER.desc);
                        sampleQuery.setQueryType("basic");

                        for (EntityInstance newObj : retrieve(sampleQuery)) {
                            results.add(newObj);
                            LOG.info("Added object '" + newObj.getID() + "'");
                        }
                    }
                }
            }
        }
    } catch (Exception e) {
        LOG.error("Failed to handle initialization request; query: '{}'.", request, e);
    }

    return results;
}

From source file:org.hoteia.qalingo.core.solr.service.CatalogCategorySolrService.java

License:Apache License

public CatalogCategoryResponseBean searchCatalogCategory(String searchBy, String searchText, String facetField)
        throws SolrServerException, IOException {
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setParam("rows", ROWS_DEFAULT_VALUE);

    if (StringUtils.isEmpty(searchBy)) {
        throw new IllegalArgumentException("SearchBy field can not be Empty or Blank!");
    }//  w  ww .  j a  v  a 2s  . c o  m

    if (StringUtils.isEmpty(searchText)) {
        solrQuery.setQuery(searchBy + ":*");
    } else {
        solrQuery.setQuery(searchBy + ":" + searchText + "*");
    }

    if (StringUtils.isNotEmpty(facetField)) {
        solrQuery.setFacet(true);
        solrQuery.setFacetMinCount(1);
        solrQuery.setFacetLimit(8);
        solrQuery.addFacetField(facetField);
    }

    logger.debug("QueryRequest solrQuery: " + solrQuery);

    SolrRequest request = new QueryRequest(solrQuery, METHOD.POST);

    QueryResponse response = new QueryResponse(catalogCategorySolrServer.request(request),
            catalogCategorySolrServer);

    logger.debug("QueryResponse Obj: " + response.toString());

    List<CatalogCategorySolr> solrList = response.getBeans(CatalogCategorySolr.class);
    CatalogCategoryResponseBean catalogCategoryResponseBean = new CatalogCategoryResponseBean();
    catalogCategoryResponseBean.setCatalogCategorySolrList(solrList);

    if (StringUtils.isNotEmpty(facetField)) {
        List<FacetField> solrFacetFieldList = response.getFacetFields();
        catalogCategoryResponseBean.setCatalogCategorySolrFacetFieldList(solrFacetFieldList);
    }

    return catalogCategoryResponseBean;
}