@Override public void deleteDocument(int docNum) throws StaleReaderException, CorruptIndexException, LockObtainFailedException, IOException { in.deleteDocument(docNum); }
public void store(String fileUrl, List<IndexDocument> documents) throws IOException { checkPreconditions(); assert ClassIndexManager.holdsWriteLock(); boolean create = !isValid(false); if (!create) { IndexReader in = getReader(); final Searcher searcher = new IndexSearcher (in); try { if (fileUrl != null) { BooleanQuery query = new BooleanQuery (); query.add (new TermQuery (new Term (DocumentUtil.FIELD_FILENAME, fileUrl)),BooleanClause.Occur.MUST); Hits hits = searcher.search(query); for (int i=0; i<hits.length(); i++) { in.deleteDocument (hits.id(i)); } } in.deleteDocuments (DocumentUtil.rootDocumentTerm()); } finally { searcher.close(); } } long timeStamp = System.currentTimeMillis(); if (documents != null) { store(documents, create, timeStamp, fileUrl); } }
@Override protected void doDelete(int docNum) throws CorruptIndexException, IOException { reader.deleteDocument(docNum); }
@Override public void deleteDocument(final int docNum) throws IOException { this.delegate.deleteDocument(docNum); }
protected void doDelete(int n) throws CorruptIndexException, IOException { in.deleteDocument(n); } protected void doCommit() throws IOException { in.commit(); }
protected void doDelete(int n) throws CorruptIndexException, IOException { in.deleteDocument(n); } protected void doCommit() throws IOException { in.commit(); }
@Override protected void doDelete(int n) throws CorruptIndexException, IOException { in.deleteDocument(n); }
protected void doDelete(int n) throws CorruptIndexException, IOException { for (int i = 0; i < readers.size(); i++) { ((IndexReader)readers.get(i)).deleteDocument(n); } hasDeletions = true; }
protected void doDelete(int n) throws CorruptIndexException, IOException { for (int i = 0; i < readers.size(); i++) { ((IndexReader)readers.get(i)).deleteDocument(n); } hasDeletions = true; }
protected void doDelete(int n) throws CorruptIndexException, IOException { numDocs = -1; // invalidate cache int i = readerIndex(n); // find segment num subReaders[i].deleteDocument(n - starts[i]); // dispatch to segment reader hasDeletions = true; }
protected void doDelete(int n) throws CorruptIndexException, IOException { numDocs = -1; // invalidate cache int i = readerIndex(n); // find segment num subReaders[i].deleteDocument(n - starts[i]); // dispatch to segment reader hasDeletions = true; }
/** * Deletes the document numbered <code>docNum</code>. * @see IndexReader#deleteDocument(int) * @throws StaleReaderException if the index has changed * since this reader was opened * @throws CorruptIndexException if the index is corrupt * @throws LockObtainFailedException if another writer * has this index open (<code>write.lock</code> could not * be obtained) * @throws IllegalStateException if the index is closed */ public void deleteDocument(int docNum) throws StaleReaderException, CorruptIndexException, LockObtainFailedException, IOException { synchronized(directory) { assureOpen(); createIndexReader(); indexReader.deleteDocument(docNum); } }
/** * Deletes the document numbered <code>docNum</code>. * @see IndexReader#deleteDocument(int) * @throws StaleReaderException if the index has changed * since this reader was opened * @throws CorruptIndexException if the index is corrupt * @throws LockObtainFailedException if another writer * has this index open (<code>write.lock</code> could not * be obtained) * @throws IllegalStateException if the index is closed */ public void deleteDocument(int docNum) throws StaleReaderException, CorruptIndexException, LockObtainFailedException, IOException { synchronized(directory) { assureOpen(); createIndexReader(); indexReader.deleteDocument(docNum); } }
/** * @throws IOException * */ private void deleteFolder(IndexReader reader, IContainer container) throws Exception { IndexSearcher searcher = new IndexSearcher(reader); String path = container.getFullPath().addTrailingSeparator().toString(); TopDocs topDocs = searcher.search(new PrefixQuery(Field.FILE.createTerm(path)), reader.numDocs()); for(ScoreDoc doc: topDocs.scoreDocs) { int docNum = doc.doc; reader.deleteDocument(docNum); } searcher.close(); }
/** * * @param indexReader * @param indexSearcher * @param extendedObjectId * * @return * * @throws IOException * @throws ParseException */ private static int deleteObject(IndexReader indexReader, IndexSearcher indexSearcher, String extendedObjectId) throws IOException, ParseException { QueryParser queryParser = new QueryParser(Version.LUCENE_30, "body", new KeywordAnalyzer()); String queryString = "objectid:\"" + QueryParser.escape(extendedObjectId) + "\""; Query query = queryParser.parse(queryString); TopDocs docs = indexSearcher.search(query, 100000); for (int i = 0; i < docs.totalHits; i++) { indexReader.deleteDocument(docs.scoreDocs[i].doc); } return docs.totalHits; }
protected static Set<String> deleteReference(Collection<String> nodeRefs, IndexReader reader, boolean delete) throws LuceneIndexException { Set<String> refs = new LinkedHashSet<String>(); for (String nodeRef : nodeRefs) { try { TermDocs td = reader.termDocs(new Term("PARENT", nodeRef)); while (td.next()) { int doc = td.doc(); Document document = reader.document(doc); String[] ids = document.getValues("ID"); refs.add(ids[ids.length - 1]); if (delete) { reader.deleteDocument(doc); } } td.close(); } catch (IOException e) { throw new LuceneIndexException("Failed to delete node by parent for " + nodeRef, e); } } return refs; }
protected static Set<String> deletePrimary(Collection<String> nodeRefs, IndexReader reader, boolean delete) throws LuceneIndexException { Set<String> refs = new LinkedHashSet<String>(); for (String nodeRef : nodeRefs) { try { TermDocs td = reader.termDocs(new Term("PRIMARYPARENT", nodeRef)); while (td.next()) { int doc = td.doc(); Document document = reader.document(doc); String[] ids = document.getValues("ID"); refs.add(ids[ids.length - 1]); if (delete) { reader.deleteDocument(doc); } } td.close(); } catch (IOException e) { throw new LuceneIndexException("Failed to delete node by primary parent for " + nodeRef, e); } } return refs; }
protected static Set<String> deleteReference(Collection<String> nodeRefs, IndexReader reader, boolean delete) throws LuceneIndexException { Set<String> refs = new LinkedHashSet<String>(); for (String nodeRef : nodeRefs) { try { TermDocs td = reader.termDocs(new Term("PARENT", nodeRef)); while (td.next()) { int doc = td.doc(); Document document = reader.document(doc); String[] ids = document.getValues("ID"); refs.add(ids[ids.length - 1]); if (delete) { reader.deleteDocument(doc); } } td.close(); } catch (IOException e) { throw new LuceneIndexException("Failed to delete node by parent for " + nodeRef, e); } } return refs; }
protected static Set<String> deletePrimary(Collection<String> nodeRefs, IndexReader reader, boolean delete) throws LuceneIndexException { Set<String> refs = new LinkedHashSet<String>(); for (String nodeRef : nodeRefs) { try { TermDocs td = reader.termDocs(new Term("PRIMARYPARENT", nodeRef)); while (td.next()) { int doc = td.doc(); Document document = reader.document(doc); String[] ids = document.getValues("ID"); refs.add(ids[ids.length - 1]); if (delete) { reader.deleteDocument(doc); } } td.close(); } catch (IOException e) { throw new LuceneIndexException("Failed to delete node by primary parent for " + nodeRef, e); } } return refs; }
try { while (docs.next()) { deleteDocument(docs.doc()); n++;