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.apache.camel.component.solr.SolrComponentTestSupport.java

License:Apache License

protected QueryResponse executeSolrQuery(String query) throws SolrServerException {
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery(query);
    return solrServer.query(solrQuery);
}

From source file:org.apache.camel.component.solr.SolrSpringTest.java

License:Apache License

private QueryResponse executeSolrQuery(String query) throws SolrServerException {
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery(query);
    return solrServer.query(solrQuery);
}

From source file:org.apache.droids.solr.AdvancedSolrHandleTest.java

License:Apache License

public void performSelection(String html, String field, String selector, String expectedValue)
        throws IOException, DroidsException, URISyntaxException, SolrServerException {
    AdvancedSolrHandler handler = new AdvancedSolrHandler();
    handler.setServer(solr);/*from www . j  a  v a2s .  c om*/

    HashMap<String, String> selectors = new HashMap<String, String>();
    selectors.put(field, selector);
    handler.setSelectors(selectors);

    MockContentEntity contentEntity = new MockContentEntity();
    contentEntity.setCharset("UTF-8");
    contentEntity.setMimeType("text/html");
    contentEntity.setText(html);

    handler.handle(new URI("http://localhost/"), contentEntity);
    solr.commit();

    SolrQuery query = new SolrQuery();
    query.setQuery("*:*");
    query.setFields(field);
    QueryResponse response = solr.query(query);

    SolrDocument doc = response.getResults().iterator().next();
    String value = (String) doc.getFieldValue(field);

    assertEquals(expectedValue, value);
}

From source file:org.apache.hadoop.hive.solr.SolrQueryGenerator.java

License:Apache License

public static SolrQuery generateQuery(JobConf job) {
    SolrQuery solrQuery = new SolrQuery();
    String query = job.get(ExternalTableProperties.SOLR_QUERY);
    solrQuery.setQuery(query);
    String fields = StringUtils.join(new ExternalTableProperties().COLUMN_NAMES, ", ");
    solrQuery.set("fl", fields);

    // Since each mapper is going to query each shard separately
    // we set "distrib" --> false.
    solrQuery.set("distrib", "false");

    // pass the filter query by doing predicate pushdown.
    String filterExprSerialized = job.get(TableScanDesc.FILTER_EXPR_CONF_STR);
    if (filterExprSerialized == null) {
        // If no predicate pushdown is possible
        return solrQuery;
    }/*from  w  w  w  .j av  a2 s  .c  om*/

    ExprNodeDesc filterExpr = Utilities.deserializeExpression(filterExprSerialized);
    IndexPredicateAnalyzer analyzer = PredicateAnalyzer.getPredicateAnalyzer();
    List<IndexSearchCondition> searchConditions = new ArrayList<IndexSearchCondition>();
    analyzer.analyzePredicate(filterExpr, searchConditions);
    for (IndexSearchCondition condition : searchConditions) {

        String fieldName = condition.getColumnDesc().getColumn();
        String value = condition.getConstantDesc().getValue().toString();
        StringBuffer fqExp = new StringBuffer();
        if (condition.getComparisonOp().equals("org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPEqual")) {
            // Formulating Filter Query Expression.
            fqExp.append(fieldName).append(":").append(value);
            solrQuery.addFilterQuery(fqExp.toString());
            LOG.debug("Equals comparison found, adding it to SOLR filter query");
        }
        if (condition.getComparisonOp()
                .equals("org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPGreaterThan")) {
            fqExp.append(fieldName).append(":").append("{").append(value).append(" TO *}");
            solrQuery.addFilterQuery(fqExp.toString());
            LOG.debug("Greater than comparison found, adding it to SOLR filter query");
        }

        if (condition.getComparisonOp()
                .equals("org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPEqualOrGreaterThan")) {
            fqExp.append(fieldName).append(":").append("[").append(value).append(" TO *]");
            solrQuery.addFilterQuery(fqExp.toString());
            LOG.debug("Greater than or equals comparison found, adding it to SOLR filter query");
        }

        if (condition.getComparisonOp().equals("org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPLessThan")) {
            fqExp.append(fieldName).append(":").append("{* TO ").append(value).append(" }");
            solrQuery.addFilterQuery(fqExp.toString());
            LOG.debug("Less than comparison found, adding it to SOLR filter query");
        }

        if (condition.getComparisonOp()
                .equals("org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPEqualOrLessThan")) {
            fqExp.append(fieldName).append(":").append("[* TO ").append(value).append(" ]");
            solrQuery.addFilterQuery(fqExp.toString());
            LOG.debug("Less than or equals comparison found, adding it to SOLR filter query");
        }
    }
    return solrQuery;
}

