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:org.apache.solr.codecs.test.testONSQLWrapperDirectory.java

License:Apache License

public static void deleteDocs(String searchField, String searchString) throws IOException, ParseException {
    System.out.println("deleting docs for '" + searchString + "'");
    IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_4_10_1,
            new StandardAnalyzer(Version.LUCENE_4_10_1));
    config.setOpenMode(IndexWriterConfig.OpenMode.APPEND);
    ONSQLCodec codec = new ONSQLCodec();

    config.setCodec(codec);//w ww .  j  a  v  a  2  s.c  o m
    config.setUseCompoundFile(false);
    Directory luceneDir = new ONSQLWrapperDirectory(new File(INDEX_ROOT_FOLDER));
    IndexWriter writer = new IndexWriter(luceneDir, config);
    QueryParser queryParser = new QueryParser(Version.LUCENE_4_10_1, searchField,
            new StandardAnalyzer(Version.LUCENE_4_10_1));
    Query query = queryParser.parse(searchString);
    writer.deleteDocuments(query);
    writer.commit();
    writer.close();
    luceneDir.close();
    System.out.println("docs were deleted");
}

---

From source file:org.apache.solr.uninverting.TestDocTermOrds.java

License:Apache License

public void testBackToTheFuture() throws Exception {
    Directory dir = newDirectory();/*ww  w.java 2  s .  co  m*/
    IndexWriter iw = new IndexWriter(dir, newIndexWriterConfig(null));

    Document doc = new Document();
    doc.add(newStringField("foo", "bar", Field.Store.NO));
    iw.addDocument(doc);

    doc = new Document();
    doc.add(newStringField("foo", "baz", Field.Store.NO));
    // we need a second value for a doc, or we don't actually test DocTermOrds!
    doc.add(newStringField("foo", "car", Field.Store.NO));
    iw.addDocument(doc);

    DirectoryReader r1 = DirectoryReader.open(iw);

    iw.deleteDocuments(new Term("foo", "baz"));
    DirectoryReader r2 = DirectoryReader.open(iw);

    FieldCache.DEFAULT.getDocTermOrds(getOnlyLeafReader(r2), "foo", null);

    SortedSetDocValues v = FieldCache.DEFAULT.getDocTermOrds(getOnlyLeafReader(r1), "foo", null);
    assertEquals(3, v.getValueCount());
    assertEquals(1, v.advance(1));
    assertEquals(1, v.nextOrd());

    iw.close();
    r1.close();
    r2.close();
    dir.close();
}

---

From source file:org.apache.solr.update.DirectUpdateHandler2.java

License:Apache License

@Override
public int addDoc(AddUpdateCommand cmd) throws IOException {
    int rc = -1;/*from w w  w.j a  va  2 s.c o m*/
    RefCounted<IndexWriter> iw = solrCoreState.getIndexWriter(core);
    try {
        IndexWriter writer = iw.get();
        addCommands.incrementAndGet();
        addCommandsCumulative.incrementAndGet();

        // if there is no ID field, don't overwrite
        if (idField == null) {
            cmd.overwrite = false;
        }

        try {
            IndexSchema schema = cmd.getReq().getSchema();

            if (cmd.overwrite) {

                // Check for delete by query commands newer (i.e. reordered). This
                // should always be null on a leader
                List<UpdateLog.DBQ> deletesAfter = null;
                if (ulog != null && cmd.version > 0) {
                    deletesAfter = ulog.getDBQNewer(cmd.version);
                }

                if (deletesAfter != null) {
                    log.info("Reordered DBQs detected.  Update=" + cmd + " DBQs=" + deletesAfter);
                    List<Query> dbqList = new ArrayList<Query>(deletesAfter.size());
                    for (UpdateLog.DBQ dbq : deletesAfter) {
                        try {
                            DeleteUpdateCommand tmpDel = new DeleteUpdateCommand(cmd.req);
                            tmpDel.query = dbq.q;
                            tmpDel.version = -dbq.version;
                            dbqList.add(getQuery(tmpDel));
                        } catch (Exception e) {
                            log.error("Exception parsing reordered query : " + dbq, e);
                        }
                    }

                    addAndDelete(cmd, dbqList);
                } else {
                    // normal update

                    Term updateTerm;
                    Term idTerm = new Term(cmd.isBlock() ? "_root_" : idField.getName(), cmd.getIndexedId());
                    boolean del = false;
                    if (cmd.updateTerm == null) {
                        updateTerm = idTerm;
                    } else {
                        // this is only used by the dedup update processor
                        del = true;
                        updateTerm = cmd.updateTerm;
                    }

                    if (cmd.isBlock()) {
                        writer.updateDocuments(updateTerm, cmd, schema.getAnalyzer());
                    } else {
                        Document luceneDocument = cmd.getLuceneDocument();
                        // SolrCore.verbose("updateDocument",updateTerm,luceneDocument,writer);
                        writer.updateDocument(updateTerm, luceneDocument, schema.getAnalyzer());
                    }
                    // SolrCore.verbose("updateDocument",updateTerm,"DONE");

                    if (del) { // ensure id remains unique
                        BooleanQuery bq = new BooleanQuery();
                        bq.add(new BooleanClause(new TermQuery(updateTerm), Occur.MUST_NOT));
                        bq.add(new BooleanClause(new TermQuery(idTerm), Occur.MUST));
                        writer.deleteDocuments(bq);
                    }

                    // Add to the transaction log *after* successfully adding to the
                    // index, if there was no error.
                    // This ordering ensures that if we log it, it's definitely been
                    // added to the the index.
                    // This also ensures that if a commit sneaks in-between, that we
                    // know everything in a particular
                    // log version was definitely committed.
                    if (ulog != null)
                        ulog.add(cmd);
                }

            } else {
                // allow duplicates
                if (cmd.isBlock()) {
                    writer.addDocuments(cmd, schema.getAnalyzer());
                } else {
                    writer.addDocument(cmd.getLuceneDocument(), schema.getAnalyzer());
                }

                if (ulog != null)
                    ulog.add(cmd);
            }

            if ((cmd.getFlags() & UpdateCommand.IGNORE_AUTOCOMMIT) == 0) {
                if (commitWithinSoftCommit) {
                    commitTracker.addedDocument(-1);
                    softCommitTracker.addedDocument(cmd.commitWithin);
                } else {
                    softCommitTracker.addedDocument(-1);
                    commitTracker.addedDocument(cmd.commitWithin);
                }
            }

            rc = 1;
        } finally {
            if (rc != 1) {
                numErrors.incrementAndGet();
                numErrorsCumulative.incrementAndGet();
            } else {
                numDocsPending.incrementAndGet();
            }
        }

    } finally {
        iw.decref();
    }

    return rc;
}

