fieldList = fields.toArray(new String[fields.size()]); SolrQuery query = new SolrQuery(); query.setQuery("*:*"); query.setParam("fq", "id:[ " + startkey + " TO * ]"); if (returnFields) { query.setFields(fieldList); query.setRows(recordcount); final QueryResponse response = client.query(table, query); SolrDocumentList results = response.getResults(); entry = new HashMap<String, ByteIterator>((int) results.getNumFound()); for (String field : hit.getFieldNames()) { entry.put(field, new StringByteIterator(String.valueOf(hit.getFirstValue(field)))); return checkStatus(response.getStatus()); } catch (IOException | SolrServerException e) { e.printStackTrace();
public Status insert(String table, String key, Map<String, ByteIterator> values) { try { SolrInputDocument doc = new SolrInputDocument(); doc.addField("id", key); for (Entry<String, String> entry : StringByteIterator.getStringMap(values).entrySet()) { doc.addField(entry.getKey(), entry.getValue()); response = client.add(table, doc, commitTime); } else { response = client.add(table, doc); client.commit(table);
@Override public void cleanup() { if (solrClient != null) { try { solrClient.close(); } catch (IOException e) { LOG.error("Error while closing solrClient", e); } } }
@Override public void deleteAllDocuments(SolrClient server) throws ServiceException { try { String deleteQuery = "*:*"; LOG.debug("Deleting by query: " + deleteQuery); server.deleteByQuery(deleteQuery); server.commit(); } catch (Exception e) { throw new ServiceException("Could not delete documents", e); } }
public void updateState(List<TridentTuple> tuples) { try { SolrRequest solrRequest = solrMapper.toSolrRequest(tuples); solrClient.request(solrRequest, solrMapper.getCollection()); solrClient.commit(solrMapper.getCollection()); } catch (Exception e) { final String msg = String.format("%s", tuples); logger.warn(msg); throw new FailedException(msg, e); } } }
/** * Delete a record from the database. * * @param table * The name of the table * @param key * The record key of the record to delete. * @return Zero on success, a non-zero error code on error. See this class's description for a * discussion of error codes. */ @Override public Status delete(String table, String key) { try { UpdateResponse response; if (batchMode) { response = client.deleteById(table, key, commitTime); } else { response = client.deleteById(table, key); client.commit(table); } return checkStatus(response.getStatus()); } catch (IOException | SolrServerException e) { e.printStackTrace(); } return Status.ERROR; }
SolrQuery solrQuery = new SolrQuery() .setQuery(searchCriteria.getQuery()) .setRows(searchCriteria.getPageSize()) .setStart((start) * searchCriteria.getPageSize()) .setRequestHandler(searchCriteria.getRequestHandler()); int numResults = 0; try { response = solrConfiguration.getServer().query(solrQuery, getSolrQueryMethod()); responseDocuments = getResponseDocuments(response); numResults = (int) response.getResults().getNumFound(); LOG.trace(response.toString());
fieldList = fields.toArray(new String[fields.size()]); SolrQuery query = new SolrQuery(); query.setQuery("id:" + key); if (returnFields) { query.setFields(fieldList); final QueryResponse response = client.query(table, query); SolrDocumentList results = response.getResults(); if ((results != null) && (results.getNumFound() > 0)) { for (String field : results.get(0).getFieldNames()) { result.put(field, new StringByteIterator(String.valueOf(results.get(0).getFirstValue(field)))); return checkStatus(response.getStatus()); } catch (IOException | SolrServerException e) { e.printStackTrace();
String collection = query.getStore(); String keyIdField = getKeyFieldId(collection); SolrQuery solrQuery = new SolrQuery("*:*"); String queryFilter = buildQueryFilter(query.getCondition(), informations.get(collection)); solrQuery.addFilterQuery(queryFilter); if (!query.getOrder().isEmpty()) { List<IndexQuery.OrderEntry> orders = query.getOrder(); String item = order1.getKey(); SolrQuery.ORDER order = order1.getOrder() == Order.ASC ? SolrQuery.ORDER.asc : SolrQuery.ORDER.desc; solrQuery.addSort(new SolrQuery.SortClause(item, order)); QueryResponse response = solrClient.query(collection, solrQuery); logger.debug("Executed query [{}] in {} ms", query.getCondition(), response.getElapsedTime()); int totalHits = response.getResults().size(); for (SolrDocument hit : response.getResults()) { result.add(hit.getFieldValue(keyIdField).toString());
String collection = query.getStore(); String keyIdField = getKeyFieldId(collection); SolrQuery solrQuery = new SolrQuery(query.getQuery()) .addField(keyIdField) .setIncludeScore(true) .setStart(query.getOffset()) .setRows(query.hasLimit() ? query.getLimit() : maxResults); QueryResponse response = solrClient.query(collection, solrQuery); if (logger.isDebugEnabled()) logger.debug("Executed query [{}] in {} ms", query.getQuery(), response.getElapsedTime()); int totalHits = response.getResults().size(); if (!query.hasLimit() && totalHits >= maxResults) { logger.warn("Query result set truncated to first [{}] elements for query: {}", maxResults, query); for (SolrDocument hit : response.getResults()) { double score = Double.parseDouble(hit.getFieldValue("score").toString()); result.add(new RawQuery.Result<String>(hit.getFieldValue(keyIdField).toString(), score));
public boolean existsInIndex(String username) { SolrQuery solrQuery = new SolrQuery().setQuery("name:" + username); try { return 1 == solrClient.query(solrQuery).getResults().getNumFound(); } catch (SolrServerException | IOException e) { throw new RuntimeException(e); } }
@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 { 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); } }
private SolrInputDocument fetchExistingOrCreateNewSolrDoc(String id) throws SolrServerException, IOException { Map<String, String> p = new HashMap<String, String>(); p.put("q", PHRASE + ":\"" + ClientUtils.escapeQueryChars(id) + "\""); SolrParams params = new MapSolrParams(p); QueryResponse res = solrAC.query(params); if (res.getResults().size() == 0) { return new SolrInputDocument(); } else if (res.getResults().size() == 1) { SolrDocument doc = res.getResults().get(0); SolrInputDocument tmp = new SolrInputDocument(); for (String fieldName : doc.getFieldNames()) { tmp.addField(fieldName, doc.getFieldValue(fieldName)); } return tmp; } else { throw new IllegalStateException("Query with params : " + p + " returned more than 1 hit!"); } }
String fullClause = "{!parent which=" + activeClause + "}" + guidClause; String metaalertTypeClause = config.getSourceTypeField() + ":" + MetaAlertConstants.METAALERT_TYPE; SolrQuery solrQuery = new SolrQuery() .setQuery(fullClause) .setFields("*", "[child parentFilter=" + metaalertTypeClause + " limit=999]") .addSort(Constants.GUID, while (!done) { solrQuery.set(CursorMarkParams.CURSOR_MARK_PARAM, cursorMark); QueryResponse rsp = solrClient.query(METAALERTS_COLLECTION, solrQuery); String nextCursorMark = rsp.getNextCursorMark(); rsp.getResults().stream() .map(solrDocument -> SolrUtilities.getSearchResult(solrDocument, null, solrSearchDao.getAccessConfig().getIndexSupplier()))
protected void index_specific(int serverNumber, Object... fields) throws Exception { SolrInputDocument doc = new SolrInputDocument(); for (int i = 0; i < fields.length; i += 2) { doc.addField((String) (fields[i]), fields[i + 1]); } controlClient.add(doc); SolrClient client = clients.get(serverNumber); client.add(doc); }
@Override public long countCollection(String name) throws DatastoreClientServiceException { try { SolrQuery q = new SolrQuery("*:*"); q.setRows(0); // don't actually request any data return getClient().query(name, q).getResults().getNumFound(); } catch (Exception e) { throw new DatastoreClientServiceException(e); } }
@Override public GroupResponse group(GroupRequest groupRequest) throws InvalidSearchException { try { String groupNames = groupRequest.getGroups().stream().map(Group::getField).collect( Collectors.joining(",")); SolrQuery query = new SolrQuery() .setStart(0) .setRows(0) .setQuery(groupRequest.getQuery()); query.set("collection", getCollections(groupRequest.getIndices())); Optional<String> scoreField = groupRequest.getScoreField(); if (scoreField.isPresent()) { query.set("stats", true); query.set("stats.field", String.format("{!tag=piv1 sum=true}%s", scoreField.get())); } query.set("facet", true); query.set("facet.pivot", String.format("{!stats=piv1}%s", groupNames)); QueryResponse response = client.query(query); return buildGroupResponse(groupRequest, response); } catch (IOException | SolrServerException e) { String msg = e.getMessage(); LOG.error(msg, e); throw new InvalidSearchException(msg, e); } }
@Override public long count(String collection, SolrDataQuery query, @Nullable Class<?> domainType, RequestMethod method) { Assert.notNull(collection, "Collection must not be null!"); Assert.notNull(query, "Query must not be 'null'."); Assert.notNull(method, "Method must not be 'null'."); return execute(solrClient -> { SolrQuery solrQuery = constructQuery(query, domainType); solrQuery.clearSorts(); solrQuery.setStart(0); solrQuery.setRows(0); return solrClient.query(collection, solrQuery, getSolrRequestMethod(method)).getResults().getNumFound(); }); }
private void deleteIndividualFieldsFromIndex(String collectionName, String keyIdField, String docId, HashSet<IndexEntry> fieldDeletions) throws SolrServerException, IOException { if (fieldDeletions.isEmpty()) return; Map<String, String> fieldDeletes = new HashMap<String, String>(1) {{ put("set", null); }}; SolrInputDocument doc = new SolrInputDocument(); doc.addField(keyIdField, docId); StringBuilder sb = new StringBuilder(); for (IndexEntry fieldToDelete : fieldDeletions) { doc.addField(fieldToDelete.field, fieldDeletes); sb.append(fieldToDelete).append(","); } if (logger.isTraceEnabled()) logger.trace("Deleting individual fields [{}] for document {}", sb.toString(), docId); UpdateRequest singleDocument = newUpdateRequest(); singleDocument.add(doc); solrClient.request(singleDocument, collectionName); }
public static void doQuery(SolrClient ss, String id) throws SolrServerException, IOException { SolrParams p = new SolrQuery("id:\"" + id + "\""); QueryResponse r = ss.query(p); System.out.println("GOT collection " + r.getResults().get(0).getFieldValue("collection")); System.out.println("GOT collections " + r.getResults().get(0).getFieldValue("collections")); System.out.println("STILL GOT crawl_date " + r.getResults().get(0).getFieldValue("crawl_date")); }