From source file:org.apache.jackrabbit.oak.plugins.index.solr.index.SolrIndexEditorIT.java

License:Apache License

@Test
public void testAddSomeNodes() throws Exception {
    Root r = createRoot();//from  w ww.  j  av a2  s  .  c  o m
    r.getTree("/").addChild("a").addChild("b").addChild("doc1").setProperty("text", "hit that hot hat tattoo");
    r.getTree("/").getChild("a").addChild("c").addChild("doc2").setProperty("text", "it hits hot hats");
    r.getTree("/").getChild("a").getChild("b").addChild("doc3").setProperty("text", "tattoos hate hot hits");
    r.getTree("/").getChild("a").getChild("b").addChild("doc4").setProperty("text", "hats tattoos hit hot");
    r.commit();

    SolrQuery query = new SolrQuery();
    query.setQuery("*:*");
    QueryResponse queryResponse = server.query(query);
    assertTrue("no documents were indexed", queryResponse.getResults().size() > 0);
}

From source file:org.apache.jackrabbit.oak.plugins.index.solr.index.SolrIndexEditorIT.java

License:Apache License

@Test
public void testRemoveNode() throws Exception {
    Root r = createRoot();//from  ww  w .j  ava 2  s.com

    // Add a node
    r.getTree("/").addChild("testRemoveNode").setProperty("foo", "bar");
    r.commit();

    // check the node is not in Solr anymore
    SolrQuery query = new SolrQuery();
    query.setQuery("path_exact:\\/testRemoveNode");
    assertTrue("item with id:testRemoveNode was not found in the index",
            server.query(query).getResults().size() > 0);

    // remove the node in oak
    r.getTree("/").getChild("testRemoveNode").remove();
    r.commit();

    // check the node is not in Solr anymore
    assertTrue("item with id:testRemoveNode was found in the index",
            server.query(query).getResults().size() == 0);
}

From source file:org.apache.jackrabbit.oak.plugins.index.solr.query.FilterQueryParser.java

License:Apache License