---

From source file:org.apache.solr.update.DirectUpdateHandler2.java

License:Apache License

/** Add a document execute the deletes as atomically as possible */
private void addAndDelete(AddUpdateCommand cmd, List<Query> dbqList) throws IOException {
    Document luceneDocument = cmd.getLuceneDocument();
    Term idTerm = new Term(idField.getName(), cmd.getIndexedId());

    // see comment in deleteByQuery
    synchronized (solrCoreState.getUpdateLock()) {
        RefCounted<IndexWriter> iw = solrCoreState.getIndexWriter(core);
        try {/*  www .j  a  v  a  2  s . com*/
            IndexWriter writer = iw.get();
            writer.updateDocument(idTerm, luceneDocument, cmd.getReq().getSchema().getAnalyzer());

            for (Query q : dbqList) {
                writer.deleteDocuments(q);
            }
        } finally {
            iw.decref();
        }

        if (ulog != null)
            ulog.add(cmd, true);
    }

}

---

From source file:org.apache.wiki.search.LuceneSearchProvider.java

License:Apache License

/**
 *  {@inheritDoc}//from   w w w.  j ava2s.  c om
 */
public void pageRemoved(WikiPage page) {
    IndexWriter writer = null;
    try {
        Directory luceneDir = new SimpleFSDirectory(new File(m_luceneDirectory), null);
        writer = getIndexWriter(luceneDir);
        Query query = new TermQuery(new Term(LUCENE_ID, page.getName()));
        writer.deleteDocuments(query);
    } catch (Exception e) {
        log.error("Unable to remove page '" + page.getName() + "' from Lucene index", e);
    } finally {
        close(writer);
    }
}

---

From source file:org.arastreju.sge.spi.impl.LuceneBasedNodeKeyTable.java

License:Apache License

@Override
public void remove(QualifiedName qn) {
    try {/*from w  ww.java 2s.c  om*/
        final IndexWriter writer = writer();
        writer.deleteDocuments(new Term(QN, qn.toURI()));
        writer.commit();
    } catch (IOException e) {
        throw new RuntimeException("Could not remove qualified name from index.", e);
    }
}

---

From source file:org.ariadne_eu.service.MACEImplementation.java

License:Creative Commons License

