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

Introduction

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

Prototype

public SolrQuery setRows(Integer rows) 

Source Link

Usage

From source file:io.logspace.hq.core.solr.event.SolrEventStreamService.java

License:Open Source License

@Override
public void stream(EventFilter eventFilter, int count, int offset, EventStreamer eventStreamer) {
    SolrQuery solrQuery = new SolrQuery(ALL_DOCS_QUERY);
    solrQuery.setStart(offset);/*ww w .j ava  2 s .com*/
    solrQuery.setRows(count);
    solrQuery.set(SORT, SORT_CRON_ASC);

    for (EventFilterElement eachElement : eventFilter) {
        solrQuery.addFilterQuery(this.createFilterQuery(eachElement));
    }

    try {
        this.solrClient.queryAndStreamResponse(solrQuery, new EventStreamCallback(eventStreamer));
    } catch (SolrServerException | IOException e) {
        String message = "Failed to stream events.";
        this.logger.error(message, e);
        throw EventStoreException.retrieveFailed(message, e);
    }
}

---

From source file:io.logspace.hq.core.solr.spaces.SolrSpacesService.java

License:Open Source License

private void loadSpacesFromSolr() throws SolrServerException, IOException {
    this.logger.debug("Loading spaces from Config Solr.");
    Set<String> activeTokens = new HashSet<>();

    SolrQuery solrQuery = new SolrQuery("*:*");
    solrQuery.setFilterQueries(ConfigFieldConstants.FIELD_TYPE + ":" + CONFIG_TYPE);
    solrQuery.setRows(Integer.MAX_VALUE);

    QueryResponse queryResponse = this.solrClient.query(solrQuery);
    for (SolrDocument eachSolrDocument : queryResponse.getResults()) {
        String spaceName = SolrDocumentHelper.getString(eachSolrDocument, FIELD_NAME);
        String tokenString = SolrDocumentHelper.getString(eachSolrDocument, FIELD_CONTENT);
        String[] tokens = tokenString.split("\\s*,\\s*");

        for (String eachToken : tokens) {
            this.spaces.put(eachToken, spaceName);
            activeTokens.add(eachToken);
        }/* w w w  .  j  a  v a2s. c o m*/
    }

    this.spaces.keySet().retainAll(activeTokens);
}

---

From source file:io.logspace.hq.core.solr.utils.SolrQueryHelper.java

License:Open Source License

public static void setRange(SolrQuery solrQuery, int start, int count) {
    solrQuery.setStart(start);/*  w w w .jav a  2 s . com*/
    solrQuery.setRows(count);
}

---

From source file:io.logspace.hq.solr.SolrEventService.java

License:Open Source License

@SuppressWarnings("unchecked")
@Override//from w  ww .ja  va  2 s . c om
public AgentActivities getAgentActivities(int start, int count, int durationSeconds, int steps, String sort) {
    SolrQuery solrQuery = new SolrQuery(ALL_DOCS_QUERY);
    solrQuery.setRows(0);

    Date endDate = new Date();
    Date startDate = new Date(endDate.getTime() - SECONDS.toMillis(durationSeconds));

    solrQuery.addFilterQuery(this.getTimestampRangeQuery(startDate, endDate));

    TermsFacet agentFacet = new TermsFacet(FIELD_GLOBAL_AGENT_ID, FIELD_GLOBAL_AGENT_ID);
    agentFacet.setOffset(start);
    agentFacet.setLimit(count);
    agentFacet.setMincount(0);
    agentFacet.setNumBuckets(true);
    agentFacet.setSort(sort);
    agentFacet.addSubFacet(new RangeFacet(FIELD_TIMESTAMP, FIELD_TIMESTAMP, startDate, endDate, GapUnit.SECONDS,
            durationSeconds / steps));

    solrQuery.set("json.facet", FacetList.toJsonString(agentFacet));

    try {
        AgentActivities result = new AgentActivities();

        QueryResponse response = this.solrClient.query(solrQuery, METHOD.POST);

        Buckets agentBuckets = Buckets.fromResponse(response, FIELD_GLOBAL_AGENT_ID);
        result.setOffset(start);
        result.setTotalCount(agentBuckets.getNumBuckets());

        int maxHistoryValue = 0;

        for (NamedList<Object> eachAgentBucket : agentBuckets) {
            AgentActivity agentActivity = new AgentActivity();

            agentActivity.setGlobalAgentId((String) eachAgentBucket.get(VALUE_FACET_NAME));
            agentActivity.setEventCount(Buckets.getInt(eachAgentBucket, COUNT_FACET_NAME));

            int[] history = new int[steps];

            Buckets historyBuckets = Buckets
                    .fromFacet((NamedList<Object>) eachAgentBucket.get(FIELD_TIMESTAMP));
            for (int i = 0; i < Math.min(historyBuckets.getBucketCount(), history.length); i++) {
                NamedList<Object> historyBucket = historyBuckets.getBucket(i);

                int historyValue = Buckets.getInt(historyBucket, COUNT_FACET_NAME);
                history[i] = historyValue;
                maxHistoryValue = Math.max(maxHistoryValue, historyValue);
            }
            agentActivity.setHistory(history);

            result.add(agentActivity);
        }

        result.setMaxHistoryValue(maxHistoryValue);

        return result;
    } catch (SolrException | SolrServerException | IOException e) {
        throw new DataRetrievalException("Could not retrieve Agent activities.", e);
    }
}