static SolrQuery getQuery(Filter filter, QueryIndex.IndexPlan plan, OakSolrConfiguration configuration) {

    SolrQuery solrQuery = new SolrQuery();
    setDefaults(solrQuery, configuration);

    StringBuilder queryBuilder = new StringBuilder();

    FullTextExpression ft = filter.getFullTextConstraint();
    if (ft != null) {
        queryBuilder.append(parseFullTextExpression(ft, configuration));
        queryBuilder.append(' ');
    } else if (filter.getFulltextConditions() != null) {
        Collection<String> fulltextConditions = filter.getFulltextConditions();
        for (String fulltextCondition : fulltextConditions) {
            queryBuilder.append(fulltextCondition).append(" ");
        }//from w w w  .  j  a  va 2s .c om
    }

    List<QueryIndex.OrderEntry> sortOrder = plan.getSortOrder();
    if (sortOrder != null) {
        for (QueryIndex.OrderEntry orderEntry : sortOrder) {
            SolrQuery.ORDER order;
            if (QueryIndex.OrderEntry.Order.ASCENDING.equals(orderEntry.getOrder())) {
                order = SolrQuery.ORDER.asc;
            } else {
                order = SolrQuery.ORDER.desc;
            }
            String sortingField;
            if (JcrConstants.JCR_PATH.equals(orderEntry.getPropertyName())) {
                sortingField = partialEscape(configuration.getPathField()).toString();
            } else if (JcrConstants.JCR_SCORE.equals(orderEntry.getPropertyName())) {
                sortingField = "score";
            } else {
                if (orderEntry.getPropertyName().indexOf('/') >= 0) {
                    log.warn("cannot sort on relative properties, ignoring {} clause", orderEntry);
                    continue; // sorting by relative properties not supported until index time aggregation is supported
                }
                sortingField = partialEscape(
                        getSortingField(orderEntry.getPropertyType().tag(), orderEntry.getPropertyName()))
                                .toString();
            }
            solrQuery.addOrUpdateSort(sortingField, order);
        }
    }

    Collection<Filter.PropertyRestriction> propertyRestrictions = filter.getPropertyRestrictions();
    if (propertyRestrictions != null && !propertyRestrictions.isEmpty()) {
        for (Filter.PropertyRestriction pr : propertyRestrictions) {
            if (pr.isNullRestriction()) {
                // can not use full "x is null"
                continue;
            }
            // facets
            if (QueryImpl.REP_FACET.equals(pr.propertyName)) {
                solrQuery.setFacetMinCount(1);
                solrQuery.setFacet(true);
                String value = pr.first.getValue(Type.STRING);
                solrQuery.addFacetField(
                        value.substring(QueryImpl.REP_FACET.length() + 1, value.length() - 1) + "_facet");
            }

            // native query support
            if (SolrQueryIndex.NATIVE_SOLR_QUERY.equals(pr.propertyName)
                    || SolrQueryIndex.NATIVE_LUCENE_QUERY.equals(pr.propertyName)) {
                String nativeQueryString = String.valueOf(pr.first.getValue(pr.first.getType()));
                if (isSupportedHttpRequest(nativeQueryString)) {
                    // pass through the native HTTP Solr request
                    String requestHandlerString = nativeQueryString.substring(0,
                            nativeQueryString.indexOf('?'));
                    if (!"select".equals(requestHandlerString)) {
                        if (requestHandlerString.charAt(0) != '/') {
                            requestHandlerString = "/" + requestHandlerString;
                        }
                        solrQuery.setRequestHandler(requestHandlerString);
                    }
                    String parameterString = nativeQueryString.substring(nativeQueryString.indexOf('?') + 1);
                    for (String param : parameterString.split("&")) {
                        String[] kv = param.split("=");
                        if (kv.length != 2) {
                            throw new RuntimeException("Unparsable native HTTP Solr query");
                        } else {
                            // more like this
                            if ("/mlt".equals(requestHandlerString)) {
                                if ("stream.body".equals(kv[0])) {
                                    kv[0] = "q";
                                    String mltFlString = "mlt.fl=";
                                    int mltFlIndex = parameterString.indexOf(mltFlString);
                                    if (mltFlIndex > -1) {
                                        int beginIndex = mltFlIndex + mltFlString.length();
                                        int endIndex = parameterString.indexOf('&', beginIndex);
                                        String fields;
                                        if (endIndex > beginIndex) {
                                            fields = parameterString.substring(beginIndex, endIndex);
                                        } else {
                                            fields = parameterString.substring(beginIndex);
                                        }
                                        kv[1] = "_query_:\"{!dismax qf=" + fields + " q.op=OR}" + kv[1] + "\"";
                                    }
                                }
                                if ("mlt.fl".equals(kv[0]) && ":path".equals(kv[1])) {
                                    // rep:similar passes the path of the node to find similar documents for in the :path
                                    // but needs its indexed content to find similar documents
                                    kv[1] = configuration.getCatchAllField();
                                }
                            }
                            if ("/spellcheck".equals(requestHandlerString)) {
                                if ("term".equals(kv[0])) {
                                    kv[0] = "spellcheck.q";
                                }
                                solrQuery.setParam("spellcheck", true);
                            }
                            if ("/suggest".equals(requestHandlerString)) {
                                if ("term".equals(kv[0])) {
                                    kv[0] = "suggest.q";
                                }
                                solrQuery.setParam("suggest", true);
                            }
                            solrQuery.setParam(kv[0], kv[1]);
                        }
                    }
                    return solrQuery;
                } else {
                    queryBuilder.append(nativeQueryString);
                }
            } else {
                if (SolrQueryIndex.isIgnoredProperty(pr, configuration)) {
                    continue;
                }

                String first = null;
                if (pr.first != null) {
                    first = partialEscape(String.valueOf(pr.first.getValue(pr.first.getType()))).toString();
                }
                String last = null;
                if (pr.last != null) {
                    last = partialEscape(String.valueOf(pr.last.getValue(pr.last.getType()))).toString();
                }

                String prField = configuration.getFieldForPropertyRestriction(pr);
                CharSequence fieldName = partialEscape(prField != null ? prField : pr.propertyName);
                if ("jcr\\:path".equals(fieldName.toString())) {
                    queryBuilder.append(configuration.getPathField());
                    queryBuilder.append(':');
                    queryBuilder.append(first);
                } else {
                    if (pr.first != null && pr.last != null && pr.first.equals(pr.last)) {
                        queryBuilder.append(fieldName).append(':');
                        queryBuilder.append(first);
                    } else if (pr.first == null && pr.last == null) {
                        if (!queryBuilder.toString().contains(fieldName + ":")) {
                            queryBuilder.append(fieldName).append(':');
                            queryBuilder.append('*');
                        }
                    } else if ((pr.first != null && pr.last == null) || (pr.last != null && pr.first == null)
                            || (!pr.first.equals(pr.last))) {
                        // TODO : need to check if this works for all field types (most likely not!)
                        queryBuilder.append(fieldName).append(':');
                        queryBuilder.append(createRangeQuery(first, last, pr.firstIncluding, pr.lastIncluding));
                    } else if (pr.isLike) {
                        // TODO : the current parameter substitution is not expected to work well
                        queryBuilder.append(fieldName).append(':');
                        queryBuilder.append(partialEscape(String.valueOf(pr.first.getValue(pr.first.getType()))
                                .replace('%', '*').replace('_', '?')));
                    } else {
                        throw new RuntimeException("[unexpected!] not handled case");
                    }
                }
            }
            queryBuilder.append(" ");
        }
    }

    if (configuration.useForPrimaryTypes()) {
        String[] pts = filter.getPrimaryTypes().toArray(new String[filter.getPrimaryTypes().size()]);
        StringBuilder ptQueryBuilder = new StringBuilder();
        for (int i = 0; i < pts.length; i++) {
            String pt = pts[i];
            if (i == 0) {
                ptQueryBuilder.append("(");
            }
            if (i > 0 && i < pts.length) {
                ptQueryBuilder.append("OR ");
            }
            ptQueryBuilder.append("jcr\\:primaryType").append(':').append(partialEscape(pt)).append(" ");
            if (i == pts.length - 1) {
                ptQueryBuilder.append(")");
                ptQueryBuilder.append(' ');
            }
        }
        solrQuery.addFilterQuery(ptQueryBuilder.toString());
    }

    if (filter.getQueryStatement() != null && filter.getQueryStatement().contains(QueryImpl.REP_EXCERPT)) {
        if (!solrQuery.getHighlight()) {
            // enable highlighting
            solrQuery.setHighlight(true);
            // defaults
            solrQuery.set("hl.fl", "*");
            solrQuery.set("hl.encoder", "html");
            solrQuery.set("hl.mergeContiguous", true);
            solrQuery.setHighlightSimplePre("<strong>");
            solrQuery.setHighlightSimplePost("</strong>");
        }
    }

    if (configuration.useForPathRestrictions()) {
        Filter.PathRestriction pathRestriction = filter.getPathRestriction();
        if (pathRestriction != null) {
            String path = purgePath(filter, plan.getPathPrefix());
            String fieldName = configuration.getFieldForPathRestriction(pathRestriction);
            if (fieldName != null) {
                if (pathRestriction.equals(Filter.PathRestriction.ALL_CHILDREN)) {
                    solrQuery.addFilterQuery(fieldName + ':' + path);
                } else {
                    queryBuilder.append(fieldName);
                    queryBuilder.append(':');
                    queryBuilder.append(path);
                }
            }
        }
    }

    if (configuration.collapseJcrContentNodes()) {
        solrQuery.addFilterQuery("{!collapse field=" + configuration.getCollapsedPathField() + " min="
                + configuration.getPathDepthField() + " hint=top_fc nullPolicy=expand}");
    }

    if (queryBuilder.length() == 0) {
        queryBuilder.append("*:*");
    }
    String escapedQuery = queryBuilder.toString();
    solrQuery.setQuery(escapedQuery);

    if (log.isDebugEnabled()) {
        log.debug("JCR query {} has been converted to Solr query {}", filter.getQueryStatement(),
                solrQuery.toString());
    }

    return solrQuery;
}

