Example usage for org.apache.lucene.index IndexWriter deleteDocuments

Introduction

In this page you can find the example usage for org.apache.lucene.index IndexWriter deleteDocuments.

Prototype

public long deleteDocuments(Query... queries) throws IOException 

Source Link

Document

Deletes the document(s) matching any of the provided queries.

Usage

From source file:com.vmware.xenon.services.common.LuceneDocumentIndexService.java

License:Open Source License

/**
 * Deletes all indexed documents with range of deleteCount,indexed with the specified self link
 *
 * @throws Throwable//from w w w.  ja  v  a2s .  c  o  m
 */
private void deleteDocumentsFromIndex(Operation delete, String link, long versionsToKeep) throws Throwable {
    IndexWriter wr = this.writer;
    if (wr == null) {
        delete.fail(new CancellationException());
        return;
    }

    Query linkQuery = new TermQuery(new Term(ServiceDocument.FIELD_NAME_SELF_LINK, link));

    IndexSearcher s = updateSearcher(link, Integer.MAX_VALUE, wr);
    if (s == null) {
        delete.fail(new CancellationException());
        return;
    }

    TopDocs results;

    results = s.search(linkQuery, Integer.MAX_VALUE, this.versionSort, false, false);
    if (results == null) {
        return;
    }

    ScoreDoc[] hits = results.scoreDocs;

    if (hits == null || hits.length == 0) {
        return;
    }

    Document hitDoc;

    if (versionsToKeep == 0) {
        // we are asked to delete everything, no need to sort or query
        wr.deleteDocuments(linkQuery);
        this.indexUpdateTimeMicros = Utils.getNowMicrosUtc();
        delete.complete();
        return;
    }

    int versionCount = hits.length;

    hitDoc = s.doc(hits[versionCount - 1].doc);
    long versionLowerBound = Long.parseLong(hitDoc.get(ServiceDocument.FIELD_NAME_VERSION));

    hitDoc = s.doc(hits[0].doc);
    long versionUpperBound = Long.parseLong(hitDoc.get(ServiceDocument.FIELD_NAME_VERSION));

    // If the number of versions found are already less than the limit
    // then there is nothing to delete. Just exit.
    if (versionCount <= versionsToKeep) {
        return;
    }

    BooleanQuery.Builder builder = new BooleanQuery.Builder();

    // grab the document at the tail of the results, and use it to form a new query
    // that will delete all documents from that document up to the version at the
    // retention limit
    hitDoc = s.doc(hits[(int) versionsToKeep].doc);
    long cutOffVersion = Long.parseLong(hitDoc.get(ServiceDocument.FIELD_NAME_VERSION));

    Query versionQuery = LongPoint.newRangeQuery(ServiceDocument.FIELD_NAME_VERSION, versionLowerBound,
            cutOffVersion);

    builder.add(versionQuery, Occur.MUST);
    builder.add(linkQuery, Occur.MUST);
    BooleanQuery bq = builder.build();

    results = s.search(bq, Integer.MAX_VALUE);

    logInfo("Version grooming for %s found %d versions from %d to %d. Trimming %d versions from %d to %d", link,
            versionCount, versionLowerBound, versionUpperBound, results.scoreDocs.length, versionLowerBound,
            cutOffVersion);

    wr.deleteDocuments(bq);

    // We have observed that sometimes Lucene search does not return all the document
    // versions in the index. Normally, the number of documents returned should be
    // equal to or more than the delta between the lower and upper versions. It can be more
    // because of duplicate document versions. If that's not the case, we add the
    // link back for retention so that the next grooming run can cleanup the missed document.
    if (versionCount < versionUpperBound - versionLowerBound + 1) {
        logWarning(
                "Adding %s back for version grooming since versionCount %d "
                        + "was lower than version delta from %d to %d.",
                link, versionCount, versionLowerBound, versionUpperBound);
        synchronized (this.linkDocumentRetentionEstimates) {
            this.linkDocumentRetentionEstimates.put(link, versionsToKeep);
        }
    }

    long now = Utils.getNowMicrosUtc();

    // Use time AFTER index was updated to be sure that it can be compared
    // against the time the searcher was updated and have this change
    // be reflected in the new searcher. If the start time would be used,
    // it is possible to race with updating the searcher and NOT have this
    // change be reflected in the searcher.
    updateLinkAccessTime(now, link);

    delete.complete();
}