---

From source file:io.logspace.hq.solr.SolrEventService.java

License:Open Source License

@Override
public Suggestion getSuggestion(SuggestionInput input) {
    TimeTracker timeTracker = new TimeTracker();

    SolrQuery solrQuery = new SolrQuery(ALL_DOCS_QUERY);
    solrQuery.setRows(0);

    if (!StringUtils.isBlank(input.getText())) {
        solrQuery.addFilterQuery(FIELD_TOKENIZED_SEARCH_FIELD + ":" + escapeSolr(input.getText()) + "*");
    }/*from   w w  w . jav  a2s. co m*/

    this.addFilterQuery(solrQuery, FIELD_PROPERTY_ID, input.getPropertyId());
    this.addFilterQuery(solrQuery, FIELD_SPACE, input.getSpaceId());
    this.addFilterQuery(solrQuery, FIELD_SYSTEM, input.getSystemId());

    solrQuery.setFacetMinCount(1);
    solrQuery.addFacetField(FIELD_GLOBAL_AGENT_ID);

    try {
        Suggestion result = new Suggestion();

        QueryResponse response = this.solrClient.query(solrQuery);

        FacetField globalAgentIdFacetField = response.getFacetField(FIELD_GLOBAL_AGENT_ID);
        for (Count eachValue : globalAgentIdFacetField.getValues()) {
            String globalAgentId = eachValue.getName();

            result.addAgentDescription(this.getAgentDescription(globalAgentId));
        }

        result.setExecutionTime(timeTracker.getElapsed(MILLISECONDS));
        return result;
    } catch (SolrException | SolrServerException | IOException e) {
        throw new DataRetrievalException("Failed to create suggestions", e);
    }
}

---

From source file:io.logspace.hq.solr.SolrEventService.java

License:Open Source License

@Override
public Object[] getTimeSeries(TimeSeriesDefinition dataDefinition) {
    SolrQuery solrQuery = new SolrQuery(ALL_DOCS_QUERY);
    solrQuery.setRows(0);

    solrQuery.addFilterQuery(FIELD_GLOBAL_AGENT_ID + ":" + escapeSolr(dataDefinition.getGlobalAgentId()));
    solrQuery.addFilterQuery(this.getTimestampRangeQuery(dataDefinition.getTimeWindow()));
    solrQuery.addFilterQuery(dataDefinition.getPropertyId() + ":*");
    solrQuery.set("json.facet", this.createTimeSeriesFacets(dataDefinition));

    try {/*from w  w w . ja v  a  2 s. c  om*/
        QueryResponse response = this.solrClient.query(solrQuery, METHOD.POST);

        List<Object> values = new ArrayList<Object>();

        Buckets buckets = Buckets.fromResponse(response, FIELD_TIMESTAMP);
        for (NamedList<Object> eachBucket : buckets) {
            if (dataDefinition.getAggregate() == Aggregate.count) {
                values.add(eachBucket.get(COUNT_FACET_NAME));
            } else {
                values.add(eachBucket.get(AGGREGATION_FACET_NAME));
            }
        }

        return values.toArray();
    } catch (SolrException | SolrServerException | IOException e) {
        throw new DataRetrievalException("Could not retrieve data.", e);
    }
}

---

From source file:io.logspace.hq.solr.SolrEventService.java

License:Open Source License

private AgentDescription loadAgentDescription(String globalAgentId) throws SolrServerException, IOException {
    SolrQuery query = new SolrQuery(ALL_DOCS_QUERY);
    query.setRows(0);

    query.setFilterQueries(FIELD_GLOBAL_AGENT_ID + ":\"" + globalAgentId + "\"");

    query.setFacetMinCount(1);//from w  w  w . j  a  v a  2  s .  c  o  m
    query.addFacetField(FIELD_SPACE, FIELD_SYSTEM, FIELD_PROPERTY_ID);

    QueryResponse response = this.solrClient.query(query);

    AgentDescription result = new AgentDescription();
    result.setGlobalId(globalAgentId);
    result.setName(this.capabilitiesService.getAgentId(globalAgentId));
    result.setSpace(this.getFirstFacetValue(response, FIELD_SPACE));
    result.setSystem(this.getFirstFacetValue(response, FIELD_SYSTEM));

    List<PropertyDescription> propertyDescriptions = new ArrayList<>();
    FacetField facetField = response.getFacetField(FIELD_PROPERTY_ID);
    for (Count eachValue : facetField.getValues()) {
        propertyDescriptions.add(this.createPropertyDescription(eachValue.getName()));
    }
    Collections.sort(propertyDescriptions);
    result.setPropertyDescriptions(propertyDescriptions);

    return result;
}