private void insertIntoLucenewEnrichments(String identifier, String metadata, List keywords,
        List classifications) {// w w  w  .  j a  v  a 2 s  .c  o m
    IndexWriter writer = null;
    try {
        InsertMetadataImpl[] insertImpls = InsertMetadataFactory.getInsertImpl();
        InsertMetadataLuceneImpl luceneImpl = null;
        for (int i = 0; i < insertImpls.length; i++) {
            InsertMetadataImpl insertImpl = insertImpls[i];
            if (insertImpl instanceof InsertMetadataLuceneImpl)
                luceneImpl = (InsertMetadataLuceneImpl) insertImpl;
        }

        if (luceneImpl == null)
            return;

        boolean create = !(IndexReader.indexExists(luceneImpl.getIndexDir()));
        DocumentAnalyzer analyzer = DocumentAnalyzerFactory.getDocumentAnalyzerImpl();
        DocumentHandler handler = HandlerFactory.getDocumentHandlerImpl();
        org.apache.lucene.document.Document doc = null;

        // first delete!
        writer = new IndexWriter(FSDirectory.open(luceneImpl.getIndexDir()), analyzer.getAnalyzer(),
                IndexWriter.MaxFieldLength.UNLIMITED);
        Term term = new Term("key", identifier);
        writer.deleteDocuments(term);
        writer.close();

        // now insert!
        writer = new IndexWriter(FSDirectory.open(luceneImpl.getIndexDir()), analyzer.getAnalyzer(), create,
                IndexWriter.MaxFieldLength.UNLIMITED);

        String insertMetadata = metadata;
        if (metadata.startsWith("<?"))
            insertMetadata = metadata.substring(metadata.indexOf("?>") + 2);

        doc = handler.getDocument(new ByteArrayInputStream(metadata.getBytes("UTF-8")));
        doc.add(new Field("key", identifier, Field.Store.YES, Field.Index.NOT_ANALYZED));
        doc.add(new Field("date.insert", DateTools.dateToString(new Date(), DateTools.Resolution.MILLISECOND),
                Field.Store.YES, Field.Index.NOT_ANALYZED));
        doc.add(new Field("md", insertMetadata, Field.Store.YES, Field.Index.NOT_ANALYZED,
                Field.TermVector.WITH_POSITIONS_OFFSETS));
        doc.add(new Field("lom.solr", "all", Field.Store.YES, Field.Index.NOT_ANALYZED,
                Field.TermVector.WITH_POSITIONS_OFFSETS));

        //keywords
        for (Iterator iterator = keywords.iterator(); iterator.hasNext();) {
            String keyword = (String) iterator.next();
            doc.add(new Field("lom.general.keyword.string", keyword, Field.Store.YES, Field.Index.ANALYZED,
                    Field.TermVector.WITH_POSITIONS_OFFSETS));
            doc.add(new Field("contents", keyword, Field.Store.YES, Field.Index.ANALYZED,
                    Field.TermVector.WITH_POSITIONS_OFFSETS));
        }

        //classifications
        for (Iterator iterator = classifications.iterator(); iterator.hasNext();) {
            List classification = (List) iterator.next();
            doc.add(new Field("lom.classification.taxonPath.taxon.id", (String) classification.get(0),
                    Field.Store.YES, Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS));
            doc.add(new Field("lom.classification.taxonPath.taxon.entry.string", (String) classification.get(1),
                    Field.Store.YES, Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS));
            doc.add(new Field("contents", (String) classification.get(0), Field.Store.YES, Field.Index.ANALYZED,
                    Field.TermVector.WITH_POSITIONS_OFFSETS));
            doc.add(new Field("contents", (String) classification.get(1), Field.Store.YES, Field.Index.ANALYZED,
                    Field.TermVector.WITH_POSITIONS_OFFSETS));
        }

        String luceneHandler = PropertiesManager.getInstance()
                .getProperty(RepositoryConstants.getInstance().SR_LUCENE_HANDLER);
        if (luceneHandler.equalsIgnoreCase("org.ariadne_eu.metadata.insert.lucene.document.MACELOMHandler")) {
            MACEUtils.getClassification();
            String exml = MACEUtils.enrichWClassification(insertMetadata);
            exml = exml.substring(38);
            doc.add(new Field("maceenrichedlom", exml, Field.Store.YES, Field.Index.NOT_ANALYZED,
                    Field.TermVector.WITH_POSITIONS_OFFSETS));
        }
        writer.addDocument(doc);

    } catch (DocumentHandlerException e) {
        log.error("insertIntoLucenewEnrichments:", e);
    } catch (CorruptIndexException e) {
        log.error("insertIntoLucenewEnrichments:", e);
    } catch (LockObtainFailedException e) {
        log.error("insertIntoLucenewEnrichments:", e);
    } catch (IOException e) {
        log.error("insertIntoLucenewEnrichments:", e);
    } finally {
        try {
            writer.close();
        } catch (CorruptIndexException e) {
            log.error("insertIntoLucenewEnrichments:", e);
        } catch (IOException e) {
            log.error("insertIntoLucenewEnrichments:", e);
        }
    }

}

---

From source file:org.chenillekit.lucene.services.impl.IndexerServiceImpl.java

License:Apache License

/**
  * delete documents by the given field name and the query.
  *//from   w w w.  j  a v a  2s .co  m
  * @param field       name of the field
  * @param queryString
  */