---

From source file:com.vnet.demo.service.lucene.LuceneService.java

License:Apache License

public void deleteDoc(DocumentData documentData) {
    IndexWriterConfig config = new IndexWriterConfig(version, analyzer);
    IndexWriter write = null;
    try {//  w w  w  .j a  va  2s.  co  m
        write = new IndexWriter(index, config);
        write.deleteDocuments(new Term("id", documentData.getId().toString()));
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        IOUtils.closeQuietly(write);
    }
}

---

From source file:com.xpn.xwiki.plugin.lucene.internal.IndexRebuilder.java

License:Open Source License

public synchronized int startIndex(Collection<String> wikis, String hqlFilter, boolean clearIndex,
        boolean onlyNew, XWikiContext context) {
    if (this.rebuildInProgress) {
        LOGGER.warn("Cannot launch rebuild because another rebuild is in progress");

        return LucenePluginApi.REBUILD_IN_PROGRESS;
    } else {//from  w ww.  java2  s  . c o  m
        if (clearIndex) {
            if (wikis == null) {
                this.indexUpdater.cleanIndex();
            } else {
                try {
                    IndexWriter writer = this.indexUpdater.openWriter(false);
                    try {
                        for (String wiki : wikis) {
                            writer.deleteDocuments(new Term(IndexFields.DOCUMENT_WIKI, wiki));
                        }
                    } finally {
                        writer.close();
                    }
                } catch (IOException ex) {
                    LOGGER.warn("Failed to clean wiki index: {}", ex.getMessage());
                }
            }
        }

        this.wikis = wikis != null ? new ArrayList<String>(wikis) : null;
        this.hqlFilter = hqlFilter;
        this.onlyNew = onlyNew;
        this.rebuildInProgress = true;

        Thread indexRebuilderThread = new Thread(this, "Lucene Index Rebuilder");
        // The JVM should be allowed to shutdown while this thread is running
        indexRebuilderThread.setDaemon(true);
        // Client requests are more important than indexing
        indexRebuilderThread.setPriority(3);
        // Finally, start the rebuild in the background
        indexRebuilderThread.start();

        // Too bad that now we can't tell how many items are there to be indexed...
        return 0;
    }
}

---

From source file:com.xpn.xwiki.plugin.lucene.internal.IndexUpdater.java

License:Open Source License

private void removeFromIndex(IndexWriter writer, AbstractIndexData data, XWikiContext context)
        throws CorruptIndexException, IOException {
    LOGGER.debug("removeFromIndex: [{}]", data);

    writer.deleteDocuments(data.getTerm());
}

---

From source file:de.berlios.jhelpdesk.utils.LuceneIndexer.java

License:Open Source License

public synchronized void removeIndexedArticle(Long articleId) {
    IndexWriter indexWriter = null;
    try {//ww  w . j av a  2s.  c  o m
        indexWriter = getIndexWriter();
        indexWriter.deleteDocuments(new Term("id", String.valueOf(articleId)));
        indexWriter.commit();
    } catch (Exception ex) {
        log.error(ex.getMessage(), ex);
        throw new RuntimeException(ex);
    } finally {
        closeWriter(indexWriter);
    }
}

---

From source file:de.cosmocode.lucene.LuceneQueryTest.java

License:Apache License

/**
 * Cleans the index up again, to ensure an empty lucene index in the next test.
 * @throws IOException if cleaning the index failed
 * @throws ParseException should not happen
 *//*from  w  w w . ja v a 2 s .co  m*/
