@Override protected long doDeleteDocuments(IndexWriter indexWriter, String tenantId) throws IOException { return indexWriter.deleteAll(); } }
/** Calls {@link IndexWriter#deleteAll} and returns the * generation that reflects this change. */ public long deleteAll() throws IOException { writer.deleteAll(); // Return gen as of when indexing finished: return indexingGen.get(); }
public void delete() { try { IndexWriter writer = index.writer; writer.deleteAll(); writer.commit(); } catch (IOException e) { log.log(Level.SEVERE, "IO error while deleting index.", e); } }
@Override public boolean truncate(long l) { try { if (logger.isInfoEnabled()) { logger.info("SG BasicIndexer - Truncating index - {}", indexName); } indexWriter.deleteAll(); return true; } catch (IOException e) { throw new RuntimeException(e); } }
StandardAnalyzer analyzer = new StandardAnalyzer(Version.LUCENE_46); FSDirectory dir; try { // delete indexing files : dir = FSDirectory.open(new File(path_dir)); IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_46, analyzer); IndexWriter writer = new IndexWriter(dir, config); writer.deleteAll(); writer.close(); } catch (IOException e) { e.printStackTrace(); }
@Override public void deleteAll() throws IOException { try (Ticker ignored = deleteAllMetric.start()) { super.deleteAll(); } }
/** * @deprecated */ @Deprecated public void deleteAll() { LOGGER.info("delete all content"); try { getWriter().deleteAll(); } catch (IOException e) { LOGGER.error(e.getMessage(), e); } }
public void copyStagingContent(String srcPath) throws IOException { try (FSDirectory dir = FSDirectory.open(new File(srcPath));) { IndexWriter writer = getWriter(); writer.deleteAll(); writer.addIndexes(dir); writer.commit(); } } }
IndexWriterConfig config=new IndexWriterConfig(Version.LUCENE_46,analyzer); try { IndexWriter iwriter=new IndexWriter(mDir,config); iwriter.deleteAll(); iwriter.commit(); Document doc = new Document(); doc.add(new Field(myfieldname,text,TextField.TYPE_STORED)); iwriter.addDocument(doc); iwriter.close(); }
@VisibleForTesting public void deleteEverything() throws IOException{ committerThread.throwExceptionIfAny(); writer.deleteAll(); commit(); } }
@Override public void removeAll() { try { writer.deleteAll(); writer.commit(); } catch (final IOException e) { throw new LuceneStoreRuntimeException(e); } finally { cleanAfterCommit(); } }
public void truncateIndex() throws LuceneException { try (Ticker ignored = truncateIndexMetric.start()) { withWriter(writer -> writer.deleteAll()); } }
public void delete() { committerThread.throwExceptionIfAny(); try { writer.deleteAll(); commit(); // Forcing refresh of index so that open files are freed and deleted from disk checkIfChanged(); } catch(Exception ex){ throw Throwables.propagate(ex); } }
public void clearData() throws StorageException { if (! isOpen) { throw new StorageException(ErrorMessages.OPERATOR_NOT_OPENED); } try { this.luceneIndexWriter.deleteAll(); } catch (IOException e) { close(); throw new StorageException(e.getMessage(), e); } }
@DELETE public Response delete() throws IOException { final IndexWriter writer = getIndexWriter(); try { writer.deleteAll(); writer.commit(); } finally { writer.close(); } return Response.ok().build(); }
public void clear() { try { mgrWriter.getIndexWriter().deleteAll(); } catch (IOException e) { OLogManager.instance().error(this, "Error on clearing Lucene index", e); } }
final void deleteAll(Map<String, String> commitUserData) throws IOException { checkIsMaster(); try (final ReadWriteSemaphores.Lock lock = readWriteSemaphores.acquireWriteSemaphore()) { writerAndSearcher.write((indexWriter, taxonomyWriter) -> { indexWriter.deleteAll(); if (commitUserData != null) indexWriter.setLiveCommitData(commitUserData.entrySet()); return null; }); nrtCommit(); } }
@Override public void clear() { updateLastAccess(); openIfClosed(); try { reopenToken = indexWriter.deleteAll(); } catch (IOException e) { OLogManager.instance().error(this, "Error on clearing Lucene index", e); } }
@Override public boolean delete(String name) throws IOException { try (val index = provide(name)) { try (val writer = index.use().provideWriter()) { writer.use().deleteAll(); } } close(name); return doDelete(name); }