From source file:org.apache.jena.query.spatial.SpatialIndexSolr.java

License:Apache License

@SuppressWarnings("deprecation")
private SolrDocumentList solrQuery(Shape shape, int limit, SpatialOperation operation) {
    SolrQuery sq = new SolrQuery();
    sq.setQuery("*:*");
    sq.setFilterQueries(docDef.getGeoField() + ":\"" + operation.toString() + "("
            + SpatialQuery.ctx.toString(shape) + ") distErrPct=0\"");
    //System.out.println("SolrQuery: " +sq.toString());
    try {//from  w w  w.  java2 s  .  c o m
        QueryResponse rsp = solrServer.query(sq);
        SolrDocumentList docs = rsp.getResults();
        return docs;
    } catch (SolrServerException e) {
        exception(e);
        return null;
    }
}

From source file:org.apache.metron.solr.dao.SolrMetaAlertRetrieveLatestDao.java

License:Apache License

@Override
public Document getLatest(String guid, String sensorType) throws IOException {
    if (MetaAlertConstants.METAALERT_TYPE.equals(sensorType)) {
        // Unfortunately, we can't just defer to the indexDao for this. Child alerts in Solr end up
        // having to be dug out.
        String guidClause = Constants.GUID + ":" + guid;
        SolrQuery query = new SolrQuery();
        query.setQuery(guidClause).setFields("*", "[child parentFilter=" + guidClause + " limit=999]");

        try {/*from  w  w w.jav  a  2s.c om*/
            QueryResponse response = solrDao.getSolrClient(solrDao.getZkHosts()).query(METAALERTS_COLLECTION,
                    query);
            // GUID is unique, so it's definitely the first result
            if (response.getResults().size() == 1) {
                SolrDocument result = response.getResults().get(0);

                return SolrUtilities.toDocument(result);
            } else {
                return null;
            }
        } catch (SolrServerException e) {
            throw new IOException("Unable to retrieve metaalert", e);
        }
    } else {
        return solrDao.getLatest(guid, sensorType);
    }
}

