Java Code Examples for org.apache.lucene.index.IndexReader#indexExists()

private IndexReader buildAndRegisterDeltaReader(String id) throws IOException
{
    IndexReader reader;
    // only register on write to avoid any locking for transactions that only ever read
    File location = getDeltaLocation(id);
    // File location = ensureDeltaIsRegistered(id);
    // Create a dummy index reader to deal with empty indexes and not
    // persist these.
    if (IndexReader.indexExists(location))
    {
        reader = IndexReader.open(location);
    }
    else
    {
        reader = IndexReader.open(emptyIndex);
    }
    return reader;
}
 

private IndexReader buildReferenceCountingIndexReader(String id, long size) throws IOException
{
    IndexReader reader;
    File location = new File(indexDirectory, id).getCanonicalFile();
    double folderSize = getSizeInMb(location);
    if (IndexReader.indexExists(location))
    {
        if ((size < maxDocsForInMemoryIndex) && (folderSize < maxRamInMbForInMemoryIndex))
        {
            RAMDirectory rd = new RAMDirectory(location);
            reader = IndexReader.open(rd);
        }
        else
        {
            reader = IndexReader.open(location);
        }
    }
    else
    {
        reader = IndexReader.open(emptyIndex);
    }
    reader = ReferenceCountingReadOnlyIndexReaderFactory.createReader(id, reader, true, config);
    return reader;
}
 

/**
 * Use a different index as the auto completer index or re-open
 * the existing index if <code>autocompleteIndex</code> is the same value
 * as given in the constructor.
 * @param autocompleteIndexDir the autocomplete directory to use
 * @throws AlreadyClosedException if the Autocompleter is already closed
 * @throws  IOException if autocompleter can not open the directory
 */
// TODO: we should make this final as it is called in the constructor
public void setAutoCompleteIndex(Directory autocompleteIndexDir) throws IOException {
  // this could be the same directory as the current autocompleteIndex
  // modifications to the directory should be synchronized
  synchronized (modifyCurrentIndexLock) {
    ensureOpen();
    if (!IndexReader.indexExists(autocompleteIndexDir)) {
        IndexWriter writer = new IndexWriter(autocompleteIndexDir,
          new IndexWriterConfig(Version.LUCENE_CURRENT,
              new WhitespaceAnalyzer(Version.LUCENE_CURRENT)));
        writer.close();
    }
    swapSearcher(autocompleteIndexDir);
  }
}
 

@Transactional(readOnly = true)
public Integer createIndex(Integer siteId, Integer channelId,
		Date startDate, Date endDate, Integer startId, Integer max,
		Directory dir) throws IOException, ParseException {
	boolean exist = IndexReader.indexExists(dir);
	IndexWriter writer = new IndexWriter(dir, new StandardAnalyzer(
			Version.LUCENE_30), !exist, IndexWriter.MaxFieldLength.LIMITED);
	try {
		if (exist) {
			LuceneContent.delete(siteId, channelId, startDate, endDate,
					writer);
		}
		Integer lastId = luceneContentDao.index(writer, siteId, channelId,
				startDate, endDate, startId, max);
		writer.optimize();
		return lastId;
	} finally {
		writer.close();
	}
}
 

/**
 * Check if index exist.
 * 
 * @return true : Index exists.
 */
private boolean existIndex() throws IOException {
    try {
        final File indexFile = new File(searchModuleConfig.getFullIndexPath());
        final Directory directory = FSDirectory.open(indexFile);
        return IndexReader.indexExists(directory);
    } catch (final IOException e) {
        throw e;
    }
}
 

/**
 * Check if index exist.
 * 
 * @return true : Index exists.
 */
public boolean existIndex() {
    try {
        final File indexFile = new File(indexPath);
        final Directory directory = FSDirectory.open(indexFile);
        return IndexReader.indexExists(directory);
    } catch (final IOException e) {
        log.error("", e);
        return false;
    }
}
 

/**
 * @return <code>true</code> if Lucene index exists.
 */