---

From source file:io.logspace.it.AbstractLogspaceTest.java

License:Open Source License

protected final long getSolrDocumentCount(String query) {
    SolrQuery solrQuery = new SolrQuery(query);
    solrQuery.setRows(0);

    try {//from w ww  .  j  av  a 2 s  .c o m
        QueryResponse queryResponse = this.getEventSolrClient().query(solrQuery);
        return queryResponse.getResults().getNumFound();
    } catch (Exception e) {
        throw new LogspaceTestException("Failed to retrieve Solr document count for query '" + query + "'.", e);
    }
}

---

From source file:it.damore.solr.importexport.App.java

License:Open Source License

/**
 * @param client/*ww  w.ja  v a2s . co  m*/
 * @param outputFile
 * @throws SolrServerException
 * @throws IOException
 */
private static void readAllDocuments(HttpSolrClient client, File outputFile)
        throws SolrServerException, IOException {

    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery("*:*");
    if (config.getFilterQuery() != null) {
        solrQuery.addFilterQuery(config.getFilterQuery());
    }
    solrQuery.setRows(0);

    solrQuery.addSort(config.getUniqueKey(), ORDER.asc); // Pay attention to this line

    String cursorMark = CursorMarkParams.CURSOR_MARK_START;

    TimeZone.setDefault(TimeZone.getTimeZone("UTC"));

    // objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, true);
    DateFormat df = new SimpleDateFormat("YYYY-MM-dd'T'HH:mm:sss'Z'");
    objectMapper.setDateFormat(df);
    objectMapper.configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS, true);

    QueryResponse r = client.query(solrQuery);

    long nDocuments = r.getResults().getNumFound();
    logger.info("Found " + nDocuments + " documents");

    if (!config.getDryRun()) {
        logger.info("Creating " + config.getFileName());

        Set<SkipField> skipFieldsEquals = config.getSkipFieldsSet().stream()
                .filter(s -> s.getMatch() == MatchType.EQUAL).collect(Collectors.toSet());
        Set<SkipField> skipFieldsStartWith = config.getSkipFieldsSet().stream()
                .filter(s -> s.getMatch() == MatchType.STARTS_WITH).collect(Collectors.toSet());
        Set<SkipField> skipFieldsEndWith = config.getSkipFieldsSet().stream()
                .filter(s -> s.getMatch() == MatchType.ENDS_WITH).collect(Collectors.toSet());

        try (PrintWriter pw = new PrintWriter(outputFile)) {
            solrQuery.setRows(200);
            boolean done = false;
            while (!done) {
                solrQuery.set(CursorMarkParams.CURSOR_MARK_PARAM, cursorMark);
                QueryResponse rsp = client.query(solrQuery);
                String nextCursorMark = rsp.getNextCursorMark();

                for (SolrDocument d : rsp.getResults()) {
                    skipFieldsEquals.forEach(f -> d.removeFields(f.getText()));
                    if (skipFieldsStartWith.size() > 0 || skipFieldsEndWith.size() > 0) {
                        Map<String, Object> collect = d.entrySet().stream()
                                .filter(e -> !skipFieldsStartWith.stream()
                                        .filter(f -> e.getKey().startsWith(f.getText())).findFirst()
                                        .isPresent())
                                .filter(e -> !skipFieldsEndWith.stream()
                                        .filter(f -> e.getKey().endsWith(f.getText())).findFirst().isPresent())
                                .collect(Collectors.toMap(e -> e.getKey(), e -> e.getValue()));
                        pw.write(objectMapper.writeValueAsString(collect));
                    } else {
                        pw.write(objectMapper.writeValueAsString(d));
                    }
                    pw.write("\n");
                }
                if (cursorMark.equals(nextCursorMark)) {
                    done = true;
                }

                cursorMark = nextCursorMark;
            }

        }
    }

}

---

From source file:it.isti.cnr.hpc.europeana.hackthon.api.Suggestion.java

License:Apache License

public List<String> getSuggestion(String query) {
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery(query);/*w  w w . j  a va2 s . c o  m*/
    // sets the number of results
    solrQuery.setRows(20);
    solrQuery.setFilterQueries("freq:[15 TO *]");
    QueryResponse rsp = null;
    try {
        rsp = server.query(solrQuery);
    } catch (SolrServerException e) {
        logger.error("The suggestion server can not reply {}", e.toString());
        // e.printStackTrace();
        return null;
    } catch (Exception e) {
        logger.error("Problem producing the suggestions " + e.toString());
        return null;
    }
    SolrDocumentList docs = rsp.getResults();
    List<String> suggestions = new ArrayList<String>();
    for (SolrDocument d : docs) {
        String value = (String) d.getFieldValue("sem_label");
        value = value.replaceAll("%28.*%29", " ");
        suggestions.add(value);
    }
    return suggestions;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• »