How to use

close

method

in

org.apache.lucene.index.IndexWriter

final IndexWriter writer = new IndexWriter(directory, config);
for (Stop stop : graphIndex.stopForId.values()) {
  addStop(writer, stop);
  addCorner(writer, sv);
writer.close();
long elapsedTime = System.currentTimeMillis() - startTime;
LOG.info("Built Lucene index in {} msec", elapsedTime);

conf.setOpenMode(OpenMode.CREATE_OR_APPEND);
wrt = new IndexWriter(indexDirectory, conf);
wrt.forceMerge(1); // this is deprecated and not needed anymore
elapsed.report(LOGGER, String.format("Done optimizing index%s", projectDetail));
if (wrt != null) {
  try {
    wrt.close();
  } catch (IOException e) {
    if (writerException == null) {

IndexWriterConfig iwc = new IndexWriterConfig(Version.LUCENE_47, analyzer);
iwc.setOpenMode(OpenMode.CREATE_OR_APPEND);
IndexWriter writer = new IndexWriter(dir, iwc);
writer.close();

writer = new IndexWriter(indexDirectory, iwc);
try {
  if (writer != null) {
    writer.close();

public void addCorpora(List<Path> corpora, double ramBufferInMb) throws IOException {
 Directory dir = FSDirectory.open(indexPath);
 Analyzer analyzer = CustomAnalyzer.builder()
   .withTokenizer("standard")
   .addTokenFilter(LuceneLemmaFilter.Factory.class)
   .build();
 IndexWriterConfig iwc = new IndexWriterConfig(analyzer);
 iwc.setOpenMode(OpenMode.CREATE_OR_APPEND);
 iwc.setRAMBufferSizeMB(ramBufferInMb);
 IndexWriter writer = new IndexWriter(dir, iwc);
 for (Path path : corpora) {
  Log.info("Adding %s", path);
  addDocs(writer, path);
 }
 writer.close();
}

w.close();
IndexWriterConfig indexWriterConfig = new IndexWriterConfig(analyzer);
LogDocMergePolicy logDocMergePolicy = new LogDocMergePolicy();
logDocMergePolicy.setMergeFactor(1000);
indexWriterConfig.setMergePolicy(logDocMergePolicy);
w = new IndexWriter(index, indexWriterConfig);

IndexWriter writer = new IndexWriter(store.directory(), new IndexWriterConfig(null)
  .setSoftDeletesField(Lucene.SOFT_DELETES_FIELD)
  .setOpenMode(IndexWriterConfig.OpenMode.CREATE)
  .setCommitOnClose(true));
writer.close();
return;

  /**
   * Removes all terms from the spell check index.
   * @throws IOException
   */
  public void clearIndex() throws IOException {
   IndexWriter writer = new IndexWriter(spellIndex, null, true);
   writer.close();

    // COMASS: Remove closing the searcher
   //close the old searcher
//      searcher.close();
//      searcher = new IndexSearcher(this.spellIndex);
  }

public void crawlerFinished() {
  try {
    tempWriter.close();
    IndexWriter indexWriter = new IndexWriter(indexDir, null, true);
    indexWriter.addIndexes(new Directory[] { tempIndexDir });
    indexWriter.close();
  }
  catch (IOException e) {
    log.error("Error", e);
  }
  tempWriter = null;
}

private boolean optimizeIndex() {
  boolean result = false;
  try {
    IndexWriter indexWriter = new IndexWriter(directory, analyzer, false, IndexWriter.MaxFieldLength.UNLIMITED);
    indexWriter.optimize();
    indexWriter.close();
    result = true;
  } catch (IOException e) {
    //logger.error("Error while trying to optimize index.");
  }
  return result;
}

@Override
public synchronized void clearAllIndexes() {
  try {
    // init index writer config
    IndexWriterConfig indexWriterConfig = new IndexWriterConfig(this.analyzer);
    // create new index writer
    IndexWriter iWriter = new IndexWriter(directory, indexWriterConfig);
    iWriter.deleteAll();
    iWriter.close();
  } catch (Exception e) {
    logger.warn("Error while deleting all entries", e);
  }
}

/**
 * Ensures the index directory exists, contains a Lucene index, and is available
 * for writing.
 */
private void ensureIndexExists(Directory directory) throws IOException {
  indexWriteLock.lock();
  try {
    if (!DirectoryReader.indexExists(directory)) {
      new IndexWriter(directory, new IndexWriterConfig(BonnieConstants.LUCENE_VERSION, null)).close();
    }
  } finally {
    indexWriteLock.unlock();
  }
}

private static void upgradeIndexIfNecessary(File directoryPath, Directory directory) throws IOException {
  try {
    new IndexWriter(directory, new IndexWriterConfig(BonnieConstants.LUCENE_VERSION, null)).close();
  } catch (IndexFormatTooOldException e) {
    log.info("Detected old index format. Attempting an upgrade.");
    upgradeIndexToLucene36(directoryPath);
    upgradeIndexToCurrentLuceneVersion(directory);
  }
}

public synchronized void createIndex(String subContext, String subIndex) throws SearchEngineException {
  Directory dir = openDirectory(subContext, subIndex);
  try {
    IndexWriter indexWriter = new IndexWriter(dir, new StandardAnalyzer(), true);
    indexWriter.close();
  } catch (IOException e) {
    throw new SearchEngineException("Failed to create index for sub index [" + subIndex + "]", e);
  }
}

/**
 * create a lucene RAMDirectory from a list of BroadcastDocumentObject
 */
static RAMDirectory createRamDirectoryFromDocuments(List<BroadcastDocumentObject> dictionaryObject) throws IOException {
  RAMDirectory ramDirectory = new RAMDirectory();
  IndexWriterConfig writerConfig = new IndexWriterConfig(Version.LATEST, new StandardAnalyzer(CharArraySet.EMPTY_SET));
  IndexWriter writer = new IndexWriter(ramDirectory, writerConfig);
  for (BroadcastDocumentObject objectDoc : dictionaryObject) {
    writer.addDocument(BroadcastUtils.createLuceneDocumentFromObject(objectDoc));
  }
  writer.commit();
  writer.close();
  return ramDirectory;
}

/**
 * Add object to Lucene index
 */
public void add(Document lucDoc, String id) throws IOException {
  synchronized (directory) {
    IndexWriter writer = new IndexWriter(directory, new SimpleAnalyzer(), !segmentFile.exists());
    try {
      writer.addDocument(lucDoc);
    } finally {
      writer.close();
    }
  }
}

  public static void main(String[] args) {
    String index = args[0];
    try {
      IndexWriter i = new IndexWriter(FSDirectory.open(new File(index)), new WhitespaceAnalyzer(), IndexWriter.MaxFieldLength.LIMITED);
      i.optimize();
      i.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

private void postInit()
  throws IOException
{
  this.queryAnalyzer = new StandardAnalyzer();
  // do some initialization for new indices
  if (!DirectoryReader.indexExists(directory)) {
    logger.debug("creating new Lucene index in directory {}", directory);
    IndexWriterConfig indexWriterConfig = getIndexWriterConfig();
    indexWriterConfig.setOpenMode(OpenMode.CREATE);
    IndexWriter writer = new IndexWriter(directory, indexWriterConfig);
    writer.close();
  }
}

  private static synchronized void create() throws IOException {
    if (directory != null) {
      return;
    }
    final RAMDirectory ram = new RAMDirectory();
    IndexWriter w = new IndexWriter(ram, Factory.get().writerConfig());
    w.commit();
    w.close();
    directory = ram;
  }
}

public static Directory getCleanRAMDirectory()
{
  try
  {
    final Directory directory = new RAMDirectory();
    IndexWriterConfig conf = new IndexWriterConfig(LuceneVersion.get(), new StandardAnalyzer(LuceneVersion.get()));
    conf.setOpenMode(IndexWriterConfig.OpenMode.CREATE);
    new IndexWriter(directory, conf).close();
    return directory;
  }
  catch (final IOException e)
  {
    throw new RuntimeException(e);
  }
}