@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); } }
@Override public void deleteByQuery(String deleteQuery) throws SolrServerException, IOException { String productFilter = shs.getTypeFieldName() + ":" + shs.getPrimaryDocumentType(); // transform the deleteQuery to include the productFilter, this is necessary to ensure that we don't delete non-product documents accidentally deleteQuery = productFilter + " AND (" + deleteQuery + ")"; String childDeleteQuery = "{!child of=" + productFilter + "} " + deleteQuery; solrConfiguration.getServer().deleteByQuery(childDeleteQuery); solrConfiguration.getServer().deleteByQuery(deleteQuery); logDeleteQuery(childDeleteQuery); logDeleteQuery(deleteQuery); }
@Override public void deleteAllNamespaceDocuments(SolrClient server) throws ServiceException { try { String deleteQuery = StringUtil.sanitize(shs.getNamespaceFieldName()) + ":(\"" + StringUtil.sanitize(solrConfiguration.getNamespace()) + "\")"; LOG.debug("Deleting by query: " + deleteQuery); server.deleteByQuery(deleteQuery); //Explicitly do a hard commit here since we just deleted the entire index server.commit(); } catch (Exception e) { if (ServiceException.class.isAssignableFrom(e.getClass())) { throw (ServiceException) e; } throw new ServiceException("Could not delete documents", e); } }
protected void del(String q) throws Exception { controlClient.deleteByQuery(q); for (SolrClient client : clients) { client.deleteByQuery(q); } }// serial commit...
@Override public void deleteByQuery(String query) throws SolrServerException, IOException { this.logger.debug("Delete Solr documents from index based on query [{}]", query); this.server.deleteByQuery(query); }
/** * Clears the whole data on SolRDF. * * @throws UnableToDeleteException in case the deletion is not possible. */ public void clear() throws UnableToDeleteException { try { solr.deleteByQuery("*:*"); } catch(final Exception exception) { throw new UnableToDeleteException(exception); } }
@Override protected void del(String q) throws Exception { controlClient.deleteByQuery(q); cloudClient.deleteByQuery(q); /*** for (SolrServer client : clients) { UpdateRequest ureq = new UpdateRequest(); // ureq.setParam("update.chain", DISTRIB_UPDATE_CHAIN); ureq.deleteByQuery(q).process(client); } ***/ }// serial commit...
@Override public void clearIndex() { try { solrClientLogger.debug(">>> clear complete index"); solrClient.deleteByQuery("*:*"); } catch (SolrServerException | IOException e) { log.error("Cannot clear index", e); throw new SearchServerException("Cannot clear index", e); } }
@Override public UpdateResponse delete(String collection, SolrDataQuery query, @Nullable Class<?> domainType) { Assert.notNull(query, "Query must not be 'null'."); final String queryString = this.queryParsers.getForClass(query.getClass()).getQueryString(query, domainType); return execute(solrClient -> solrClient.deleteByQuery(collection, queryString)); }
public JsonObjectBuilder deleteAllFromSolrAndResetIndexTimes() throws SolrServerException, IOException { JsonObjectBuilder response = Json.createObjectBuilder(); logger.info("attempting to delete all Solr documents before a complete re-index"); solrServer.deleteByQuery("*:*"); solrServer.commit(); int numRowsAffected = dvObjectService.clearAllIndexTimes(); response.add(numRowsClearedByClearAllIndexTimes, numRowsAffected); response.add(messageString, "Solr index and database index timestamps cleared."); return response; }
public static <T extends IsIndexed> void deleteByQuery(SolrClient index, String classToDelete, Filter filter) throws GenericException, RequestNotValidException { try { index.deleteByQuery(classToDelete, parseFilter(filter)); } catch (SolrServerException | SolrException | IOException e) { throw new GenericException("Could not delete items", e); } }
private void clearSolr(Map<String, String> indexConnectionParams) throws SolrServerException, IOException { Set<SolrClient> servers = createSolrClients(indexConnectionParams); for (SolrClient server : servers) { server.deleteByQuery("*:*"); server.commit(false, false); try { server.close(); } catch (java.io.IOException e) { throw new RuntimeException(e); } } }
private void clearSolr(Map<String, String> indexConnectionParams, String uniqueKeyField) throws SolrServerException, IOException { Set<SolrClient> servers = createSolrServers(indexConnectionParams, uniqueKeyField); for (SolrClient server : servers) { server.deleteByQuery("*:*"); server.commit(false, false); try { server.close(); } catch (java.io.IOException e) { throw new RuntimeException(e); } } }
@Override public void performDelete(final Triple triple) { try { cloud.deleteByQuery(deleteQuery(triple)); } catch (final Exception exception) { LOGGER.error(MessageCatalog._00113_NWS_FAILURE, exception); throw new DeleteDeniedException(exception.getMessage(), triple); } }
@Override public void clear() { try { cloud.deleteByQuery(fq(Field.C, graphNodeStringified)); } catch (final Exception exception) { LOGGER.error(MessageCatalog._00113_NWS_FAILURE, exception); throw new DeleteDeniedException(exception.getMessage()); } }
@Override public boolean clearIndex() throws IndexException { UpdateResponse resp; try { resp = this._client.deleteByQuery(this._collection, "*:*"); resp = this._client.commit(this._collection); } catch (SolrServerException | IOException ex) { throw new IndexException("Failed to clear index", ex); } return resp.getStatus() == 0; }
public void deleteByQuery(String query, ModifiableSolrParams params) throws IOException, SolrServerException { if (local()) { assertU(delQ(query)); // todo - handle extra params return; } for (SolrClient client : provider.all()) { client.deleteByQuery(query); // todo - handle extra params } }
public void clearAIPEventIndex() throws GenericException, AuthorizationDeniedException { RodaCoreFactory.checkIfWriteIsAllowedAndIfFalseThrowException(nodeType); String indexName = RodaConstants.INDEX_PRESERVATION_EVENTS; try { getSolrClient().deleteByQuery(indexName, "*:* -" + RodaConstants.PRESERVATION_EVENT_OBJECT_CLASS + ":" + PreservationMetadataEventClass.REPOSITORY.toString()); getSolrClient().commit(indexName); } catch (SolrServerException | IOException e) { LOGGER.error("Error cleaning up index {}", indexName, e); throw new GenericException("Error cleaning up index " + indexName, e); } }
private void deleteAllDocuments() throws SolrServerException, IOException { collector.reset(); SolrClient s = solrClient; s.deleteByQuery("*:*"); // delete everything! s.commit(); }
@After public void tearDown() throws Exception { if (server != null && server.ping() != null) { server.deleteByQuery("*:*"); server.commit(); server = null; } }