public void delDocuments(String field, String queryString) {
    try {
        IndexWriter indexWriter = indexSource.getIndexWriter();
        indexWriter.deleteDocuments(new Term(field, queryString));
    } catch (IOException ioe) {
        this.logger.error(String.format("Unable to access the index for deleting docs: '%s'", ioe.getMessage()),
                ioe);
        throw new ChenilleKitLuceneRuntimeException(ioe);
    }
}

---

From source file:org.codesearch.commons.configuration.IndexCleaner.java

License:Open Source License

public void cleanIndex() throws InvalidConfigurationException {
    // delete all lucene documents and database information associated to a repository that exists in the configuration
    // in case the repository configuraiton has changed since the last startup
    Directory indexDirectory;/*w  ww .  ja  v  a  2  s .  c  o m*/
    IndexWriter indexWriter = null;
    try {
        indexDirectory = FSDirectory.open(configReader.getIndexLocation());
        Analyzer analyzer = new StandardAnalyzer(IndexConstants.LUCENE_VERSION);
        IndexWriterConfig config = new IndexWriterConfig(IndexConstants.LUCENE_VERSION, analyzer);
        indexWriter = new IndexWriter(indexDirectory, config);

        List<String> invalidRepositories = indexStatusManager.getAllSavedRepositoryNames();

        BooleanQuery query = new BooleanQuery();
        for (RepositoryDto repository : configReader.getRepositories()) {
            invalidRepositories.remove(repository.getName());
        }
        for (String invalidRepo : invalidRepositories) {
            dbAccess.deleteRepository(invalidRepo);
            if (!indexStatusManager.getStatus(invalidRepo).equals(VersionControlPlugin.UNDEFINED_VERSION)) {
                Query q = new TermQuery(new Term("repository", invalidRepo));
                query.add(q, BooleanClause.Occur.SHOULD);
                indexStatusManager.setStatus(invalidRepo, VersionControlPlugin.UNDEFINED_VERSION);
            }
        }

        int countDocuments = indexWriter.maxDoc();
        indexWriter.deleteDocuments(query);
        indexWriter.commit();
        int countDeleted = countDocuments - indexWriter.maxDoc();
        if (countDeleted > 0) {
            LOG.info("Deleted " + countDeleted
                    + " documents from the Index since they belonged to repositories that were no longer found in the configuration.");
        }
    } catch (DatabaseAccessException ex) {
        throw new InvalidConfigurationException("Could not clean analysis data for unused repository" + ex);
    } catch (IOException ex) {
        throw new InvalidConfigurationException(
                "Index can not be opened for writing at: " + configReader.getIndexLocation() + "\n" + ex);
    } finally {
        try {
            indexWriter.close();
        } catch (IOException ex) {
            LOG.error("Unable to close IndexWriter after cleaning up Lucene index\n" + ex);
        }
    }
}

---

From source file:org.compass.core.lucene.engine.transaction.readcommitted.ReadCommittedTransactionProcessor.java

License:Apache License

@Override
protected void doProcessJob(TransactionJob job) throws SearchEngineException {
    try {//from   ww w.  j  a v  a  2 s .c om
        IndexWriter indexWriter = openIndexWriterIfNeeded(job.getSubIndex());
        if (job instanceof DeleteTransactionJob) {
            DeleteTransactionJob deleteJob = (DeleteTransactionJob) job;
            markDeleted(deleteJob.getResourceKey());
            // delete from the original index (autoCommit is false, so won't be committed)
            job.execute(indexWriter, searchEngineFactory);
            transIndexManager.processJob(job);
        } else if (job instanceof DeleteByQueryTransactionJob) {
            job.execute(indexWriter, searchEngineFactory);
            transIndexManager.processJob(job);
        } else if (job instanceof UpdateTransactionJob) {
            UpdateTransactionJob updateJob = (UpdateTransactionJob) job;
            Term deleteTerm = markDeleted(updateJob.getResource().getResourceKey());
            // delete from the original index (autoCommit is false, so won't be committed
            indexWriter.deleteDocuments(deleteTerm);
            transIndexManager.processJob(job);
        } else if (job instanceof FlushCommitTransactionJob) {
            if (transIndexManager.hasTransIndex(job.getSubIndex())) {
                transIndexManager.commit(job.getSubIndex());
                Directory transDir = transIndexManager.getDirectory(job.getSubIndex());
                indexWriter.addIndexesNoOptimize(new Directory[] { transDir });
                transIndexManager.close(job.getSubIndex());
            }
            indexWriter.commit();
        } else {
            // Create job
            transIndexManager.processJob(job);
        }
    } catch (Exception e) {
        throw new SearchEngineException("Failed to process job [" + job + "]", e);
    }
}

---

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