public boolean existIndex() {
    try {
        final File indexDir = new File(searchModule.getSearchIndexPath());
        final Directory indexLuceneDirectory = FSDirectory.open(indexDir);
        return IndexReader.indexExists(indexLuceneDirectory);
    } catch (final IOException e) {
        return false;
    }
}
 

private void createIndexSearcher(boolean indexNewlyBuilt) {
    try {
        log.info("Create searcher on new index ...");
        Directory searchIndexDirectory = null;
        synchronized (createIndexSearcherLock) {
            closeIndexSearcher();
            if (indexNewlyBuilt) {
                replaceIndexFiles();
            }
            searchIndexDirectory = FSDirectory.open(new File(searchModule.getSearchIndexPath()));
            if (!IndexReader.indexExists(searchIndexDirectory)) {
                log.error("SpellChecker index does not exist [" + searchModule.getSearchIndexPath() + "]");
                return;
            }
            searcher = new IndexSearcher(searchIndexDirectory);
        }

        final long indexTime = IndexReader.getCurrentVersion(searchIndexDirectory);
        if ((System.currentTimeMillis() - indexTime) > maxIndexTime) {
            log.error("Search index is too old [indexDate=" + new Date(indexTime) + "].");
        }

        if (indexNewlyBuilt) {
            log.info("Cleanup old index files ...");
            cleanupIndexFiles();
        }
    } catch (IOException ex) {
        log.error("Searcher couldn't be created.", ex);
    }
}
 

private void createSpellCheckSearcher(boolean indexNewlyBuilt) {
    try {
        log.info("Create spell checker on new index ...");
        synchronized (createSpellCheckSearcherLock) {// o_clusterOK by:pb if service is only configured on one vm, which is recommended way
            closeSpellCheckSearcher();
            if (indexNewlyBuilt) {
                replaceSpellCheckFiles();
            }

            final File spellDictionaryFile = new File(searchModule.getSpellCheckerIndexPath());
            final Directory spellIndexDirectory = FSDirectory.open(spellDictionaryFile);
            if (!IndexReader.indexExists(spellIndexDirectory)) {
                log.error("SpellChecker index does not exist [" + spellDictionaryFile.getAbsolutePath() + "]");
                return;
            }
            spellChecker = new SpellChecker(spellIndexDirectory);
            spellChecker.setAccuracy(0.7f);
        }

        if (indexNewlyBuilt) {
            log.info("Cleanup old spell checker index files ...");
            cleanupSpellCheckFiles();
        }
    } catch (IOException ex) {
        log.error("SpellChecker couldn't be created.", ex);
    }

}
 

@Transactional(readOnly = true)
public void createIndex(Content content, Directory dir) throws IOException {
	boolean exist = IndexReader.indexExists(dir);
	IndexWriter writer = new IndexWriter(dir, new StandardAnalyzer(
			Version.LUCENE_30), !exist, IndexWriter.MaxFieldLength.LIMITED);
	try {
		writer.addDocument(LuceneContent.createDocument(content));
	} finally {
		writer.close();
	}
}
 

@Transactional(readOnly = true)
public void deleteIndex(Integer contentId, Directory dir)
		throws IOException, ParseException {
	boolean exist = IndexReader.indexExists(dir);
	if (exist) {
		IndexWriter writer = new IndexWriter(dir, new StandardAnalyzer(
				Version.LUCENE_30), false,
				IndexWriter.MaxFieldLength.LIMITED);
		try {
			LuceneContent.delete(contentId, writer);
		} finally {
			writer.close();
		}
	}
}
 

public void updateIndex(Content content, Directory dir) throws IOException,
		ParseException {
	boolean exist = IndexReader.indexExists(dir);
	IndexWriter writer = new IndexWriter(dir, new StandardAnalyzer(
			Version.LUCENE_30), !exist, IndexWriter.MaxFieldLength.LIMITED);
	try {
		if (exist) {
			LuceneContent.delete(content.getId(), writer);
		}
		writer.addDocument(LuceneContent.createDocument(content));
	} finally {
		writer.close();
	}
}