@AfterClass
public static void cleanLuceneIndex() throws IOException, ParseException {
    final IndexWriter writer = IndexHelper.createIndexWriter();
    writer.deleteDocuments(IndexHelper.createQueryParser().parse("+empty:empty"));
    writer.close();
}

---

From source file:de.elbe5.cms.search.SearchBean.java

License:Open Source License

public void deleteItem(int id, String dataType) {
    IndexWriter writer = null;
    try {//from  w w w  . j ava  2s  . c  om
        switch (dataType) {
        case SiteSearchData.TYPE:
        case PageSearchData.TYPE:
        case FileSearchData.TYPE: {
            writer = openContentIndexWriter(false);
        }
            break;
        case UserSearchData.TYPE: {
            writer = openUserIndexWriter(false);
        }
            break;
        }
        assert (writer != null);
        writer.deleteDocuments(SearchData.getTerm(id));
        writer.close();
    } catch (Exception e) {
        Log.error("error deleting item", e);
    }
}

---

From source file:de.hybris.platform.lucenesearch.jalo.LuceneTest.java

License:Open Source License

@Test
public void testReindex() throws IOException {
    assertTermSearch(set(docA, docB, docC), "text");

    final IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_40,
            new StandardAnalyzer(Version.LUCENE_40)).setOpenMode(OpenMode.APPEND);
    final IndexWriter changewriter = new IndexWriter(directory, indexWriterConfig);

    changewriter.deleteDocuments(new Term("key", "b"));

    final Document docB2 = new Document();
    docB2.add(new Field("key", "b", Field.Store.YES, Field.Index.NOT_ANALYZED));
    docB2.add(new Field("text", "neuer texxxt zum zweiten document", Field.Store.YES, Field.Index.ANALYZED));
    changewriter.addDocument(docB2);// ww  w .ja  v a  2 s  .co  m
    changewriter.close();
    assertTermSearch(set(docA, docB2, docC), "zum");
    assertTermSearch(set(docA, docC), "text");
    assertTermSearch(set(docB2), "texxxt");
}

---

From source file:de.ingrid.interfaces.csw.index.impl.IngridGeoTKLuceneIndexer.java

License:EUPL

/**
 * This method remove documents identified by query from the index.
 * /*from  ww  w .  j  a  v a  2  s . c  om*/
 * @param query
 * @throws ParseException
 */
public List<String> removeDocumentByQuery(final String queryString) throws ParseException {
    List<String> deletedRecords = new ArrayList<String>();
    try {
        final QueryParser parser = new QueryParser(Version.LUCENE_36, "anytext", analyzer);

        Query query = parser.parse(queryString);

        final IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_36, analyzer);
        final IndexWriter writer = new IndexWriter(LuceneUtils.getAppropriateDirectory(getFileDirectory()),
                config);

        LOGGER.log(logLevel, "Query:{0}", query);

        IndexReader reader = IndexReader.open(writer, false);
        IndexSearcher searcher = new IndexSearcher(reader);
        TopDocs docs = searcher.search(query, Integer.MAX_VALUE);
        for (ScoreDoc doc : docs.scoreDocs) {
            deletedRecords.add(reader.document(doc.doc).get("id"));
        }
        writer.deleteDocuments(query);

        writer.commit();
        searcher.close();
        reader.close();
        writer.close();

    } catch (CorruptIndexException ex) {
        LOGGER.log(Level.WARNING, "CorruptIndexException while indexing document: " + ex.getMessage(), ex);
    } catch (IOException ex) {
        LOGGER.log(Level.WARNING, "IOException while indexing document: " + ex.getMessage(), ex);
    }
    return deletedRecords;
}

---

From source file:de.ks.flatadocdb.index.LuceneIndex.java

License:Apache License

protected void deleteEntry(SessionEntry sessionEntry, IndexWriter writer) throws IOException {
    writer.deleteDocuments(new Term(StandardLuceneFields.ID.name(), sessionEntry.getId()));
}

---

• «
• 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
• »