From source file:org.apache.nifi.processors.solr.GetSolr.java

License:Apache License

@Override
public void onTrigger(final ProcessContext context, final ProcessSession session) throws ProcessException {

    final ComponentLog logger = getLogger();
    final AtomicBoolean continuePaging = new AtomicBoolean(true);
    final SolrQuery solrQuery = new SolrQuery();

    try {/*from w ww .jav  a  2  s .  c  o  m*/
        if (id_field == null) {
            id_field = getFieldNameOfUniqueKey();
        }

        final String dateField = context.getProperty(DATE_FIELD).getValue();

        final Map<String, String> stateMap = new HashMap<String, String>();
        stateMap.putAll(context.getStateManager().getState(Scope.CLUSTER).toMap());

        solrQuery.setQuery("*:*");
        final String query = context.getProperty(SOLR_QUERY).getValue();
        if (!StringUtils.isBlank(query) && !query.equals("*:*")) {
            solrQuery.addFilterQuery(query);
        }
        final StringBuilder automatedFilterQuery = (new StringBuilder()).append(dateField).append(":[")
                .append(stateMap.get(STATE_MANAGER_FILTER)).append(" TO *]");
        solrQuery.addFilterQuery(automatedFilterQuery.toString());

        final List<String> fieldList = new ArrayList<String>();
        final String returnFields = context.getProperty(RETURN_FIELDS).getValue();
        if (!StringUtils.isBlank(returnFields)) {
            fieldList.addAll(Arrays.asList(returnFields.trim().split("[,]")));
            if (!fieldList.contains(dateField)) {
                fieldList.add(dateField);
                dateFieldNotInSpecifiedFieldsList.set(true);
            }
            for (String returnField : fieldList) {
                solrQuery.addField(returnField.trim());
            }
        }

        solrQuery.setParam(CursorMarkParams.CURSOR_MARK_PARAM, stateMap.get(STATE_MANAGER_CURSOR_MARK));
        solrQuery.setRows(context.getProperty(BATCH_SIZE).asInteger());

        final StringBuilder sortClause = (new StringBuilder()).append(dateField).append(" asc,")
                .append(id_field).append(" asc");
        solrQuery.setParam("sort", sortClause.toString());

        while (continuePaging.get()) {
            final QueryRequest req = new QueryRequest(solrQuery);
            if (isBasicAuthEnabled()) {
                req.setBasicAuthCredentials(getUsername(), getPassword());
            }

            logger.debug(solrQuery.toQueryString());
            final QueryResponse response = req.process(getSolrClient());
            final SolrDocumentList documentList = response.getResults();

            if (response.getResults().size() > 0) {
                final SolrDocument lastSolrDocument = documentList.get(response.getResults().size() - 1);
                final String latestDateValue = df.format(lastSolrDocument.get(dateField));
                final String newCursorMark = response.getNextCursorMark();

                solrQuery.setParam(CursorMarkParams.CURSOR_MARK_PARAM, newCursorMark);
                stateMap.put(STATE_MANAGER_CURSOR_MARK, newCursorMark);
                stateMap.put(STATE_MANAGER_FILTER, latestDateValue);

                FlowFile flowFile = session.create();
                flowFile = session.putAttribute(flowFile, "solrQuery", solrQuery.toString());

                if (context.getProperty(RETURN_TYPE).getValue().equals(MODE_XML.getValue())) {
                    if (dateFieldNotInSpecifiedFieldsList.get()) {
                        for (SolrDocument doc : response.getResults()) {
                            doc.removeFields(dateField);
                        }
                    }
                    flowFile = session.write(flowFile,
                            SolrUtils.getOutputStreamCallbackToTransformSolrResponseToXml(response));
                    flowFile = session.putAttribute(flowFile, CoreAttributes.MIME_TYPE.key(),
                            "application/xml");

                } else {
                    final RecordSetWriterFactory writerFactory = context.getProperty(RECORD_WRITER)
                            .asControllerService(RecordSetWriterFactory.class);
                    final RecordSchema schema = writerFactory.getSchema(null, null);
                    final RecordSet recordSet = SolrUtils.solrDocumentsToRecordSet(response.getResults(),
                            schema);
                    final StringBuffer mimeType = new StringBuffer();
                    flowFile = session.write(flowFile, new OutputStreamCallback() {
                        @Override
                        public void process(final OutputStream out) throws IOException {
                            try {
                                final RecordSetWriter writer = writerFactory.createWriter(getLogger(), schema,
                                        out);
                                writer.write(recordSet);
                                writer.flush();
                                mimeType.append(writer.getMimeType());
                            } catch (SchemaNotFoundException e) {
                                throw new ProcessException("Could not parse Solr response", e);
                            }
                        }
                    });
                    flowFile = session.putAttribute(flowFile, CoreAttributes.MIME_TYPE.key(),
                            mimeType.toString());
                }
                session.transfer(flowFile, REL_SUCCESS);
            }
            continuePaging.set(response.getResults().size() == Integer
                    .parseInt(context.getProperty(BATCH_SIZE).getValue()));
        }
        context.getStateManager().setState(stateMap, Scope.CLUSTER);
    } catch (SolrServerException | SchemaNotFoundException | IOException e) {
        context.yield();
        session.rollback();
        logger.error("Failed to execute query {} due to {}", new Object[] { solrQuery.toString(), e }, e);
        throw new ProcessException(e);
    } catch (final Throwable t) {
        context.yield();
        session.rollback();
        logger.error("Failed to execute query {} due to {}", new Object[] { solrQuery.toString(), t }, t);
        throw t;
    }
}