Index: solr/core/src/test/org/apache/solr/core/TestSolrDeletionPolicy1.java =================================================================== --- solr/core/src/test/org/apache/solr/core/TestSolrDeletionPolicy1.java (revision 1197316) +++ solr/core/src/test/org/apache/solr/core/TestSolrDeletionPolicy1.java (working copy) @@ -95,7 +95,7 @@ for (Long version : commits.keySet()) { if (commits.get(version) == latest) continue; - assertTrue(commits.get(version).isOptimized()); + assertEquals(1, commits.get(version).getSegmentCount()); } } Index: solr/core/src/test/org/apache/solr/search/TestRealTimeGet.java =================================================================== --- solr/core/src/test/org/apache/solr/search/TestRealTimeGet.java (revision 1197316) +++ solr/core/src/test/org/apache/solr/search/TestRealTimeGet.java (working copy) @@ -448,7 +448,7 @@ Directory dir = newDirectory(); final RandomIndexWriter writer = new RandomIndexWriter(random, dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random))); - writer.setDoRandomOptimizeAssert(false); + writer.setDoRandomMergeIfNeededAssert(false); writer.w.setInfoStream(VERBOSE ? System.out : null); writer.w.setInfoStream(null); Index: solr/core/src/test/org/apache/solr/spelling/IndexBasedSpellCheckerTest.java =================================================================== --- solr/core/src/test/org/apache/solr/spelling/IndexBasedSpellCheckerTest.java (revision 1197316) +++ solr/core/src/test/org/apache/solr/spelling/IndexBasedSpellCheckerTest.java (working copy) @@ -293,7 +293,7 @@ doc.add(new Field("title", ALT_DOCS[i], TextField.TYPE_STORED)); iw.addDocument(doc); } - iw.optimize(); + iw.mergeIfNeeded(1); iw.close(); dir.close(); indexDir.mkdirs(); Index: solr/core/src/java/org/apache/solr/update/DirectUpdateHandler2.java =================================================================== --- solr/core/src/java/org/apache/solr/update/DirectUpdateHandler2.java (revision 1197316) +++ solr/core/src/java/org/apache/solr/update/DirectUpdateHandler2.java (working copy) @@ -312,7 +312,7 @@ log.info("start "+cmd); if (cmd.optimize) { - writer.optimize(cmd.maxOptimizeSegments); + writer.mergeIfNeeded(cmd.maxOptimizeSegments); } else if (cmd.expungeDeletes) { writer.expungeDeletes(); } Index: solr/core/src/java/org/apache/solr/core/IndexDeletionPolicyWrapper.java =================================================================== --- solr/core/src/java/org/apache/solr/core/IndexDeletionPolicyWrapper.java (revision 1197316) +++ solr/core/src/java/org/apache/solr/core/IndexDeletionPolicyWrapper.java (working copy) @@ -173,8 +173,8 @@ } @Override - public boolean isOptimized() { - return delegate.isOptimized(); + public int getSegmentCount() { + return delegate.getSegmentCount(); } @Override Index: solr/core/src/java/org/apache/solr/core/SolrDeletionPolicy.java =================================================================== --- solr/core/src/java/org/apache/solr/core/SolrDeletionPolicy.java (revision 1197316) +++ solr/core/src/java/org/apache/solr/core/SolrDeletionPolicy.java (working copy) @@ -135,7 +135,7 @@ IndexCommit newest = commits.get(commits.size() - 1); log.info("newest commit = " + newest.getVersion()); - int optimizedKept = newest.isOptimized() ? 1 : 0; + int singleSegKept = (newest.getSegmentCount() == 1) ? 1 : 0; int totalKept = 1; // work our way from newest to oldest, skipping the first since we always want to keep it. @@ -158,9 +158,9 @@ log.warn("Exception while checking commit point's age for deletion", e); } - if (optimizedKept < maxOptimizedCommitsToKeep && commit.isOptimized()) { + if (singleSegKept < maxOptimizedCommitsToKeep && commit.getSegmentCount() == 1) { totalKept++; - optimizedKept++; + singleSegKept++; continue; } Index: solr/core/src/java/org/apache/solr/handler/ReplicationHandler.java =================================================================== --- solr/core/src/java/org/apache/solr/handler/ReplicationHandler.java (revision 1197316) +++ solr/core/src/java/org/apache/solr/handler/ReplicationHandler.java (working copy) @@ -758,7 +758,7 @@ void refreshCommitpoint() { IndexCommit commitPoint = core.getDeletionPolicy().getLatestCommit(); - if(replicateOnCommit || (replicateOnOptimize && commitPoint.isOptimized())) { + if(replicateOnCommit || (replicateOnOptimize && commitPoint.getSegmentCount() == 1)) { indexCommitPoint = commitPoint; } } @@ -827,7 +827,7 @@ if(replicateOnOptimize){ Collection commits = IndexReader.listCommits(reader.directory()); for (IndexCommit ic : commits) { - if(ic.isOptimized()){ + if(ic.getSegmentCount() == 1){ if(indexCommitPoint == null || indexCommitPoint.getVersion() < ic.getVersion()) indexCommitPoint = ic; } } Index: solr/core/src/java/org/apache/solr/handler/admin/LukeRequestHandler.java =================================================================== --- solr/core/src/java/org/apache/solr/handler/admin/LukeRequestHandler.java (revision 1197316) +++ solr/core/src/java/org/apache/solr/handler/admin/LukeRequestHandler.java (working copy) @@ -492,7 +492,7 @@ } indexInfo.add("version", reader.getVersion()); // TODO? Is this different then: IndexReader.getCurrentVersion( dir )? - indexInfo.add("optimized", reader.isOptimized() ); + indexInfo.add("segmentCount", reader.getSequentialSubReaders().length); indexInfo.add("current", reader.isCurrent() ); indexInfo.add("hasDeletions", reader.hasDeletions() ); indexInfo.add("directory", dir ); Index: solr/core/src/java/org/apache/solr/handler/component/SpellCheckComponent.java =================================================================== --- solr/core/src/java/org/apache/solr/handler/component/SpellCheckComponent.java (revision 1197316) +++ solr/core/src/java/org/apache/solr/handler/component/SpellCheckComponent.java (working copy) @@ -685,7 +685,7 @@ if (buildOnCommit) { buildSpellIndex(newSearcher); } else if (buildOnOptimize) { - if (newSearcher.getIndexReader().isOptimized()) { + if (newSearcher.getIndexReader().getSequentialSubReaders().length == 1) { buildSpellIndex(newSearcher); } else { LOG.info("Index is not optimized therefore skipping building spell check index for: " + checker.getDictionaryName()); Index: solr/core/src/java/org/apache/solr/spelling/FileBasedSpellChecker.java =================================================================== --- solr/core/src/java/org/apache/solr/spelling/FileBasedSpellChecker.java (revision 1197316) +++ solr/core/src/java/org/apache/solr/spelling/FileBasedSpellChecker.java (working copy) @@ -103,7 +103,7 @@ d.add(new TextField(WORD_FIELD_NAME, s)); writer.addDocument(d); } - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); dictionary = new HighFrequencyDictionary(IndexReader.open(ramDir), Index: modules/suggest/src/java/org/apache/lucene/search/spell/SpellChecker.java =================================================================== --- modules/suggest/src/java/org/apache/lucene/search/spell/SpellChecker.java (revision 1197316) +++ modules/suggest/src/java/org/apache/lucene/search/spell/SpellChecker.java (working copy) @@ -481,11 +481,11 @@ * @param dict Dictionary to index * @param mergeFactor mergeFactor to use when indexing * @param ramMB the max amount or memory in MB to use - * @param optimize whether or not the spellcheck index should be optimized + * @param fullMerge whether or not the spellcheck index should be fully merged * @throws AlreadyClosedException if the Spellchecker is already closed * @throws IOException */ - public final void indexDictionary(Dictionary dict, int mergeFactor, int ramMB, boolean optimize) throws IOException { + public final void indexDictionary(Dictionary dict, int mergeFactor, int ramMB, boolean fullMerge) throws IOException { synchronized (modifyCurrentIndexLock) { ensureOpen(); final Directory dir = this.spellIndex; @@ -537,8 +537,8 @@ releaseSearcher(indexSearcher); } // close writer - if (optimize) - writer.optimize(); + if (fullMerge) + writer.mergeIfNeeded(1); writer.close(); // also re-open the spell index to see our own changes when the next suggestion // is fetched: Index: lucene/contrib/demo/src/java/org/apache/lucene/demo/IndexFiles.java =================================================================== --- lucene/contrib/demo/src/java/org/apache/lucene/demo/IndexFiles.java (revision 1197316) +++ lucene/contrib/demo/src/java/org/apache/lucene/demo/IndexFiles.java (working copy) @@ -109,12 +109,12 @@ indexDocs(writer, docDir); // NOTE: if you want to maximize search performance, - // you can optionally call optimize here. This can be - // a costly operation, so generally it's only worth - // it when your index is relatively static (ie you're - // done adding documents to it): + // you can optionally call mergeIfNeeded here. This can be + // a terribly costly operation, so generally it's only + // worth it when your index is relatively static (ie + // you're done adding documents to it): // - // writer.optimize(); + // writer.mergeIfNeeded(1); writer.close(); Index: lucene/contrib/instantiated/src/test/org/apache/lucene/store/instantiated/TestUnoptimizedReaderOnConstructor.java =================================================================== --- lucene/contrib/instantiated/src/test/org/apache/lucene/store/instantiated/TestUnoptimizedReaderOnConstructor.java (revision 1197316) +++ lucene/contrib/instantiated/src/test/org/apache/lucene/store/instantiated/TestUnoptimizedReaderOnConstructor.java (working copy) @@ -30,6 +30,7 @@ /** * @since 2009-mar-30 13:15:49 */ +// nocommit rename public class TestUnoptimizedReaderOnConstructor extends LuceneTestCase { public void test() throws Exception { @@ -49,18 +50,18 @@ addDocument(iw, "All work and no play makes wendy a dull girl"); iw.close(); - IndexReader unoptimizedReader = IndexReader.open(dir, false); - unoptimizedReader.deleteDocument(2); + IndexReader multiSegReader = IndexReader.open(dir, false); + multiSegReader.deleteDocument(2); try { - new InstantiatedIndex(unoptimizedReader); + new InstantiatedIndex(multiSegReader); } catch (Exception e) { e.printStackTrace(System.out); - fail("No exceptions when loading an unoptimized reader!"); + fail("No exceptions when loading a multi-seg reader!"); } // todo some assertations. - unoptimizedReader.close(); + multiSegReader.close(); dir.close(); } Index: lucene/contrib/instantiated/src/java/org/apache/lucene/store/instantiated/InstantiatedIndexReader.java =================================================================== --- lucene/contrib/instantiated/src/java/org/apache/lucene/store/instantiated/InstantiatedIndexReader.java (revision 1197316) +++ lucene/contrib/instantiated/src/java/org/apache/lucene/store/instantiated/InstantiatedIndexReader.java (working copy) @@ -56,14 +56,6 @@ } /** - * @return always true. - */ - @Override - public boolean isOptimized() { - return true; - } - - /** * An InstantiatedIndexReader is not a snapshot in time, it is completely in * sync with the latest commit to the store! * Index: lucene/contrib/instantiated/src/java/org/apache/lucene/store/instantiated/InstantiatedIndex.java =================================================================== --- lucene/contrib/instantiated/src/java/org/apache/lucene/store/instantiated/InstantiatedIndex.java (revision 1197316) +++ lucene/contrib/instantiated/src/java/org/apache/lucene/store/instantiated/InstantiatedIndex.java (working copy) @@ -96,7 +96,7 @@ * Creates a new instantiated index that looks just like the index in a specific state as represented by a reader. * * @param sourceIndexReader the source index this new instantiated index will be copied from. - * @throws IOException if the source index is not optimized, or when accessing the source. + * @throws IOException if the source index is not single-segment, or when accessing the source. */ public InstantiatedIndex(IndexReader sourceIndexReader) throws IOException { this(sourceIndexReader, null); @@ -109,13 +109,13 @@ * * @param sourceIndexReader the source index this new instantiated index will be copied from. * @param fields fields to be added, or null for all - * @throws IOException if the source index is not optimized, or when accessing the source. + * @throws IOException if the source index is not single-segment, or when accessing the source. */ public InstantiatedIndex(IndexReader sourceIndexReader, Set fields) throws IOException { - if (!sourceIndexReader.isOptimized()) { - System.out.println(("Source index is not optimized.")); - //throw new IOException("Source index is not optimized."); + if (sourceIndexReader.getSequentialSubReaders().length != 1) { + System.out.println(("Source index has more than one segment.")); + //throw new IOException("Source index has more than one segment."); } Index: lucene/contrib/misc/src/test/org/apache/lucene/index/codecs/appending/TestAppendingCodec.java =================================================================== --- lucene/contrib/misc/src/test/org/apache/lucene/index/codecs/appending/TestAppendingCodec.java (revision 1197316) +++ lucene/contrib/misc/src/test/org/apache/lucene/index/codecs/appending/TestAppendingCodec.java (working copy) @@ -149,7 +149,7 @@ writer.addDocument(doc); writer.commit(); writer.addDocument(doc); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); IndexReader reader = IndexReader.open(dir, null, true, 1, new AppendingCodecProvider()); assertEquals(2, reader.numDocs()); Index: lucene/contrib/misc/src/test/org/apache/lucene/index/TestContribIndexReader.java =================================================================== --- lucene/contrib/misc/src/test/org/apache/lucene/index/TestContribIndexReader.java (revision 1197316) +++ lucene/contrib/misc/src/test/org/apache/lucene/index/TestContribIndexReader.java (working copy) @@ -145,11 +145,11 @@ assertEquals(bin[i], bytesRef.bytes[i + bytesRef.offset]); } reader.close(); - // force optimize + // force full merge writer = new IndexWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)).setOpenMode(OpenMode.APPEND).setMergePolicy(newLogMergePolicy())); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); reader = IndexReader.open(dir, false); doc2 = reader.document(reader.maxDoc() - 1); Index: lucene/contrib/misc/src/test/org/apache/lucene/index/TestIndexSplitter.java =================================================================== --- lucene/contrib/misc/src/test/org/apache/lucene/index/TestIndexSplitter.java (revision 1197316) +++ lucene/contrib/misc/src/test/org/apache/lucene/index/TestIndexSplitter.java (working copy) @@ -94,7 +94,7 @@ fsDir.close(); } - public void testDeleteThenOptimize() throws Exception { + public void testDeleteThenFullMerge() throws Exception { // Create directories where the indexes will reside File indexPath = new File(TEMP_DIR, "testfilesplitter"); _TestUtil.rmDir(indexPath); @@ -134,7 +134,7 @@ indexReader.close(); fsDirDest.close(); - // Optimize the split index + // Fully merge the split index mergePolicy = new LogByteSizeMergePolicy(); mergePolicy.setNoCFSRatio(1); iwConfig = new IndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)) @@ -142,7 +142,7 @@ .setMergePolicy(mergePolicy); fsDirDest = newFSDirectory(indexSplitPath); indexWriter = new IndexWriter(fsDirDest, iwConfig); - indexWriter.optimize(); + indexWriter.mergeIfNeeded(1); indexWriter.close(); fsDirDest.close(); Index: lucene/contrib/misc/src/java/org/apache/lucene/index/BalancedSegmentMergePolicy.java =================================================================== --- lucene/contrib/misc/src/java/org/apache/lucene/index/BalancedSegmentMergePolicy.java (revision 1197316) +++ lucene/contrib/misc/src/java/org/apache/lucene/index/BalancedSegmentMergePolicy.java (working copy) @@ -105,22 +105,22 @@ } @Override - public MergeSpecification findMergesForOptimize(SegmentInfos infos, int maxNumSegments, Map segmentsToOptimize) throws IOException { + public MergeSpecification findMerges(SegmentInfos infos, int maxNumSegments, Map segmentsToMerge) throws IOException { assert maxNumSegments > 0; MergeSpecification spec = null; - if (!isOptimized(infos, maxNumSegments, segmentsToOptimize)) { + if (!isMerged(infos, maxNumSegments, segmentsToMerge)) { // Find the newest (rightmost) segment that needs to - // be optimized (other segments may have been flushed - // since optimize started): + // be merged (other segments may have been flushed + // since the merge started): int last = infos.size(); while(last > 0) { final SegmentInfo info = infos.info(--last); - if (segmentsToOptimize.containsKey(info)) { + if (segmentsToMerge.containsKey(info)) { last++; break; } @@ -130,9 +130,9 @@ if (maxNumSegments == 1) { - // Since we must optimize down to 1 segment, the + // Since we must merge down to 1 segment, the // choice is simple: - if (last > 1 || !isOptimized(infos.info(0))) { + if (last > 1 || !isMerged(infos.info(0))) { spec = new MergeSpecification(); spec.add(new OneMerge(infos.asList().subList(0, last))); Index: lucene/contrib/misc/src/java/org/apache/lucene/index/IndexSplitter.java =================================================================== --- lucene/contrib/misc/src/java/org/apache/lucene/index/IndexSplitter.java (revision 1197316) +++ lucene/contrib/misc/src/java/org/apache/lucene/index/IndexSplitter.java (working copy) @@ -37,8 +37,8 @@ * *

This tool does file-level copying of segments files. * This means it's unable to split apart a single segment - * into multiple segments. For example if your index is - * optimized, this tool won't help. Also, it does basic + * into multiple segments. For example if your index is a + * single segment, this tool won't help. Also, it does basic * file-level copying (using simple * File{In,Out}putStream) so it will not work with non * FSDirectory Directory impls.

Index: lucene/contrib/misc/src/java/org/apache/lucene/misc/IndexMergeTool.java =================================================================== --- lucene/contrib/misc/src/java/org/apache/lucene/misc/IndexMergeTool.java (revision 1197316) +++ lucene/contrib/misc/src/java/org/apache/lucene/misc/IndexMergeTool.java (working copy) @@ -50,8 +50,8 @@ System.out.println("Merging..."); writer.addIndexes(indexes); - System.out.println("Optimizing..."); - writer.optimize(); + System.out.println("Full merge..."); + writer.mergeIfNeeded(1); writer.close(); System.out.println("Done."); } Index: lucene/contrib/spatial/src/test/org/apache/lucene/spatial/tier/TestCartesian.java =================================================================== --- lucene/contrib/spatial/src/test/org/apache/lucene/spatial/tier/TestCartesian.java (revision 1197316) +++ lucene/contrib/spatial/src/test/org/apache/lucene/spatial/tier/TestCartesian.java (working copy) @@ -141,7 +141,7 @@ writer.commit(); // TODO: fix CustomScoreQuery usage in testRange/testGeoHashRange so we don't need this. - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); } Index: lucene/contrib/highlighter/src/test/org/apache/lucene/search/highlight/HighlighterTest.java =================================================================== --- lucene/contrib/highlighter/src/test/org/apache/lucene/search/highlight/HighlighterTest.java (revision 1197316) +++ lucene/contrib/highlighter/src/test/org/apache/lucene/search/highlight/HighlighterTest.java (working copy) @@ -1635,7 +1635,7 @@ writer.addDocument( doc( "t_text1", "more random words for second field del" ) ); writer.addDocument( doc( "t_text1", "random words for highlighting tests del" ) ); writer.addDocument( doc( "t_text1", "more random words for second field" ) ); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); } @@ -1643,7 +1643,7 @@ IndexWriter writer = new IndexWriter(dir, new IndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random, MockTokenizer.WHITESPACE, false)).setOpenMode(OpenMode.APPEND)); writer.deleteDocuments( new Term( "t_text1", "del" ) ); // To see negative idf, keep comment the following line - //writer.optimize(); + //writer.mergeIfNeeded(1); writer.close(); } @@ -1759,7 +1759,7 @@ doc = new Document(); doc.add(nfield); writer.addDocument(doc, analyzer); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); reader = IndexReader.open(ramDir, true); numHighlights = 0; Index: lucene/contrib/sandbox/src/test/org/apache/lucene/sandbox/queries/DuplicateFilterTest.java =================================================================== --- lucene/contrib/sandbox/src/test/org/apache/lucene/sandbox/queries/DuplicateFilterTest.java (revision 1197316) +++ lucene/contrib/sandbox/src/test/org/apache/lucene/sandbox/queries/DuplicateFilterTest.java (working copy) @@ -57,7 +57,7 @@ // Until we fix LUCENE-2348, the index must // have only 1 segment: - writer.optimize(); + writer.mergeIfNeeded(1); reader = writer.getReader(); writer.close(); Index: lucene/contrib/sandbox/src/test/org/apache/lucene/sandbox/queries/regex/TestSpanRegexQuery.java =================================================================== --- lucene/contrib/sandbox/src/test/org/apache/lucene/sandbox/queries/regex/TestSpanRegexQuery.java (revision 1197316) +++ lucene/contrib/sandbox/src/test/org/apache/lucene/sandbox/queries/regex/TestSpanRegexQuery.java (working copy) @@ -68,7 +68,7 @@ doc = new Document(); doc.add(newField("field", "first auto update", TextField.TYPE_UNSTORED)); writer.addDocument(doc); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); IndexSearcher searcher = new IndexSearcher(directory, true); @@ -98,14 +98,14 @@ IndexWriter writerA = new IndexWriter(indexStoreA, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)).setOpenMode(OpenMode.CREATE)); writerA.addDocument(lDoc); - writerA.optimize(); + writerA.mergeIfNeeded(1); writerA.close(); // creating second index writer IndexWriter writerB = new IndexWriter(indexStoreB, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)).setOpenMode(OpenMode.CREATE)); writerB.addDocument(lDoc2); - writerB.optimize(); + writerB.mergeIfNeeded(1); writerB.close(); } } Index: lucene/src/test/org/apache/lucene/TestMergeSchedulerExternal.java =================================================================== --- lucene/src/test/org/apache/lucene/TestMergeSchedulerExternal.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/TestMergeSchedulerExternal.java (working copy) @@ -142,7 +142,7 @@ writer.commit(); // trigger flush writer.addDocument(new Document()); writer.commit(); // trigger flush - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); dir.close(); } Index: lucene/src/test/org/apache/lucene/TestExternalCodecs.java =================================================================== --- lucene/src/test/org/apache/lucene/TestExternalCodecs.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/TestExternalCodecs.java (working copy) @@ -572,7 +572,7 @@ System.out.println("\nTEST: now delete 2nd doc"); } w.deleteDocuments(new Term("id", "44")); - w.optimize(); + w.mergeIfNeeded(1); r = IndexReader.open(w, true); assertEquals(NUM_DOCS-2, r.maxDoc()); assertEquals(NUM_DOCS-2, r.numDocs()); Index: lucene/src/test/org/apache/lucene/search/TestFuzzyQuery2.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestFuzzyQuery2.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/search/TestFuzzyQuery2.java (working copy) @@ -174,7 +174,7 @@ writer.addDocument(doc); } - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); IndexSearcher searcher = new IndexSearcher(dir); Index: lucene/src/test/org/apache/lucene/search/TestCachingWrapperFilter.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestCachingWrapperFilter.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/search/TestCachingWrapperFilter.java (working copy) @@ -239,8 +239,8 @@ assertEquals("[just filter] Should *not* find a hit...", 0, docs.totalHits); assertEquals(missCount, filter.missCount); - // NOTE: silliness to make sure JRE does not optimize - // away our holding onto oldReader to prevent + // NOTE: silliness to make sure JRE does not eliminate + // our holding onto oldReader to prevent // CachingWrapperFilter's WeakHashMap from dropping the // entry: assertTrue(oldReader != null); Index: lucene/src/test/org/apache/lucene/search/TestBooleanQuery.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestBooleanQuery.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/search/TestBooleanQuery.java (working copy) @@ -213,7 +213,7 @@ doc.add(new TextField("field", contents)); w.addDocument(doc); } - w.optimize(); + w.mergeIfNeeded(1); final IndexReader r = w.getReader(); final IndexSearcher s = newSearcher(r); w.close(); Index: lucene/src/test/org/apache/lucene/search/TestSort.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestSort.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/search/TestSort.java (working copy) @@ -208,9 +208,9 @@ } writer.addDocument (doc); } - //writer.optimize (); + //writer.mergeIfNeeded(1); //System.out.println(writer.getSegmentCount()); - writer.close (); + writer.close(); return new IndexSearcher (indexStore, true); } @@ -1115,7 +1115,7 @@ doc.add (new StringField ("string", "b"+i)); writer.addDocument (doc); } - writer.optimize(); // enforce one segment to have a higher unique term count in all cases + writer.mergeIfNeeded(1); // enforce one segment to have a higher unique term count in all cases writer.close(); sort.setSort( new SortField("string", SortField.Type.STRING), Index: lucene/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java (working copy) @@ -56,7 +56,7 @@ writer.addDocument(doc); ((i % 2 == 0) ? swriter1 : swriter2).addDocument(doc); } - writer.optimize(); swriter1.optimize(); swriter2.optimize(); + writer.mergeIfNeeded(1); swriter1.mergeIfNeeded(1); swriter2.mergeIfNeeded(1); writer.close(); swriter1.close(); swriter2.close(); reader = IndexReader.open(dir, true); Index: lucene/src/test/org/apache/lucene/search/TestTermVectors.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestTermVectors.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/search/TestTermVectors.java (working copy) @@ -515,22 +515,22 @@ r.close(); } - public void testOptimizeAddDocs() throws Exception { + public void testFullMergeAddDocs() throws Exception { Directory target = newDirectory(); IndexWriter writer = createWriter(target); - // with maxBufferedDocs=2, this results in two segments, so that optimize + // with maxBufferedDocs=2, this results in two segments, so that mergeIfNeeded // actually does something. for (int i = 0; i < 4; i++) { writer.addDocument(createDoc()); } - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); verifyIndex(target); target.close(); } - public void testOptimizeAddIndexesDir() throws Exception { + public void testFullMergeAddIndexesDir() throws Exception { Directory[] input = new Directory[] { newDirectory(), newDirectory() }; Directory target = newDirectory(); @@ -540,7 +540,7 @@ IndexWriter writer = createWriter(target); writer.addIndexes(input); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); verifyIndex(target); @@ -548,7 +548,7 @@ IOUtils.close(target, input[0], input[1]); } - public void testOptimizeAddIndexesReader() throws Exception { + public void testFullMergeAddIndexesReader() throws Exception { Directory[] input = new Directory[] { newDirectory(), newDirectory() }; Directory target = newDirectory(); @@ -562,7 +562,7 @@ writer.addIndexes(r); r.close(); } - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); verifyIndex(target); Index: lucene/src/test/org/apache/lucene/search/TestTopDocsMerge.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestTopDocsMerge.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/search/TestTopDocsMerge.java (working copy) @@ -74,7 +74,7 @@ { dir = newDirectory(); final RandomIndexWriter w = new RandomIndexWriter(random, dir); - // w.setDoRandomOptimize(false); + // w.setDoRandomMergeIfNeeded(false); // w.w.getConfig().setMaxBufferedDocs(atLeast(100)); Index: lucene/src/test/org/apache/lucene/search/FieldCacheRewriteMethod.java =================================================================== --- lucene/src/test/org/apache/lucene/search/FieldCacheRewriteMethod.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/search/FieldCacheRewriteMethod.java (working copy) @@ -85,7 +85,7 @@ /** * Expert: Return the number of unique terms visited during execution of the filter. * If there are many of them, you may consider using another filter type - * or optimize your total term count in index. + * or reduce your total term count in index. *

This method is not thread safe, be sure to only call it when no filter is running! * If you re-use the same filter instance for another * search, be sure to first reset the term counter Index: lucene/src/test/org/apache/lucene/search/TestScorerPerf.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestScorerPerf.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/search/TestScorerPerf.java (working copy) @@ -71,7 +71,7 @@ } iw.addDocument(d); } - iw.optimize(); + iw.mergeIfNeeded(1); iw.close(); } @@ -103,7 +103,7 @@ @Override public void collect(int doc) { count++; - sum += docBase + doc; // use it to avoid any possibility of being optimized away + sum += docBase + doc; // use it to avoid any possibility of being eliminated by hotspot } public int getCount() { return count; } Index: lucene/src/test/org/apache/lucene/search/TestFilteredSearch.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestFilteredSearch.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/search/TestFilteredSearch.java (working copy) @@ -61,15 +61,15 @@ directory.close(); } - public void searchFiltered(IndexWriter writer, Directory directory, Filter filter, boolean optimize) { + public void searchFiltered(IndexWriter writer, Directory directory, Filter filter, boolean fullMerge) { try { for (int i = 0; i < 60; i++) {//Simple docs Document doc = new Document(); doc.add(newField(FIELD, Integer.toString(i), StringField.TYPE_STORED)); writer.addDocument(doc); } - if(optimize) - writer.optimize(); + if(fullMerge) + writer.mergeIfNeeded(1); writer.close(); BooleanQuery booleanQuery = new BooleanQuery(); Index: lucene/src/test/org/apache/lucene/search/TestFieldCacheRangeFilter.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestFieldCacheRangeFilter.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/search/TestFieldCacheRangeFilter.java (working copy) @@ -540,7 +540,7 @@ writer.addDocument(doc); } - writer.optimize(); + writer.mergeIfNeeded(1); writer.deleteDocuments(new Term("id","0")); writer.close(); Index: lucene/src/test/org/apache/lucene/search/TestTopScoreDocCollector.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestTopScoreDocCollector.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/search/TestTopScoreDocCollector.java (working copy) @@ -43,7 +43,7 @@ // Add a Query with SHOULD, since bw.scorer() returns BooleanScorer2 // which delegates to BS if there are no mandatory clauses. bq.add(new MatchAllDocsQuery(), Occur.SHOULD); - // Set minNrShouldMatch to 1 so that BQ will not optimize rewrite to return + // Set minNrShouldMatch to 1 so that BQ will not rewrite to return // the clause instead of BQ. bq.setMinimumNumberShouldMatch(1); IndexReader reader = writer.getReader(); Index: lucene/src/test/org/apache/lucene/search/TestFilteredQuery.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestFilteredQuery.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/search/TestFilteredQuery.java (working copy) @@ -77,7 +77,7 @@ // tests here require single segment (eg try seed // 8239472272678419952L), because SingleDocTestFilter(x) // blindly accepts that docID in any sub-segment - writer.optimize(); + writer.mergeIfNeeded(1); reader = writer.getReader(); writer.close (); Index: lucene/src/test/org/apache/lucene/index/TestPayloadProcessorProvider.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestPayloadProcessorProvider.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestPayloadProcessorProvider.java (working copy) @@ -245,7 +245,7 @@ processors.put(dir, new PerTermPayloadProcessor()); IndexWriter writer = new IndexWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random, MockTokenizer.WHITESPACE, false))); writer.setPayloadProcessorProvider(new PerDirPayloadProcessor(processors)); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); verifyPayloadExists(dir, "p", new BytesRef("p1"), 0); Index: lucene/src/test/org/apache/lucene/index/TestIndexWriterCommit.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestIndexWriterCommit.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestIndexWriterCommit.java (working copy) @@ -223,7 +223,7 @@ } long midDiskUsage = dir.getMaxUsedSizeInBytes(); dir.resetMaxUsedSizeInBytes(); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); IndexReader.open(dir, true).close(); @@ -245,11 +245,11 @@ /* - * Verify that calling optimize when writer is open for + * Verify that calling mergeIfNeeded when writer is open for * "commit on close" works correctly both for rollback() * and close(). */ - public void testCommitOnCloseOptimize() throws IOException { + public void testCommitOnCloseMergeIfNeeded() throws IOException { MockDirectoryWrapper dir = newDirectory(); // Must disable throwing exc on double-write: this // test uses IW.rollback which easily results in @@ -267,7 +267,7 @@ writer.close(); writer = new IndexWriter(dir, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)).setOpenMode(OpenMode.APPEND)); - writer.optimize(); + writer.mergeIfNeeded(1); if (VERBOSE) { writer.setInfoStream(System.out); @@ -276,42 +276,42 @@ // Open a reader before closing (commiting) the writer: IndexReader reader = IndexReader.open(dir, true); - // Reader should see index as unoptimized at this + // Reader should see index as multi-segment at this // point: - assertFalse("Reader incorrectly sees that the index is optimized", reader.isOptimized()); + assertTrue("Reader incorrectly sees one segment", reader.getSequentialSubReaders().length > 1); reader.close(); // Abort the writer: writer.rollback(); - TestIndexWriter.assertNoUnreferencedFiles(dir, "aborted writer after optimize"); + TestIndexWriter.assertNoUnreferencedFiles(dir, "aborted writer after mergeIfNeeded"); // Open a reader after aborting writer: reader = IndexReader.open(dir, true); - // Reader should still see index as unoptimized: - assertFalse("Reader incorrectly sees that the index is optimized", reader.isOptimized()); + // Reader should still see index as multi-segment + assertTrue("Reader incorrectly sees one segment", reader.getSequentialSubReaders().length > 1); reader.close(); if (VERBOSE) { - System.out.println("TEST: do real optimize"); + System.out.println("TEST: do real full merge"); } writer = new IndexWriter(dir, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)).setOpenMode(OpenMode.APPEND)); if (VERBOSE) { writer.setInfoStream(System.out); } - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); if (VERBOSE) { System.out.println("TEST: writer closed"); } - TestIndexWriter.assertNoUnreferencedFiles(dir, "aborted writer after optimize"); + TestIndexWriter.assertNoUnreferencedFiles(dir, "aborted writer after mergeIfNeeded"); // Open a reader after aborting writer: reader = IndexReader.open(dir, true); - // Reader should still see index as unoptimized: - assertTrue("Reader incorrectly sees that the index is unoptimized", reader.isOptimized()); + // Reader should see index as one segment + assertEquals("Reader incorrectly sees more than one segment", 1, reader.getSequentialSubReaders().length); reader.close(); dir.close(); } @@ -663,7 +663,7 @@ r.close(); w = new IndexWriter(dir, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random))); - w.optimize(); + w.mergeIfNeeded(1); w.close(); assertEquals("test1", IndexReader.getCommitUserData(dir).get("label")); Index: lucene/src/test/org/apache/lucene/index/TestSegmentTermEnum.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestSegmentTermEnum.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestSegmentTermEnum.java (working copy) @@ -60,15 +60,15 @@ writer.close(); - // verify document frequency of terms in an unoptimized index + // verify document frequency of terms in an multi segment index verifyDocFreq(); - // merge segments by optimizing the index + // merge segments writer = new IndexWriter(dir, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)).setOpenMode(OpenMode.APPEND)); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); - // verify document frequency of terms in an optimized index + // verify document frequency of terms in a single segment index verifyDocFreq(); } Index: lucene/src/test/org/apache/lucene/index/TestIndexWriterOptimize.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestIndexWriterOptimize.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestIndexWriterOptimize.java (working copy) @@ -28,8 +28,9 @@ import org.apache.lucene.util.LuceneTestCase; import org.apache.lucene.util._TestUtil; +// nocommit rename public class TestIndexWriterOptimize extends LuceneTestCase { - public void testOptimizeMaxNumSegments() throws IOException { + public void testPartialMerge() throws IOException { MockDirectoryWrapper dir = newDirectory(); @@ -56,7 +57,7 @@ ldmp.setMergeFactor(5); writer = new IndexWriter(dir, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)).setMergePolicy(ldmp)); - writer.optimize(3); + writer.mergeIfNeeded(3); writer.close(); sis = new SegmentInfos(); @@ -71,7 +72,7 @@ dir.close(); } - public void testOptimizeMaxNumSegments2() throws IOException { + public void testMaxNumSegments2() throws IOException { MockDirectoryWrapper dir = newDirectory(); final Document doc = new Document(); @@ -97,7 +98,7 @@ final int segCount = sis.size(); - writer.optimize(7); + writer.mergeIfNeeded(7); writer.commit(); writer.waitForMerges(); @@ -115,11 +116,11 @@ } /** - * Make sure optimize doesn't use any more than 1X + * Make sure mergeIfNeeded doesn't use any more than 1X * starting index size as its temporary free space * required. */ - public void testOptimizeTempSpaceUsage() throws IOException { + public void testMergeIfNeededTempSpaceUsage() throws IOException { MockDirectoryWrapper dir = newDirectory(); IndexWriter writer = new IndexWriter(dir, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)).setMaxBufferedDocs(10).setMergePolicy(newLogMergePolicy())); @@ -157,18 +158,18 @@ // cause a false failure: writer = new IndexWriter(dir, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)).setOpenMode(OpenMode.APPEND).setTermIndexInterval(termIndexInterval).setMergePolicy(newLogMergePolicy())); writer.setInfoStream(VERBOSE ? System.out : null); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); long maxDiskUsage = dir.getMaxUsedSizeInBytes(); - assertTrue("optimize used too much temporary space: starting usage was " + startDiskUsage + " bytes; max temp usage was " + maxDiskUsage + " but should have been " + (4*startDiskUsage) + " (= 4X starting usage)", + assertTrue("mergeIfNeeded used too much temporary space: starting usage was " + startDiskUsage + " bytes; max temp usage was " + maxDiskUsage + " but should have been " + (4*startDiskUsage) + " (= 4X starting usage)", maxDiskUsage <= 4*startDiskUsage); dir.close(); } - // Test calling optimize(false) whereby optimize is kicked + // Test calling mergeIfNeeded(1, false) whereby merging is kicked // off but we don't wait for it to finish (but // writer.close()) does wait - public void testBackgroundOptimize() throws IOException { + public void testBackgroundMergeIfNeeded() throws IOException { Directory dir = newDirectory(); for(int pass=0;pass<2;pass++) { @@ -183,22 +184,22 @@ doc.add(newField("field", "aaa", StringField.TYPE_UNSTORED)); for(int i=0;i<100;i++) writer.addDocument(doc); - writer.optimize(false); + writer.mergeIfNeeded(1, false); if (0 == pass) { writer.close(); IndexReader reader = IndexReader.open(dir, true); - assertTrue(reader.isOptimized()); + assertEquals(1, reader.getSequentialSubReaders().length); reader.close(); } else { // Get another segment to flush so we can verify it is - // NOT included in the optimization + // NOT included in the merging writer.addDocument(doc); writer.addDocument(doc); writer.close(); IndexReader reader = IndexReader.open(dir, true); - assertTrue(!reader.isOptimized()); + assertTrue(reader.getSequentialSubReaders().length > 1); reader.close(); SegmentInfos infos = new SegmentInfos(); Index: lucene/src/test/org/apache/lucene/index/Test2BPostings.java =================================================================== --- lucene/src/test/org/apache/lucene/index/Test2BPostings.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/Test2BPostings.java (working copy) @@ -76,7 +76,7 @@ System.out.println(i + " of " + numDocs + "..."); } } - w.optimize(); + w.mergeIfNeeded(1); w.close(); CheckIndex ci = new CheckIndex(dir); if (VERBOSE) { Index: lucene/src/test/org/apache/lucene/index/TestSizeBoundedOptimize.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestSizeBoundedOptimize.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestSizeBoundedOptimize.java (working copy) @@ -24,6 +24,7 @@ import org.apache.lucene.store.RAMDirectory; import org.apache.lucene.util.LuceneTestCase; +// nocommit rename public class TestSizeBoundedOptimize extends LuceneTestCase { private void addDocs(IndexWriter writer, int numDocs) throws IOException { @@ -44,7 +45,7 @@ } public void testByteSizeLimit() throws Exception { - // tests that the max merge size constraint is applied during optimize. + // tests that the max merge size constraint is applied during mergeIfNeeded. Directory dir = new RAMDirectory(); // Prepare an index w/ several small segments and a large one. @@ -63,11 +64,11 @@ conf = newWriterConfig(); LogByteSizeMergePolicy lmp = new LogByteSizeMergePolicy(); - lmp.setMaxMergeMBForOptimize((min + 1) / (1 << 20)); + lmp.setMaxMergeMBForMergeIfNeeded((min + 1) / (1 << 20)); conf.setMergePolicy(lmp); writer = new IndexWriter(dir, conf); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); // Should only be 3 segments in the index, because one of them exceeds the size limit @@ -77,7 +78,7 @@ } public void testNumDocsLimit() throws Exception { - // tests that the max merge docs constraint is applied during optimize. + // tests that the max merge docs constraint is applied during mergeIfNeeded. Directory dir = new RAMDirectory(); // Prepare an index w/ several small segments and a large one. @@ -100,7 +101,7 @@ conf.setMergePolicy(lmp); writer = new IndexWriter(dir, conf); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); // Should only be 3 segments in the index, because one of them exceeds the size limit @@ -128,7 +129,7 @@ conf.setMergePolicy(lmp); writer = new IndexWriter(dir, conf); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); SegmentInfos sis = new SegmentInfos(); @@ -155,7 +156,7 @@ conf.setMergePolicy(lmp); writer = new IndexWriter(dir, conf); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); SegmentInfos sis = new SegmentInfos(); @@ -182,7 +183,7 @@ conf.setMergePolicy(lmp); writer = new IndexWriter(dir, conf); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); SegmentInfos sis = new SegmentInfos(); @@ -208,7 +209,7 @@ conf.setMergePolicy(lmp); writer = new IndexWriter(dir, conf); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); SegmentInfos sis = new SegmentInfos(); @@ -235,7 +236,7 @@ conf.setMergePolicy(lmp); writer = new IndexWriter(dir, conf); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); SegmentInfos sis = new SegmentInfos(); @@ -266,7 +267,7 @@ conf.setMergePolicy(lmp); writer = new IndexWriter(dir, conf); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); // Should only be 4 segments in the index, because of the merge factor and @@ -276,7 +277,7 @@ assertEquals(4, sis.size()); } - public void testSingleNonOptimizedSegment() throws Exception { + public void testSingleMergeableSegment() throws Exception { Directory dir = new RAMDirectory(); IndexWriterConfig conf = newWriterConfig(); @@ -288,7 +289,7 @@ writer.close(); - // delete the last document, so that the last segment is optimized. + // delete the last document, so that the last segment is merged. IndexReader r = IndexReader.open(dir, false); r.deleteDocument(r.numDocs() - 1); r.close(); @@ -299,7 +300,7 @@ conf.setMergePolicy(lmp); writer = new IndexWriter(dir, conf); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); // Verify that the last segment does not have deletions. @@ -309,7 +310,7 @@ assertFalse(sis.info(2).hasDeletions()); } - public void testSingleOptimizedSegment() throws Exception { + public void testSingleNonMergeableSegment() throws Exception { Directory dir = new RAMDirectory(); IndexWriterConfig conf = newWriterConfig(); @@ -325,7 +326,7 @@ conf.setMergePolicy(lmp); writer = new IndexWriter(dir, conf); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); // Verify that the last segment does not have deletions. @@ -334,7 +335,7 @@ assertEquals(1, sis.size()); } - public void testSingleNonOptimizedTooLargeSegment() throws Exception { + public void testSingleMergeableTooLargeSegment() throws Exception { Directory dir = new RAMDirectory(); IndexWriterConfig conf = newWriterConfig(); @@ -355,7 +356,7 @@ conf.setMergePolicy(lmp); writer = new IndexWriter(dir, conf); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); // Verify that the last segment does not have deletions. Index: lucene/src/test/org/apache/lucene/index/TestFlex.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestFlex.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestFlex.java (working copy) @@ -47,7 +47,7 @@ w.addDocument(doc); } } else { - w.optimize(); + w.mergeIfNeeded(1); } IndexReader r = w.getReader(); Index: lucene/src/test/org/apache/lucene/index/TestIndexWriterOnDiskFull.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestIndexWriterOnDiskFull.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestIndexWriterOnDiskFull.java (working copy) @@ -179,7 +179,7 @@ } // Now, build a starting index that has START_COUNT docs. We - // will then try to addIndexesNoOptimize into a copy of this: + // will then try to addIndexes into a copy of this: MockDirectoryWrapper startDir = newDirectory(); IndexWriter writer = new IndexWriter(startDir, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random))); for(int j=0;j fieldNames = new HashSet(); final int numFields = 2 + (TEST_NIGHTLY ? random.nextInt(200) : random.nextInt(20)); @@ -287,7 +287,7 @@ FieldNumberBiMap globalFieldMap = writer.segmentInfos .getOrLoadGlobalFieldNumberMap(base); Set> entries = globalFieldMap.entries(); - writer.optimize(); + writer.mergeIfNeeded(1); writer.commit(); writer.close(); Set> afterOptmize = globalFieldMap.entries(); @@ -354,7 +354,7 @@ IndexWriter w = new IndexWriter(base, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)).setMergePolicy( new LogByteSizeMergePolicy())); - w.optimize(); + w.mergeIfNeeded(1); w.close(); SegmentInfos sis = new SegmentInfos(); sis.read(base); Index: lucene/src/test/org/apache/lucene/index/TestSegmentTermDocs.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestSegmentTermDocs.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestSegmentTermDocs.java (working copy) @@ -120,7 +120,7 @@ addDoc(writer, "ccc ccc ccc ccc"); // assure that we deal with a single segment - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); IndexReader reader = IndexReader.open(dir, null, true, indexDivisor); Index: lucene/src/test/org/apache/lucene/index/TestCheckIndex.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestCheckIndex.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestCheckIndex.java (working copy) @@ -45,7 +45,7 @@ for(int i=0;i<19;i++) { writer.addDocument(doc); } - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); IndexReader reader = IndexReader.open(dir, false); reader.deleteDocument(5); Index: lucene/src/test/org/apache/lucene/index/TestIndexWriterExceptions.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestIndexWriterExceptions.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestIndexWriterExceptions.java (working copy) @@ -666,7 +666,7 @@ doc.add(newField("contents", "here are some contents", DocCopyIterator.custom5)); for(int j=0;j<17;j++) writer.addDocument(doc); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); reader = IndexReader.open(dir, true); @@ -780,7 +780,7 @@ doc.add(newField("contents", "here are some contents", DocCopyIterator.custom5)); for(int j=0;j<17;j++) writer.addDocument(doc); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); reader = IndexReader.open(dir, true); @@ -936,7 +936,7 @@ } } - public void testOptimizeExceptions() throws IOException { + public void testMergeIfNeededExceptions() throws IOException { Directory startDir = newDirectory(); IndexWriterConfig conf = newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)).setMaxBufferedDocs(2).setMergePolicy(newLogMergePolicy()); ((LogMergePolicy) conf.getMergePolicy()).setMergeFactor(100); @@ -957,10 +957,10 @@ w.setInfoStream(VERBOSE ? System.out : null); dir.setRandomIOExceptionRate(0.5); try { - w.optimize(); + w.mergeIfNeeded(1); } catch (IOException ioe) { if (ioe.getCause() == null) - fail("optimize threw IOException without root cause"); + fail("mergeIfNeeded threw IOException without root cause"); } dir.setRandomIOExceptionRate(0); w.close(); Index: lucene/src/test/org/apache/lucene/index/TestDocumentWriter.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestDocumentWriter.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestDocumentWriter.java (working copy) @@ -321,7 +321,7 @@ IndexWriter writer = new IndexWriter(dir, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random))); writer.addDocument(doc); - writer.optimize(); // be sure to have a single segment + writer.mergeIfNeeded(1); // be sure to have a single segment writer.close(); _TestUtil.checkIndex(dir); Index: lucene/src/test/org/apache/lucene/index/values/TestTypePromotion.java =================================================================== --- lucene/src/test/org/apache/lucene/index/values/TestTypePromotion.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/values/TestTypePromotion.java (working copy) @@ -88,7 +88,7 @@ if (random.nextInt(4) == 0) { // once in a while use addIndexes - writer.optimize(); + writer.mergeIfNeeded(1); Directory dir_2 = newDirectory() ; IndexWriter writer_2 = new IndexWriter(dir_2, @@ -111,7 +111,7 @@ randomValueType(types, random), values, num_1 + num_2, num_3); } - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); assertValues(type, dir, values); dir.close(); @@ -120,7 +120,7 @@ private void assertValues(TestType type, Directory dir, long[] values) throws CorruptIndexException, IOException { IndexReader reader = IndexReader.open(dir); - assertTrue(reader.isOptimized()); + assertEquals(1, reader.getSequentialSubReaders().length); ReaderContext topReaderContext = reader.getTopReaderContext(); ReaderContext[] children = topReaderContext.children(); IndexDocValues docValues = children[0].reader.docValues("promote"); @@ -293,14 +293,14 @@ writer.close(); writerConfig = newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)); if (writerConfig.getMergePolicy() instanceof NoMergePolicy) { - writerConfig.setMergePolicy(newLogMergePolicy()); // make sure we optimize to one segment (merge everything together) + writerConfig.setMergePolicy(newLogMergePolicy()); // make sure we merge to one segment (merge everything together) } writer = new IndexWriter(dir, writerConfig); - // now optimize - writer.optimize(); + // now merge + writer.mergeIfNeeded(1); writer.close(); IndexReader reader = IndexReader.open(dir); - assertTrue(reader.isOptimized()); + assertEquals(1, reader.getSequentialSubReaders().length); ReaderContext topReaderContext = reader.getTopReaderContext(); ReaderContext[] children = topReaderContext.children(); IndexDocValues docValues = children[0].reader.docValues("promote"); Index: lucene/src/test/org/apache/lucene/index/values/TestDocValuesIndexing.java =================================================================== --- lucene/src/test/org/apache/lucene/index/values/TestDocValuesIndexing.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/values/TestDocValuesIndexing.java (working copy) @@ -58,7 +58,7 @@ */ public class TestDocValuesIndexing extends LuceneTestCase { /* - * - add test for unoptimized case with deletes + * - add test for multi segment case with deletes * - add multithreaded tests / integrate into stress indexing? */ @@ -83,12 +83,12 @@ writer.addDocument(doc); } writer.commit(); - writer.optimize(true); + writer.mergeIfNeeded(1, true); writer.close(true); IndexReader reader = IndexReader.open(dir, null, true, 1); - assertTrue(reader.isOptimized()); + assertEquals(1, reader.getSequentialSubReaders().length); IndexSearcher searcher = new IndexSearcher(reader); @@ -159,7 +159,7 @@ } else { w.addIndexes(r_1, r_2); } - w.optimize(true); + w.mergeIfNeeded(1, true); w.commit(); _TestUtil.checkIndex(target, w.getConfig().getCodecProvider()); @@ -418,10 +418,10 @@ private IndexDocValues getDocValues(IndexReader reader, String field) throws IOException { - boolean optimized = reader.isOptimized(); - PerDocValues perDoc = optimized ? reader.getSequentialSubReaders()[0].perDocValues() + boolean singleSeg = reader.getSequentialSubReaders().length == 1; + PerDocValues perDoc = singleSeg ? reader.getSequentialSubReaders()[0].perDocValues() : MultiPerDocValues.getPerDocs(reader); - switch (random.nextInt(optimized ? 3 : 2)) { // case 2 only if optimized + switch (random.nextInt(singleSeg ? 3 : 2)) { // case 2 only if single seg case 0: return perDoc.docValues(field); case 1: @@ -430,7 +430,7 @@ return docValues; } throw new RuntimeException("no such field " + field); - case 2:// this only works if we are on an optimized index! + case 2:// this only works if we are on a single seg index! return reader.getSequentialSubReaders()[0].docValues(field); } throw new RuntimeException(); @@ -538,9 +538,9 @@ } w.commit(); - // TODO test unoptimized with deletions + // TODO test multi seg with deletions if (withDeletions || random.nextBoolean()) { - w.optimize(true); + w.mergeIfNeeded(1, true); } return deleted; } @@ -566,7 +566,7 @@ doc = new Document(); doc.add(f); w.addDocument(doc); - w.optimize(); + w.mergeIfNeeded(1); IndexReader r = w.getReader(); w.close(); assertEquals(17, r.getSequentialSubReaders()[0].perDocValues().docValues("field").load().getInt(0)); @@ -597,7 +597,7 @@ doc = new Document(); doc.add(f); w.addDocument(doc); - w.optimize(); + w.mergeIfNeeded(1); IndexReader r = w.getReader(); w.close(); assertEquals(17, r.getSequentialSubReaders()[0].perDocValues().docValues("field").load().getInt(0)); Index: lucene/src/test/org/apache/lucene/index/TestIndexReaderCloneNorms.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestIndexReaderCloneNorms.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestIndexReaderCloneNorms.java (working copy) @@ -80,7 +80,7 @@ /** * Test that norms values are preserved as the index is maintained. Including * separate norms. Including merging indexes with seprate norms. Including - * optimize. + * full merge. */ public void testNorms() throws IOException { // test with a single index: index1 @@ -112,7 +112,7 @@ createIndex(random, dir3); if (VERBOSE) { - System.out.println("TEST: now addIndexes/optimize"); + System.out.println("TEST: now addIndexes/full merge"); } IndexWriter iw = new IndexWriter( dir3, @@ -123,7 +123,7 @@ ); iw.setInfoStream(VERBOSE ? System.out : null); iw.addIndexes(dir1, dir2); - iw.optimize(); + iw.mergeIfNeeded(1); iw.close(); norms1.addAll(norms); @@ -136,7 +136,7 @@ verifyIndex(dir3); doTestNorms(random, dir3); - // now with optimize + // now with full merge iw = new IndexWriter( dir3, newIndexWriterConfig(TEST_VERSION_CURRENT, anlzr). @@ -144,7 +144,7 @@ setMaxBufferedDocs(5). setMergePolicy(newLogMergePolicy(3)) ); - iw.optimize(); + iw.mergeIfNeeded(1); iw.close(); verifyIndex(dir3); Index: lucene/src/test/org/apache/lucene/index/TestOmitTf.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestOmitTf.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestOmitTf.java (working copy) @@ -82,7 +82,7 @@ d.add(f2); writer.addDocument(d); - writer.optimize(); + writer.mergeIfNeeded(1); // now we add another document which has term freq for field f2 and not for f1 and verify if the SegmentMerger // keep things constant d = new Document(); @@ -97,7 +97,7 @@ writer.addDocument(d); // force merge - writer.optimize(); + writer.mergeIfNeeded(1); // flush writer.close(); @@ -150,7 +150,7 @@ writer.addDocument(d); // force merge - writer.optimize(); + writer.mergeIfNeeded(1); // flush writer.close(); @@ -192,7 +192,7 @@ writer.addDocument(d); // force merge - writer.optimize(); + writer.mergeIfNeeded(1); // flush writer.close(); @@ -235,7 +235,8 @@ assertNoPrx(ram); - // now add some documents with positions, and check there is no prox after optimization + // now add some documents with positions, and check + // there is no prox after full merge d = new Document(); f1 = newField("f1", "This field has positions", TextField.TYPE_UNSTORED); d.add(f1); @@ -244,7 +245,7 @@ writer.addDocument(d); // force merge - writer.optimize(); + writer.mergeIfNeeded(1); // flush writer.close(); @@ -281,7 +282,7 @@ //System.out.println(d); } - writer.optimize(); + writer.mergeIfNeeded(1); // flush writer.close(); @@ -416,7 +417,7 @@ @Override public void collect(int doc) throws IOException { count++; - sum += doc + docBase; // use it to avoid any possibility of being optimized away + sum += doc + docBase; // use it to avoid any possibility of being merged away } public static int getCount() { return count; } Index: lucene/src/test/org/apache/lucene/index/TestStressNRT.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestStressNRT.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestStressNRT.java (working copy) @@ -107,7 +107,7 @@ Directory dir = newDirectory(); final RandomIndexWriter writer = new RandomIndexWriter(random, dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random))); - writer.setDoRandomOptimizeAssert(false); + writer.setDoRandomMergeIfNeededAssert(false); writer.w.setInfoStream(VERBOSE ? System.out : null); writer.commit(); reader = IndexReader.open(dir); Index: lucene/src/test/org/apache/lucene/index/TestIndexReaderDelete.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestIndexReaderDelete.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestIndexReaderDelete.java (working copy) @@ -33,7 +33,7 @@ import static org.apache.lucene.index.TestIndexReader.createDocument; public class TestIndexReaderDelete extends LuceneTestCase { - private void deleteReaderReaderConflict(boolean optimize) throws IOException { + private void deleteReaderReaderConflict(boolean doFullMerge) throws IOException { Directory dir = newDirectory(); Term searchTerm1 = new Term("content", "aaa"); @@ -49,8 +49,8 @@ addDoc(writer, searchTerm2.text()); addDoc(writer, searchTerm3.text()); } - if(optimize) - writer.optimize(); + if(doFullMerge) + writer.mergeIfNeeded(1); writer.close(); // OPEN TWO READERS @@ -131,7 +131,7 @@ dir.close(); } - private void deleteReaderWriterConflict(boolean optimize) throws IOException { + private void deleteReaderWriterConflict(boolean doFullMerge) throws IOException { //Directory dir = new RAMDirectory(); Directory dir = newDirectory(); @@ -159,13 +159,13 @@ addDoc(writer, searchTerm2.text()); } - // REQUEST OPTIMIZATION + // REQUEST full merge // This causes a new segment to become current for all subsequent // searchers. Because of this, deletions made via a previously open // reader, which would be applied to that reader's segment, are lost // for subsequent searchers/readers - if(optimize) - writer.optimize(); + if(doFullMerge) + writer.mergeIfNeeded(1); writer.close(); // The reader should not see the new data @@ -256,19 +256,19 @@ dir.close(); } - public void testDeleteReaderReaderConflictUnoptimized() throws IOException { + public void testDeleteReaderReaderConflictNoFullMerge() throws IOException { deleteReaderReaderConflict(false); } - public void testDeleteReaderReaderConflictOptimized() throws IOException { + public void testDeleteReaderReaderConflictFullMerge() throws IOException { deleteReaderReaderConflict(true); } - public void testDeleteReaderWriterConflictUnoptimized() throws IOException { + public void testDeleteReaderWriterConflictNoFullMerge() throws IOException { deleteReaderWriterConflict(false); } - public void testDeleteReaderWriterConflictOptimized() throws IOException { + public void testDeleteReaderWriterConflictFullMerge() throws IOException { deleteReaderWriterConflict(true); } Index: lucene/src/test/org/apache/lucene/index/TestNRTThreads.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestNRTThreads.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestNRTThreads.java (working copy) @@ -25,7 +25,7 @@ import org.apache.lucene.util.LuceneTestCase.UseNoMemoryExpensiveCodec; // TODO -// - mix in optimize, addIndexes +// - mix in mergeIfNeeded, addIndexes // - randomoly mix in non-congruent docs @UseNoMemoryExpensiveCodec Index: lucene/src/test/org/apache/lucene/index/TestIndexCommit.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestIndexCommit.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestIndexCommit.java (working copy) @@ -42,7 +42,7 @@ @Override public long getTimestamp() throws IOException { return 1;} @Override public Map getUserData() throws IOException { return null; } @Override public boolean isDeleted() { return false; } - @Override public boolean isOptimized() { return false; } + @Override public int getSegmentCount() { return 2; } }; IndexCommit ic2 = new IndexCommit() { @@ -55,7 +55,7 @@ @Override public long getTimestamp() throws IOException { return 1;} @Override public Map getUserData() throws IOException { return null; } @Override public boolean isDeleted() { return false; } - @Override public boolean isOptimized() { return false; } + @Override public int getSegmentCount() { return 2; } }; assertEquals(ic1, ic2); Index: lucene/src/test/org/apache/lucene/index/TestOmitPositions.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestOmitPositions.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestOmitPositions.java (working copy) @@ -109,7 +109,7 @@ d.add(f9); writer.addDocument(d); - writer.optimize(); + writer.mergeIfNeeded(1); // now we add another document which has docs-only for f1, f4, f7, docs/freqs for f2, f5, f8, // and docs/freqs/positions for f3, f6, f9 @@ -148,7 +148,7 @@ writer.addDocument(d); // force merge - writer.optimize(); + writer.mergeIfNeeded(1); // flush writer.close(); @@ -217,7 +217,7 @@ writer.addDocument(d); // force merge - writer.optimize(); + writer.mergeIfNeeded(1); // flush writer.close(); Index: lucene/src/test/org/apache/lucene/index/TestOmitNorms.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestOmitNorms.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestOmitNorms.java (working copy) @@ -49,7 +49,7 @@ d.add(f2); writer.addDocument(d); - writer.optimize(); + writer.mergeIfNeeded(1); // now we add another document which has term freq for field f2 and not for f1 and verify if the SegmentMerger // keep things constant d = new Document(); @@ -62,7 +62,7 @@ writer.addDocument(d); // force merge - writer.optimize(); + writer.mergeIfNeeded(1); // flush writer.close(); @@ -116,7 +116,7 @@ } // force merge - writer.optimize(); + writer.mergeIfNeeded(1); // flush writer.close(); @@ -163,7 +163,7 @@ } // force merge - writer.optimize(); + writer.mergeIfNeeded(1); // flush writer.close(); @@ -210,7 +210,7 @@ assertNoNrm(ram); // force merge - writer.optimize(); + writer.mergeIfNeeded(1); // flush writer.close(); @@ -222,7 +222,7 @@ * Tests various combinations of omitNorms=true/false, the field not existing at all, * ensuring that only omitNorms is 'viral'. * Internally checks that MultiNorms.norms() is consistent (returns the same bytes) - * as the optimized equivalent. + * as the fully merged equivalent. */ public void testOmitNormsCombos() throws IOException { // indexed with norms @@ -291,8 +291,8 @@ IndexReader ir1 = riw.getReader(); byte[] norms1 = MultiNorms.norms(ir1, field); - // optimize and validate MultiNorms against single segment. - riw.optimize(); + // fully merge and validate MultiNorms against single segment. + riw.mergeIfNeeded(1); IndexReader ir2 = riw.getReader(); byte[] norms2 = ir2.getSequentialSubReaders()[0].norms(field); Index: lucene/src/test/org/apache/lucene/index/TestDirectoryReader.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestDirectoryReader.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestDirectoryReader.java (working copy) @@ -184,7 +184,7 @@ while (td.nextDoc() != td.NO_MORE_DOCS) ret += td.docID(); // really a dummy assert to ensure that we got some docs and to ensure that - // nothing is optimized out. + // nothing is eliminated by hotspot assertTrue(ret > 0); readers1[0].close(); readers1[1].close(); Index: lucene/src/test/org/apache/lucene/index/TestIndexWriterReader.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestIndexWriterReader.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestIndexWriterReader.java (working copy) @@ -94,7 +94,7 @@ assertFalse(reader.isCurrent()); reader.close(); } - writer.optimize(); // make sure all merging is done etc. + writer.mergeIfNeeded(1); // make sure all merging is done etc. IndexReader reader = writer.getReader(); writer.commit(); // no changes that are not visible to the reader assertTrue(reader.isCurrent()); @@ -112,7 +112,7 @@ } public void testUpdateDocument() throws Exception { - boolean optimize = true; + boolean doFullMerge = true; Directory dir1 = newDirectory(); IndexWriterConfig iwc = newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)); @@ -132,7 +132,7 @@ writer.setInfoStream(VERBOSE ? System.out : null); // create the index - createIndexNoClose(!optimize, "index1", writer); + createIndexNoClose(!doFullMerge, "index1", writer); // writer.flush(false, true, true); @@ -202,7 +202,7 @@ assertTrue(nrtReader.isCurrent()); writer.addDocument(doc); assertFalse(nrtReader.isCurrent()); // should see the changes - writer.optimize(); // make sure we don't have a merge going on + writer.mergeIfNeeded(1); // make sure we don't have a merge going on assertFalse(nrtReader.isCurrent()); nrtReader.close(); @@ -228,7 +228,7 @@ * @throws Exception */ public void testAddIndexes() throws Exception { - boolean optimize = false; + boolean doFullMerge = false; Directory dir1 = newDirectory(); IndexWriterConfig iwc = newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)); @@ -245,14 +245,14 @@ writer.setInfoStream(infoStream); // create the index - createIndexNoClose(!optimize, "index1", writer); + createIndexNoClose(!doFullMerge, "index1", writer); writer.flush(false, true); // create a 2nd index Directory dir2 = newDirectory(); IndexWriter writer2 = new IndexWriter(dir2, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random))); writer2.setInfoStream(infoStream); - createIndexNoClose(!optimize, "index2", writer2); + createIndexNoClose(!doFullMerge, "index2", writer2); writer2.close(); IndexReader r0 = writer.getReader(); @@ -285,7 +285,7 @@ } public void testAddIndexes2() throws Exception { - boolean optimize = false; + boolean doFullMerge = false; Directory dir1 = newDirectory(); IndexWriter writer = new IndexWriter(dir1, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random))); @@ -295,7 +295,7 @@ Directory dir2 = newDirectory(); IndexWriter writer2 = new IndexWriter(dir2, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random))); writer2.setInfoStream(infoStream); - createIndexNoClose(!optimize, "index2", writer2); + createIndexNoClose(!doFullMerge, "index2", writer2); writer2.close(); writer.addIndexes(dir2); @@ -319,13 +319,13 @@ * @throws Exception */ public void testDeleteFromIndexWriter() throws Exception { - boolean optimize = true; + boolean doFullMerge = true; Directory dir1 = newDirectory(); IndexWriter writer = new IndexWriter(dir1, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)).setReaderTermsIndexDivisor(2)); writer.setInfoStream(infoStream); // create the index - createIndexNoClose(!optimize, "index1", writer); + createIndexNoClose(!doFullMerge, "index1", writer); writer.flush(false, true); // get a reader IndexReader r1 = writer.getReader(); @@ -497,7 +497,7 @@ switch (j % 4) { case 0: mainWriter.addIndexes(dirs); - mainWriter.optimize(); + mainWriter.mergeIfNeeded(1); break; case 1: mainWriter.addIndexes(dirs); @@ -513,7 +513,7 @@ } } - public void testIndexWriterReopenSegmentOptimize() throws Exception { + public void testIndexWriterReopenSegmentFullMerge() throws Exception { doTestIndexWriterReopenSegment(true); } @@ -525,14 +525,14 @@ * Tests creating a segment, then check to insure the segment can be seen via * IW.getReader */ - public void doTestIndexWriterReopenSegment(boolean optimize) throws Exception { + public void doTestIndexWriterReopenSegment(boolean doFullMerge) throws Exception { Directory dir1 = newDirectory(); IndexWriter writer = new IndexWriter(dir1, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random))); writer.setInfoStream(infoStream); IndexReader r1 = writer.getReader(); assertEquals(0, r1.maxDoc()); createIndexNoClose(false, "index1", writer); - writer.flush(!optimize, true); + writer.flush(!doFullMerge, true); IndexReader iwr1 = writer.getReader(); assertEquals(100, iwr1.maxDoc()); @@ -592,7 +592,7 @@ w.addDocument(DocHelper.createDocument(i, indexName, 4)); } if (!multiSegment) { - w.optimize(); + w.mergeIfNeeded(1); } w.close(); } @@ -603,7 +603,7 @@ w.addDocument(DocHelper.createDocument(i, indexName, 4)); } if (!multiSegment) { - w.optimize(); + w.mergeIfNeeded(1); } } @@ -648,7 +648,7 @@ final int count = warmer.warmCount; writer.addDocument(DocHelper.createDocument(17, "test", 4)); - writer.optimize(); + writer.mergeIfNeeded(1); assertTrue(warmer.warmCount > count); writer.close(); Index: lucene/src/test/org/apache/lucene/index/TestAddIndexes.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestAddIndexes.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestAddIndexes.java (working copy) @@ -103,7 +103,7 @@ assertEquals(40, writer.maxDoc()); writer.close(); - // test doc count before segments are merged/index is optimized + // test doc count before segments are merged writer = newWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)).setOpenMode(OpenMode.APPEND)); assertEquals(190, writer.maxDoc()); writer.addIndexes(aux3); @@ -117,9 +117,9 @@ verifyTermDocs(dir, new Term("content", "bbb"), 50); - // now optimize it. + // now fully merge it. writer = newWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)).setOpenMode(OpenMode.APPEND)); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); // make sure the new index is correct @@ -176,7 +176,7 @@ q.add(new Term("content", "14")); writer.deleteDocuments(q); - writer.optimize(); + writer.mergeIfNeeded(1); writer.commit(); verifyNumDocs(dir, 1039); @@ -214,7 +214,7 @@ q.add(new Term("content", "14")); writer.deleteDocuments(q); - writer.optimize(); + writer.mergeIfNeeded(1); writer.commit(); verifyNumDocs(dir, 1039); @@ -252,7 +252,7 @@ writer.addIndexes(aux); - writer.optimize(); + writer.mergeIfNeeded(1); writer.commit(); verifyNumDocs(dir, 1039); @@ -721,10 +721,10 @@ switch(j%5) { case 0: if (VERBOSE) { - System.out.println(Thread.currentThread().getName() + ": TEST: addIndexes(Dir[]) then optimize"); + System.out.println(Thread.currentThread().getName() + ": TEST: addIndexes(Dir[]) then full merge"); } writer2.addIndexes(dirs); - writer2.optimize(); + writer2.mergeIfNeeded(1); break; case 1: if (VERBOSE) { @@ -827,10 +827,10 @@ switch(j%5) { case 0: if (VERBOSE) { - System.out.println("TEST: " + Thread.currentThread().getName() + ": addIndexes + optimize"); + System.out.println("TEST: " + Thread.currentThread().getName() + ": addIndexes + full merge"); } writer2.addIndexes(dirs); - writer2.optimize(); + writer2.mergeIfNeeded(1); break; case 1: if (VERBOSE) { @@ -846,9 +846,9 @@ break; case 3: if (VERBOSE) { - System.out.println("TEST: " + Thread.currentThread().getName() + ": optimize"); + System.out.println("TEST: " + Thread.currentThread().getName() + ": full merge"); } - writer2.optimize(); + writer2.mergeIfNeeded(1); break; case 4: if (VERBOSE) { Index: lucene/src/test/org/apache/lucene/index/TestPayloads.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestPayloads.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestPayloads.java (working copy) @@ -134,7 +134,7 @@ writer.addDocument(d); // force merge - writer.optimize(); + writer.mergeIfNeeded(1); // flush writer.close(); @@ -204,7 +204,7 @@ writer.addDocument(d, analyzer); } - writer.optimize(); + writer.mergeIfNeeded(1); // flush writer.close(); @@ -322,7 +322,7 @@ writer.addDocument(d); - writer.optimize(); + writer.mergeIfNeeded(1); // flush writer.close(); @@ -621,7 +621,7 @@ doc.add(new Field("hasMaybepayload2", "here we go", TextField.TYPE_STORED)); writer.addDocument(doc); writer.addDocument(doc); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); dir.close(); Index: lucene/src/test/org/apache/lucene/index/TestTieredMergePolicy.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestTieredMergePolicy.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestTieredMergePolicy.java (working copy) @@ -66,7 +66,7 @@ dir.close(); } - public void testPartialOptimize() throws Exception { + public void testPartialMerge() throws Exception { int num = atLeast(10); for(int iter=0;iter names = new ArrayList(oldNames.length + oldOptimizedNames.length); + List names = new ArrayList(oldNames.length + oldSingleSegmentNames.length); names.addAll(Arrays.asList(oldNames)); - names.addAll(Arrays.asList(oldOptimizedNames)); + names.addAll(Arrays.asList(oldSingleSegmentNames)); for(String name : names) { if (VERBOSE) { System.out.println("testUpgradeOldIndex: index=" +name); @@ -764,16 +764,16 @@ } } - public void testUpgradeOldOptimizedIndexWithAdditions() throws Exception { - for (String name : oldOptimizedNames) { + public void testUpgradeOldSingleSegmentIndexWithAdditions() throws Exception { + for (String name : oldSingleSegmentNames) { if (VERBOSE) { - System.out.println("testUpgradeOldOptimizedIndexWithAdditions: index=" +name); + System.out.println("testUpgradeOldSingleSegmentIndexWithAdditions: index=" +name); } File oldIndxeDir = _TestUtil.getTempDir(name); _TestUtil.unzip(getDataFile("index." + name + ".zip"), oldIndxeDir); Directory dir = newFSDirectory(oldIndxeDir); - assertEquals("Original index must be optimized", 1, getNumberOfSegments(dir)); + assertEquals("Original index must be single segment", 1, getNumberOfSegments(dir)); // create a bunch of dummy segments int id = 40; @@ -791,7 +791,8 @@ w.close(false); } - // add dummy segments (which are all in current version) to optimized index + // add dummy segments (which are all in current + // version) to single segment index MergePolicy mp = random.nextBoolean() ? newLogMergePolicy() : newTieredMergePolicy(); IndexWriterConfig iwc = new IndexWriterConfig(TEST_VERSION_CURRENT, null) .setMergePolicy(mp); Index: lucene/src/test/org/apache/lucene/index/TestLazyProxSkipping.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestLazyProxSkipping.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestLazyProxSkipping.java (working copy) @@ -102,7 +102,7 @@ } // make sure the index has only a single segment - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); SegmentReader reader = getOnlySegmentReader(IndexReader.open(directory, false)); Index: lucene/src/test/org/apache/lucene/index/TestNorms.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestNorms.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestNorms.java (working copy) @@ -36,7 +36,7 @@ /** * Test that norms info is preserved during index life - including - * separate norms, addDocument, addIndexes, optimize. + * separate norms, addDocument, addIndexes, mergeIfNeeded. */ public class TestNorms extends LuceneTestCase { @@ -74,7 +74,7 @@ * Test that norms values are preserved as the index is maintained. * Including separate norms. * Including merging indexes with seprate norms. - * Including optimize. + * Including mergeIfNeeded. */ public void testNorms() throws IOException { Directory dir1 = newDirectory(); @@ -111,7 +111,7 @@ setMergePolicy(newLogMergePolicy(3)) ); iw.addIndexes(dir1,dir2); - iw.optimize(); + iw.mergeIfNeeded(1); iw.close(); norms1.addAll(norms); @@ -124,7 +124,7 @@ verifyIndex(dir3); doTestNorms(random, dir3); - // now with optimize + // now with single segment iw = new IndexWriter( dir3, newIndexWriterConfig(TEST_VERSION_CURRENT, anlzr). @@ -132,7 +132,7 @@ setMaxBufferedDocs(5). setMergePolicy(newLogMergePolicy(3)) ); - iw.optimize(); + iw.mergeIfNeeded(1); iw.close(); verifyIndex(dir3); Index: lucene/src/test/org/apache/lucene/index/TestStressAdvance.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestStressAdvance.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestStressAdvance.java (working copy) @@ -52,7 +52,7 @@ w.addDocument(doc); } - w.optimize(); + w.mergeIfNeeded(1); final List aDocIDs = new ArrayList(); final List bDocIDs = new ArrayList(); Index: lucene/src/test/org/apache/lucene/index/TestIndexWriterUnicode.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestIndexWriterUnicode.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestIndexWriterUnicode.java (working copy) @@ -326,9 +326,9 @@ // Test multi segment r.close(); - writer.optimize(); + writer.mergeIfNeeded(1); - // Test optimized single segment + // Test single segment r = writer.getReader(); checkTermsOrder(r, allTerms, true); r.close(); Index: lucene/src/test/org/apache/lucene/index/TestIndexReaderClone.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestIndexReaderClone.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestIndexReaderClone.java (working copy) @@ -192,15 +192,15 @@ } // open non-readOnly reader1 on multi-segment index, then - // optimize the index, then clone to readOnly reader2 - public void testReadOnlyCloneAfterOptimize() throws Exception { + // fully merge the index, then clone to readOnly reader2 + public void testReadOnlyCloneAfterFullMerge() throws Exception { final Directory dir1 = newDirectory(); TestIndexReaderReopen.createIndex(random, dir1, true); IndexReader reader1 = IndexReader.open(dir1, false); IndexWriter w = new IndexWriter(dir1, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random))); - w.optimize(); + w.mergeIfNeeded(1); w.close(); IndexReader reader2 = reader1.clone(true); assertTrue(isReadOnly(reader2)); Index: lucene/src/test/org/apache/lucene/index/TestNoMergePolicy.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestNoMergePolicy.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestNoMergePolicy.java (working copy) @@ -31,7 +31,7 @@ public void testNoMergePolicy() throws Exception { MergePolicy mp = NoMergePolicy.NO_COMPOUND_FILES; assertNull(mp.findMerges(null)); - assertNull(mp.findMergesForOptimize(null, 0, null)); + assertNull(mp.findMerges(null, 0, null)); assertNull(mp.findMergesToExpungeDeletes(null)); assertFalse(mp.useCompoundFile(null, null)); mp.close(); Index: lucene/src/test/org/apache/lucene/index/TestDocCount.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestDocCount.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestDocCount.java (working copy) @@ -42,7 +42,7 @@ IndexReader ir = iw.getReader(); verifyCount(ir); ir.close(); - iw.optimize(); + iw.mergeIfNeeded(1); ir = iw.getReader(); verifyCount(ir); ir.close(); Index: lucene/src/test/org/apache/lucene/index/TestIndexReader.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestIndexReader.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestIndexReader.java (working copy) @@ -95,18 +95,18 @@ IndexReader r3 = IndexReader.openIfChanged(r2); assertNotNull(r3); assertFalse(c.equals(r3.getIndexCommit())); - assertFalse(r2.getIndexCommit().isOptimized()); + assertFalse(r2.getIndexCommit().getSegmentCount() == 1); r3.close(); writer = new IndexWriter(d, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)) .setOpenMode(OpenMode.APPEND)); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); r3 = IndexReader.openIfChanged(r2); assertNotNull(r3); - assertTrue(r3.getIndexCommit().isOptimized()); + assertEquals(1, r3.getIndexCommit().getSegmentCount()); r2.close(); r3.close(); d.close(); @@ -381,11 +381,11 @@ assertEquals(bin[i], bytesRef.bytes[i + bytesRef.offset]); } reader.close(); - // force optimize + // force merge writer = new IndexWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)).setOpenMode(OpenMode.APPEND).setMergePolicy(newLogMergePolicy())); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); reader = IndexReader.open(dir, false); doc2 = reader.document(reader.maxDoc() - 1); @@ -721,7 +721,7 @@ // [incorrectly] hit a "docs out of order" // IllegalStateException because above out-of-bounds // deleteDocument corrupted the index: - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); if (!gotException) { fail("delete of out-of-bounds doc number failed to hit exception"); @@ -846,7 +846,9 @@ assertEquals("IndexReaders have different values for numDocs.", index1.numDocs(), index2.numDocs()); assertEquals("IndexReaders have different values for maxDoc.", index1.maxDoc(), index2.maxDoc()); assertEquals("Only one IndexReader has deletions.", index1.hasDeletions(), index2.hasDeletions()); - assertEquals("Only one index is optimized.", index1.isOptimized(), index2.isOptimized()); + if (!(index1 instanceof ParallelReader)) { + assertEquals("Single segment test differs.", index1.getSequentialSubReaders().length == 1, index2.getSequentialSubReaders().length == 1); + } // check field names Collection fields1 = index1.getFieldNames(FieldOption.ALL); @@ -970,19 +972,19 @@ IndexReader r2 = IndexReader.openIfChanged(r); assertNotNull(r2); assertFalse(c.equals(r2.getIndexCommit())); - assertFalse(r2.getIndexCommit().isOptimized()); + assertFalse(r2.getIndexCommit().getSegmentCount() == 1); r2.close(); writer = new IndexWriter(d, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)) .setOpenMode(OpenMode.APPEND)); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); r2 = IndexReader.openIfChanged(r); assertNotNull(r2); assertNull(IndexReader.openIfChanged(r2)); - assertTrue(r2.getIndexCommit().isOptimized()); + assertEquals(1, r2.getIndexCommit().getSegmentCount()); r.close(); r2.close(); @@ -1032,7 +1034,7 @@ writer = new IndexWriter(d, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)) .setOpenMode(OpenMode.APPEND)); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); // Make sure reopen to a single segment is still readonly: Index: lucene/src/test/org/apache/lucene/index/TestStressIndexing2.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestStressIndexing2.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestStressIndexing2.java (working copy) @@ -180,7 +180,7 @@ threads[i].join(); } - // w.optimize(); + // w.mergeIfNeeded(1); //w.close(); for (int i=0; i files = Arrays.asList(dir.listAll()); assertTrue(files.contains("_0.cfs")); w.addDocument(doc); - w.optimize(); + w.mergeIfNeeded(1); if (iter == 1) { w.commit(); } @@ -1449,10 +1449,10 @@ // NOTE: here we rely on "Windows" behavior, ie, even // though IW wanted to delete _0.cfs since it was - // optimized away, because we have a reader open + // merged away, because we have a reader open // against this file, it should still be here: assertTrue(files.contains("_0.cfs")); - // optimize created this + // mergeIfNeeded created this //assertTrue(files.contains("_2.cfs")); w.deleteUnusedFiles(); @@ -1700,7 +1700,7 @@ } s.close(); r.close(); - w.optimize(); + w.mergeIfNeeded(1); } } w.close(); Index: lucene/src/test/org/apache/lucene/index/TestMultiLevelSkipList.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestMultiLevelSkipList.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestMultiLevelSkipList.java (working copy) @@ -76,7 +76,7 @@ writer.addDocument(d1); } writer.commit(); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); IndexReader reader = getOnlySegmentReader(IndexReader.open(dir)); Index: lucene/src/test/org/apache/lucene/index/TestTermVectorsWriter.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestTermVectorsWriter.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestTermVectorsWriter.java (working copy) @@ -315,7 +315,7 @@ document.add(termVectorField); writer.addDocument(document); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); IndexReader reader = IndexReader.open(dir, true); @@ -333,7 +333,7 @@ Directory[] indexDirs = {new MockDirectoryWrapper(random, new RAMDirectory(dir, newIOContext(random)))}; writer.addIndexes(indexDirs); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); } dir.close(); @@ -369,7 +369,7 @@ Field termVectorField = newField("termVector", "termVector", customType2); document.add(termVectorField); writer.addDocument(document); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); IndexReader reader = IndexReader.open(dir, true); @@ -414,7 +414,7 @@ for(int i=0;i<6;i++) writer.addDocument(document); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); IndexReader reader = IndexReader.open(dir, true); @@ -452,7 +452,7 @@ // Make 2nd segment iw.commit(); - iw.optimize(); + iw.mergeIfNeeded(1); iw.close(); dir.close(); } @@ -476,7 +476,7 @@ // Make first segment iw.commit(); - iw.optimize(); + iw.mergeIfNeeded(1); FieldType customType2 = new FieldType(StringField.TYPE_UNSTORED); customType2.setStoreTermVectors(true); @@ -484,7 +484,7 @@ iw.addDocument(document); // Make 2nd segment iw.commit(); - iw.optimize(); + iw.mergeIfNeeded(1); iw.close(); dir.close(); Index: lucene/src/test/org/apache/lucene/index/TestCodecs.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestCodecs.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestCodecs.java (working copy) @@ -366,7 +366,7 @@ assertEquals(2, results.length); assertEquals(0, results[0].doc); - writer.optimize(); + writer.mergeIfNeeded(1); // optimise to merge the segments. results = this.search(writer, pq, 5); Index: lucene/src/test/org/apache/lucene/index/TestThreadedOptimize.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestThreadedOptimize.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestThreadedOptimize.java (working copy) @@ -31,6 +31,7 @@ import java.util.Random; +// nocommit rename public class TestThreadedOptimize extends LuceneTestCase { private static final Analyzer ANALYZER = new MockAnalyzer(random, MockTokenizer.SIMPLE, true); @@ -86,7 +87,7 @@ public void run() { try { for(int j=0;j segmentsToOptimize) + public MergeSpecification findMerges(SegmentInfos segmentInfos, + int maxSegmentCount, Map segmentsToMerge) throws CorruptIndexException, IOException { return null; } Index: lucene/src/test/org/apache/lucene/index/codecs/preflex/TestTermInfosReaderIndex.java =================================================================== --- lucene/src/test/org/apache/lucene/index/codecs/preflex/TestTermInfosReaderIndex.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/codecs/preflex/TestTermInfosReaderIndex.java (working copy) @@ -182,7 +182,7 @@ } writer.addDocument(document); } - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); return config.getTermIndexInterval(); } Index: lucene/src/test/org/apache/lucene/index/TestDeletionPolicy.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestDeletionPolicy.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestDeletionPolicy.java (working copy) @@ -74,7 +74,7 @@ public void onCommit(List commits) throws IOException { IndexCommit lastCommit = commits.get(commits.size()-1); IndexReader r = IndexReader.open(dir, true); - assertEquals("lastCommit.isOptimized()=" + lastCommit.isOptimized() + " vs IndexReader.isOptimized=" + r.isOptimized(), r.isOptimized(), lastCommit.isOptimized()); + assertEquals("lastCommit.segmentCount()=" + lastCommit.getSegmentCount() + " vs IndexReader.segmentCount=" + r.getSequentialSubReaders().length, r.getSequentialSubReaders().length, lastCommit.getSegmentCount()); r.close(); verifyCommitOrder(commits); numOnCommit++; @@ -317,13 +317,13 @@ } writer.close(); - final boolean isOptimized; + final boolean needsMerging; { IndexReader r = IndexReader.open(dir); - isOptimized = r.isOptimized(); + needsMerging = r.getSequentialSubReaders().length != 1; r.close(); } - if (!isOptimized) { + if (needsMerging) { conf = newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)).setOpenMode( OpenMode.APPEND).setIndexDeletionPolicy(policy); @@ -332,23 +332,23 @@ ((LogMergePolicy) mp).setUseCompoundFile(useCompoundFile); } if (VERBOSE) { - System.out.println("TEST: open writer for optimize"); + System.out.println("TEST: open writer for merging"); } writer = new IndexWriter(dir, conf); writer.setInfoStream(VERBOSE ? System.out : null); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); } - assertEquals(isOptimized ? 0:1, policy.numOnInit); + assertEquals(needsMerging ? 1:0, policy.numOnInit); // If we are not auto committing then there should // be exactly 2 commits (one per close above): - assertEquals(1 + (isOptimized ? 0:1), policy.numOnCommit); + assertEquals(1 + (needsMerging ? 1:0), policy.numOnCommit); // Test listCommits Collection commits = IndexReader.listCommits(dir); // 2 from closing writer - assertEquals(1 + (isOptimized ? 0:1), commits.size()); + assertEquals(1 + (needsMerging ? 1:0), commits.size()); // Make sure we can open a reader on each commit: for (final IndexCommit commit : commits) { @@ -419,16 +419,16 @@ } assertTrue(lastCommit != null); - // Now add 1 doc and optimize + // Now add 1 doc and merge writer = new IndexWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)).setIndexDeletionPolicy(policy)); addDoc(writer); assertEquals(11, writer.numDocs()); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); assertEquals(6, IndexReader.listCommits(dir).size()); - // Now open writer on the commit just before optimize: + // Now open writer on the commit just before merge: writer = new IndexWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)) .setIndexDeletionPolicy(policy).setIndexCommit(lastCommit)); assertEquals(10, writer.numDocs()); @@ -437,8 +437,8 @@ writer.rollback(); IndexReader r = IndexReader.open(dir, true); - // Still optimized, still 11 docs - assertTrue(r.isOptimized()); + // Still merged, still 11 docs + assertEquals(1, r.getSequentialSubReaders().length); assertEquals(11, r.numDocs()); r.close(); @@ -452,39 +452,39 @@ assertEquals(7, IndexReader.listCommits(dir).size()); r = IndexReader.open(dir, true); - // Not optimized because we rolled it back, and now only + // Not fully merged because we rolled it back, and now only // 10 docs - assertTrue(!r.isOptimized()); + assertTrue(r.getSequentialSubReaders().length > 1); assertEquals(10, r.numDocs()); r.close(); - // Reoptimize + // Re-merge writer = new IndexWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)).setIndexDeletionPolicy(policy)); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); r = IndexReader.open(dir, true); - assertTrue(r.isOptimized()); + assertEquals(1, r.getSequentialSubReaders().length); assertEquals(10, r.numDocs()); r.close(); - // Now open writer on the commit just before optimize, + // Now open writer on the commit just before merging, // but this time keeping only the last commit: writer = new IndexWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)).setIndexCommit(lastCommit)); assertEquals(10, writer.numDocs()); - // Reader still sees optimized index, because writer + // Reader still sees fully merged index, because writer // opened on the prior commit has not yet committed: r = IndexReader.open(dir, true); - assertTrue(r.isOptimized()); + assertEquals(1, r.getSequentialSubReaders().length); assertEquals(10, r.numDocs()); r.close(); writer.close(); - // Now reader sees unoptimized index: + // Now reader sees not-fully-merged index: r = IndexReader.open(dir, true); - assertTrue(!r.isOptimized()); + assertTrue(r.getSequentialSubReaders().length > 1); assertEquals(10, r.numDocs()); r.close(); @@ -526,7 +526,7 @@ ((LogMergePolicy) mp).setUseCompoundFile(true); } writer = new IndexWriter(dir, conf); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); assertEquals(1, policy.numOnInit); @@ -570,7 +570,7 @@ for(int i=0;i<17;i++) { addDoc(writer); } - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); } @@ -675,15 +675,15 @@ ((LogMergePolicy) mp).setUseCompoundFile(useCompoundFile); } IndexReader r = IndexReader.open(dir); - final boolean wasOptimized = r.isOptimized(); + final boolean wasFullyMerged = r.getSequentialSubReaders().length == 1; r.close(); writer = new IndexWriter(dir, conf); - writer.optimize(); + writer.mergeIfNeeded(1); // this is a commit writer.close(); assertEquals(2*(N+1)+1, policy.numOnInit); - assertEquals(2*(N+2) - (wasOptimized ? 1:0), policy.numOnCommit); + assertEquals(2*(N+2) - (wasFullyMerged ? 1:0), policy.numOnCommit); IndexSearcher searcher = new IndexSearcher(dir, false); ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs; Index: lucene/src/test/org/apache/lucene/index/TestPerFieldCodecSupport.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestPerFieldCodecSupport.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestPerFieldCodecSupport.java (working copy) @@ -106,7 +106,7 @@ writer.commit(); assertEquals(30, writer.maxDoc()); _TestUtil.checkIndex(dir, provider); - writer.optimize(); + writer.mergeIfNeeded(1); assertEquals(30, writer.maxDoc()); writer.close(); dir.close(); @@ -178,12 +178,12 @@ assertEquals(40, writer.maxDoc()); if (VERBOSE) { - System.out.println("TEST: now optimize"); + System.out.println("TEST: now full merge"); } - writer.optimize(); + writer.mergeIfNeeded(1); assertEquals(40, writer.maxDoc()); writer.close(); - assertCodecPerFieldOptimized(_TestUtil.checkIndex(dir, provider), + assertCodecPerFieldFullyMerged(_TestUtil.checkIndex(dir, provider), "content", newContentCodec); assertQuery(new Term("content", "ccc"), dir, 10, provider); assertQuery(new Term("content", "bbb"), dir, 20, provider); @@ -192,7 +192,7 @@ dir.close(); } - public void assertCodecPerFieldOptimized(Status checkIndex, String field, + public void assertCodecPerFieldFullyMerged(Status checkIndex, String field, Codec codec) { assertEquals(1, checkIndex.segmentInfos.size()); final CodecProvider provider = checkIndex.segmentInfos.get(0).codec.provider; @@ -307,7 +307,7 @@ writer.addDocument(doc); } if (random.nextBoolean()) { - writer.optimize(); + writer.mergeIfNeeded(1); } writer.commit(); assertEquals((i + 1) * docsPerRound, writer.maxDoc()); Index: lucene/src/test/org/apache/lucene/index/TestParallelReaderEmptyIndex.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestParallelReaderEmptyIndex.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestParallelReaderEmptyIndex.java (working copy) @@ -58,7 +58,7 @@ // When unpatched, Lucene crashes here with a NoSuchElementException (caused by ParallelTermEnum) iwOut.addIndexes(pr); - iwOut.optimize(); + iwOut.mergeIfNeeded(1); iwOut.close(); rdOut.close(); rd1.close(); @@ -88,7 +88,7 @@ ir.close(); iw = new IndexWriter(rd1, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)).setOpenMode(OpenMode.APPEND)); - iw.optimize(); + iw.mergeIfNeeded(1); iw.close(); } @@ -116,7 +116,7 @@ rd1.close(); rd2.close(); - iwOut.optimize(); + iwOut.mergeIfNeeded(1); iwOut.close(); rdOut.close(); Index: lucene/src/test/org/apache/lucene/index/TestOptimizeForever.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestOptimizeForever.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestOptimizeForever.java (working copy) @@ -28,12 +28,13 @@ import org.apache.lucene.util._TestUtil; +// nocommit rename public class TestOptimizeForever extends LuceneTestCase { - // Just counts how many merges are done for optimize + // Just counts how many merges are done private static class MyIndexWriter extends IndexWriter { - AtomicInteger optimizeMergeCount = new AtomicInteger(); + AtomicInteger mergeCount = new AtomicInteger(); private boolean first; public MyIndexWriter(Directory dir, IndexWriterConfig conf) throws Exception { @@ -42,12 +43,12 @@ @Override public void merge(MergePolicy.OneMerge merge) throws CorruptIndexException, IOException { - if (merge.optimize && (first || merge.segments.size() == 1)) { + if (merge.maxNumSegments != -1 && (first || merge.segments.size() == 1)) { first = false; if (VERBOSE) { - System.out.println("TEST: optimized merge"); + System.out.println("TEST: maxNumSegments merge"); } - optimizeMergeCount.incrementAndGet(); + mergeCount.incrementAndGet(); } super.merge(merge); } @@ -58,7 +59,7 @@ final MyIndexWriter w = new MyIndexWriter(d, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random))); w.setInfoStream(VERBOSE ? System.out : null); - // Try to make an index that requires optimizing: + // Try to make an index that requires merging: w.getConfig().setMaxBufferedDocs(_TestUtil.nextInt(random, 2, 11)); final int numStartDocs = atLeast(20); final LineFileDocs docs = new LineFileDocs(random); @@ -96,10 +97,10 @@ } }; t.start(); - w.optimize(); + w.mergeIfNeeded(1); doStop.set(true); t.join(); - assertTrue("optimize count is " + w.optimizeMergeCount.get(), w.optimizeMergeCount.get() <= 1); + assertTrue("merge count is " + w.mergeCount.get(), w.mergeCount.get() <= 1); w.close(); d.close(); } Index: lucene/src/test/org/apache/lucene/index/TestConsistentFieldNumbers.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestConsistentFieldNumbers.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/index/TestConsistentFieldNumbers.java (working copy) @@ -76,7 +76,7 @@ assertEquals("f4", fis2.fieldInfo(3).name); writer = new IndexWriter(dir, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random))); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); sis = new SegmentInfos(); @@ -140,7 +140,7 @@ assertEquals("f4", fis2.fieldInfo(3).name); writer = new IndexWriter(dir1, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random))); - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); sis = new SegmentInfos(); @@ -251,7 +251,7 @@ IndexWriter writer = new IndexWriter(dir, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)).setMergePolicy( new LogByteSizeMergePolicy())); - writer.optimize(); + writer.mergeIfNeeded(1); assertFalse(" field numbers got mixed up", writer.anyNonBulkMerges); writer.close(); @@ -293,7 +293,7 @@ writer.addDocument(d); } - writer.optimize(); + writer.mergeIfNeeded(1); writer.close(); SegmentInfos sis = new SegmentInfos(); Index: lucene/src/test/org/apache/lucene/store/TestRAMDirectory.java =================================================================== --- lucene/src/test/org/apache/lucene/store/TestRAMDirectory.java (revision 1197316) +++ lucene/src/test/org/apache/lucene/store/TestRAMDirectory.java (working copy) @@ -104,7 +104,7 @@ final IndexWriter writer = new IndexWriter(ramDir, new IndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)).setOpenMode(OpenMode.APPEND)); - writer.optimize(); + writer.mergeIfNeeded(1); assertEquals(ramDir.sizeInBytes(), ramDir.getRecomputedSizeInBytes()); @@ -131,7 +131,7 @@ for (int i=0; iThis method is not thread safe, be sure to only call it when no query is running! * If you re-use the same query instance for another * search, be sure to first reset the term counter * with {@link #clearTotalNumberOfTerms}. - *

On optimized indexes / no MultiReaders, you get the correct number of + *

On single-segment indexes / no MultiReaders, you get the correct number of * unique terms for the whole index. Use this number to compare different queries. - * For non-optimized indexes this number can also be achieved in + * For multi-segment indexes this number can also be achieved in * non-constant-score mode. In constant-score mode you get the total number of * terms seeked for all segments / sub-readers. * @see #clearTotalNumberOfTerms Index: lucene/src/java/org/apache/lucene/index/LogDocMergePolicy.java =================================================================== --- lucene/src/java/org/apache/lucene/index/LogDocMergePolicy.java (revision 1197316) +++ lucene/src/java/org/apache/lucene/index/LogDocMergePolicy.java (working copy) @@ -31,10 +31,10 @@ public LogDocMergePolicy() { minMergeSize = DEFAULT_MIN_MERGE_DOCS; - // maxMergeSize(ForOptimize) are never used by LogDocMergePolicy; set + // maxMergeSize(ForMergeIfNeeded) are never used by LogDocMergePolicy; set // it to Long.MAX_VALUE to disable it maxMergeSize = Long.MAX_VALUE; - maxMergeSizeForOptimize = Long.MAX_VALUE; + maxMergeSizeForMergeIfNeeded = Long.MAX_VALUE; } @Override Index: lucene/src/java/org/apache/lucene/index/IndexUpgrader.java =================================================================== --- lucene/src/java/org/apache/lucene/index/IndexUpgrader.java (revision 1197316) +++ lucene/src/java/org/apache/lucene/index/IndexUpgrader.java (working copy) @@ -34,7 +34,7 @@ * java -cp lucene-core.jar org.apache.lucene.index.IndexUpgrader [-delete-prior-commits] [-verbose] indexDir * * Alternatively this class can be instantiated and {@link #upgrade} invoked. It uses {@link UpgradeIndexMergePolicy} - * and triggers the upgrade via an optimize request to {@link IndexWriter}. + * and triggers the upgrade via an mergeIfNeeded request to {@link IndexWriter}. *

This tool keeps only the last commit in an index; for this * reason, if the incoming index has more than one commit, the tool * refuses to run by default. Specify {@code -delete-prior-commits} @@ -44,7 +44,7 @@ *

Warning: This tool may reorder documents if the index was partially * upgraded before execution (e.g., documents were added). If your application relies * on "monotonicity" of doc IDs (which means that the order in which the documents - * were added to the index is preserved), do a full optimize instead. + * were added to the index is preserved), do a full mergeIfNeeded instead. * The {@link MergePolicy} set by {@link IndexWriterConfig} may also reorder * documents. */ @@ -133,7 +133,7 @@ try { w.setInfoStream(infoStream); w.message("Upgrading all pre-" + Constants.LUCENE_MAIN_VERSION + " segments of index directory '" + dir + "' to version " + Constants.LUCENE_MAIN_VERSION + "..."); - w.optimize(); + w.mergeIfNeeded(1); w.message("All segments upgraded to version " + Constants.LUCENE_MAIN_VERSION); } finally { w.close(); Index: lucene/src/java/org/apache/lucene/index/ParallelReader.java =================================================================== --- lucene/src/java/org/apache/lucene/index/ParallelReader.java (revision 1197316) +++ lucene/src/java/org/apache/lucene/index/ParallelReader.java (working copy) @@ -477,23 +477,6 @@ return true; } - /** - * Checks recursively if all subindexes are optimized - */ - @Override - public boolean isOptimized() { - ensureOpen(); - for (final IndexReader reader : readers) { - if (!reader.isOptimized()) { - return false; - } - } - - // all subindexes are optimized - return true; - } - - /** Not implemented. * @throws UnsupportedOperationException */ Index: lucene/src/java/org/apache/lucene/index/UpgradeIndexMergePolicy.java =================================================================== --- lucene/src/java/org/apache/lucene/index/UpgradeIndexMergePolicy.java (revision 1197316) +++ lucene/src/java/org/apache/lucene/index/UpgradeIndexMergePolicy.java (working copy) @@ -26,24 +26,24 @@ import java.util.HashMap; /** This {@link MergePolicy} is used for upgrading all existing segments of - * an index when calling {@link IndexWriter#optimize()}. + * an index when calling {@link IndexWriter#mergeIfNeeded()}. * All other methods delegate to the base {@code MergePolicy} given to the constructor. * This allows for an as-cheap-as possible upgrade of an older index by only upgrading segments that - * are created by previous Lucene versions. Optimize does no longer really optimize - * it is just used to "optimize" older segment versions away. + * are created by previous Lucene versions. mergeIfNeeded does no longer really merge; + * it is just used to "mergeIfNeeded" older segment versions away. *

In general one would use {@link IndexUpgrader}, but for a fully customizeable upgrade, - * you can use this like any other {@code MergePolicy} and call {@link IndexWriter#optimize()}: + * you can use this like any other {@code MergePolicy} and call {@link IndexWriter#mergeIfNeeded()}: * 

   *  IndexWriterConfig iwc = new IndexWriterConfig(Version.LUCENE_XX, new KeywordAnalyzer());
   *  iwc.setMergePolicy(new UpgradeIndexMergePolicy(iwc.getMergePolicy()));
   *  IndexWriter w = new IndexWriter(dir, iwc);
-  *  w.optimize();
+  *  w.mergeIfNeeded(1);
   *  w.close();
   *
*

Warning: This merge policy may reorder documents if the index was partially - * upgraded before calling optimize (e.g., documents were added). If your application relies + * upgraded before calling mergeIfNeeded (e.g., documents were added). If your application relies * on "monotonicity" of doc IDs (which means that the order in which the documents - * were added to the index is preserved), do a full optimize instead. Please note, the + * were added to the index is preserved), do a mergeIfNeeded(1) instead. Please note, the * delegate {@code MergePolicy} may also reorder documents. * @lucene.experimental * @see IndexUpgrader @@ -52,7 +52,7 @@ protected final MergePolicy base; - /** Wrap the given {@link MergePolicy} and intercept optimize requests to + /** Wrap the given {@link MergePolicy} and intercept mergeIfNeeded requests to * only upgrade segments written with previous Lucene versions. */ public UpgradeIndexMergePolicy(MergePolicy base) { this.base = base; @@ -79,22 +79,22 @@ } @Override - public MergeSpecification findMergesForOptimize(SegmentInfos segmentInfos, int maxSegmentCount, Map segmentsToOptimize) throws CorruptIndexException, IOException { + public MergeSpecification findMerges(SegmentInfos segmentInfos, int maxSegmentCount, Map segmentsToMerge) throws CorruptIndexException, IOException { // first find all old segments final Map oldSegments = new HashMap(); for (final SegmentInfo si : segmentInfos) { - final Boolean v =segmentsToOptimize.get(si); + final Boolean v = segmentsToMerge.get(si); if (v != null && shouldUpgradeSegment(si)) { oldSegments.put(si, v); } } - if (verbose()) message("findMergesForOptimize: segmentsToUpgrade=" + oldSegments); + if (verbose()) message("findMerges: segmentsToUpgrade=" + oldSegments); if (oldSegments.isEmpty()) return null; - MergeSpecification spec = base.findMergesForOptimize(segmentInfos, maxSegmentCount, oldSegments); + MergeSpecification spec = base.findMerges(segmentInfos, maxSegmentCount, oldSegments); if (spec != null) { // remove all segments that are in merge specification from oldSegments, @@ -107,7 +107,7 @@ if (!oldSegments.isEmpty()) { if (verbose()) - message("findMergesForOptimize: " + base.getClass().getSimpleName() + + message("findMerges: " + base.getClass().getSimpleName() + " does not want to merge all old segments, merge remaining ones into new segment: " + oldSegments); final List newInfos = new ArrayList(); for (final SegmentInfo si : segmentInfos) { Index: lucene/src/java/org/apache/lucene/index/SnapshotDeletionPolicy.java =================================================================== --- lucene/src/java/org/apache/lucene/index/SnapshotDeletionPolicy.java (revision 1197316) +++ lucene/src/java/org/apache/lucene/index/SnapshotDeletionPolicy.java (working copy) @@ -136,8 +136,8 @@ } @Override - public boolean isOptimized() { - return cp.isOptimized(); + public int getSegmentCount() { + return cp.getSegmentCount(); } } @@ -340,7 +340,7 @@ * NOTE: while the snapshot is held, the files it references will not * be deleted, which will consume additional disk space in your index. If you * take a snapshot at a particularly bad time (say just before you call - * optimize()) then in the worst case this could consume an extra 1X of your + * mergeIfNeeded) then in the worst case this could consume an extra 1X of your * total index size, until you release the snapshot. * * @param id Index: lucene/src/java/org/apache/lucene/index/MergePolicy.java =================================================================== --- lucene/src/java/org/apache/lucene/index/MergePolicy.java (revision 1197316) +++ lucene/src/java/org/apache/lucene/index/MergePolicy.java (working copy) @@ -30,8 +30,7 @@ /** *

Expert: a MergePolicy determines the sequence of - * primitive merge operations to be used for overall merge - * and optimize operations.

+ * primitive merge operations.

* *

Whenever the segments in an index have been altered by * {@link IndexWriter}, either the addition of a newly @@ -42,8 +41,8 @@ * merges that are now required. This method returns a * {@link MergeSpecification} instance describing the set of * merges that should be done, or null if no merges are - * necessary. When IndexWriter.optimize is called, it calls - * {@link #findMergesForOptimize} and the MergePolicy should + * necessary. When IndexWriter.mergeifNeeded is called, it calls + * {@link #findMerges(SegmentInfos,int,Map)} and the MergePolicy should * then return the necessary merges.

* *

Note that the policy can return more than one merge at @@ -69,11 +68,10 @@ public static class OneMerge { SegmentInfo info; // used by IndexWriter - boolean optimize; // used by IndexWriter boolean registerDone; // used by IndexWriter long mergeGen; // used by IndexWriter boolean isExternal; // used by IndexWriter - int maxNumSegmentsOptimize; // used by IndexWriter + int maxNumSegments = -1; // used by IndexWriter public long estimatedMergeBytes; // used by IndexWriter List readers; // used by IndexWriter List readerLiveDocs; // used by IndexWriter @@ -160,8 +158,8 @@ } if (info != null) b.append(" into ").append(info.name); - if (optimize) - b.append(" [optimize]"); + if (maxNumSegments != -1) + b.append(" [maxNumSegments=" + maxNumSegments + "]"); if (aborted) { b.append(" [ABORTED]"); } @@ -193,7 +191,7 @@ } public MergeInfo getMergeInfo() { - return new MergeInfo(totalDocCount, estimatedMergeBytes, isExternal, optimize); + return new MergeInfo(totalDocCount, estimatedMergeBytes, isExternal, maxNumSegments); } } @@ -290,9 +288,9 @@ throws CorruptIndexException, IOException; /** - * Determine what set of merge operations is necessary in order to optimize - * the index. {@link IndexWriter} calls this when its - * {@link IndexWriter#optimize()} method is called. This call is always + * Determine what set of merge operations is necessary in + * order to merge to <= the specified segment count. {@link IndexWriter} calls this when its + * {@link IndexWriter#mergeIfNeeded} method is called. This call is always * synchronized on the {@link IndexWriter} instance so only one thread at a * time will call this method. * @@ -301,17 +299,17 @@ * @param maxSegmentCount * requested maximum number of segments in the index (currently this * is always 1) - * @param segmentsToOptimize + * @param segmentsToMerge * contains the specific SegmentInfo instances that must be merged * away. This may be a subset of all * SegmentInfos. If the value is True for a * given SegmentInfo, that means this segment was * an original segment present in the - * to-be-optimized index; else, it was a segment + * to-be-merged index; else, it was a segment * produced by a cascaded merge. */ - public abstract MergeSpecification findMergesForOptimize( - SegmentInfos segmentInfos, int maxSegmentCount, Map segmentsToOptimize) + public abstract MergeSpecification findMerges( + SegmentInfos segmentInfos, int maxSegmentCount, Map segmentsToMerge) throws CorruptIndexException, IOException; /** Index: lucene/src/java/org/apache/lucene/index/LogMergePolicy.java =================================================================== --- lucene/src/java/org/apache/lucene/index/LogMergePolicy.java (revision 1197316) +++ lucene/src/java/org/apache/lucene/index/LogMergePolicy.java (working copy) @@ -68,7 +68,7 @@ protected long maxMergeSize; // Although the core MPs set it explicitly, we must default in case someone // out there wrote his own LMP ... - protected long maxMergeSizeForOptimize = Long.MAX_VALUE; + protected long maxMergeSizeForMergeIfNeeded = Long.MAX_VALUE; protected int maxMergeDocs = DEFAULT_MAX_MERGE_DOCS; protected double noCFSRatio = DEFAULT_NO_CFS_RATIO; @@ -117,10 +117,10 @@ /** Determines how often segment indices are merged by * addDocument(). With smaller values, less RAM is used - * while indexing, and searches on unoptimized indices are + * while indexing, and searches are * faster, but indexing speed is slower. With larger * values, more RAM is used during indexing, and while - * searches on unoptimized indices are slower, indexing is + * searches is slower, indexing is * faster. Thus larger values (> 10) are best for batch * index creation, and smaller values (< 10) for indices * that are interactively maintained. */ @@ -201,29 +201,29 @@ } } - protected boolean isOptimized(SegmentInfos infos, int maxNumSegments, Map segmentsToOptimize) throws IOException { + protected boolean isMerged(SegmentInfos infos, int maxNumSegments, Map segmentsToMerge) throws IOException { final int numSegments = infos.size(); - int numToOptimize = 0; - SegmentInfo optimizeInfo = null; + int numToMerge = 0; + SegmentInfo mergeInfo = null; boolean segmentIsOriginal = false; - for(int i=0;i segments = infos.asList(); @@ -250,14 +250,15 @@ int start = last - 1; while (start >= 0) { SegmentInfo info = infos.info(start); - if (size(info) > maxMergeSizeForOptimize || sizeDocs(info) > maxMergeDocs) { + if (size(info) > maxMergeSizeForMergeIfNeeded || sizeDocs(info) > maxMergeDocs) { if (verbose()) { - message("optimize: skip segment=" + info + ": size is > maxMergeSize (" + maxMergeSizeForOptimize + ") or sizeDocs is > maxMergeDocs (" + maxMergeDocs + ")"); + message("findMergesSizeLimit: skip segment=" + info + ": size is > maxMergeSize (" + maxMergeSizeForMergeIfNeeded + ") or sizeDocs is > maxMergeDocs (" + maxMergeDocs + ")"); } // need to skip that segment + add a merge for the 'right' segments, - // unless there is only 1 which is optimized. - if (last - start - 1 > 1 || (start != last - 1 && !isOptimized(infos.info(start + 1)))) { - // there is more than 1 segment to the right of this one, or an unoptimized single segment. + // unless there is only 1 which is merged. + if (last - start - 1 > 1 || (start != last - 1 && !isMerged(infos.info(start + 1)))) { + // there is more than 1 segment to the right of + // this one, or a mergeable single segment. spec.add(new OneMerge(segments.subList(start + 1, last))); } last = start; @@ -269,8 +270,9 @@ --start; } - // Add any left-over segments, unless there is just 1 already optimized. - if (last > 0 && (++start + 1 < last || !isOptimized(infos.info(start)))) { + // Add any left-over segments, unless there is just 1 + // already fully merged + if (last > 0 && (++start + 1 < last || !isMerged(infos.info(start)))) { spec.add(new OneMerge(segments.subList(start, last))); } @@ -278,11 +280,11 @@ } /** - * Returns the merges necessary to optimize the index. This method constraints + * Returns the merges necessary to mergeIfNeeded the index. This method constraints * the returned merges only by the {@code maxNumSegments} parameter, and * guaranteed that exactly that number of segments will remain in the index. */ - private MergeSpecification findMergesForOptimizeMaxNumSegments(SegmentInfos infos, int maxNumSegments, int last) throws IOException { + private MergeSpecification findMergesMaxNumSegments(SegmentInfos infos, int maxNumSegments, int last) throws IOException { MergeSpecification spec = new MergeSpecification(); final List segments = infos.asList(); @@ -298,9 +300,9 @@ if (0 == spec.merges.size()) { if (maxNumSegments == 1) { - // Since we must optimize down to 1 segment, the + // Since we must merge down to 1 segment, the // choice is simple: - if (last > 1 || !isOptimized(infos.info(0))) { + if (last > 1 || !isMerged(infos.info(0))) { spec.add(new OneMerge(segments.subList(0, last))); } } else if (last > maxNumSegments) { @@ -313,7 +315,7 @@ // We must merge this many segments to leave // maxNumSegments in the index (from when - // optimize was first kicked off): + // mergeIfNeeded was first kicked off): final int finalMergeSize = last - maxNumSegments + 1; // Consider all possible starting points: @@ -336,10 +338,9 @@ return spec.merges.size() == 0 ? null : spec; } - /** Returns the merges necessary to optimize the index. - * This merge policy defines "optimized" to mean only the - * requested number of segments is left in the index, and - * respects the {@link #maxMergeSizeForOptimize} setting. + /** Returns the merges necessary to merge the index down + * to a specified number of segments. + * This respects the {@link #maxMergeSizeForMergeIfNeeded} setting. * By default, and assuming {@code maxNumSegments=1}, only * one segment will be left in the index, where that segment * has no deletions pending nor separate norms, and it is in @@ -348,30 +349,30 @@ * (mergeFactor at a time) so the {@link MergeScheduler} * in use may make use of concurrency. */ @Override - public MergeSpecification findMergesForOptimize(SegmentInfos infos, - int maxNumSegments, Map segmentsToOptimize) throws IOException { + public MergeSpecification findMerges(SegmentInfos infos, + int maxNumSegments, Map segmentsToMerge) throws IOException { assert maxNumSegments > 0; if (verbose()) { - message("findMergesForOptimize: maxNumSegs=" + maxNumSegments + " segsToOptimize="+ segmentsToOptimize); + message("findMerges: maxNumSegs=" + maxNumSegments + " segsToMerge="+ segmentsToMerge); } - // If the segments are already optimized (e.g. there's only 1 segment), or - // there are 0) { final SegmentInfo info = infos.info(--last); - if (segmentsToOptimize.get(info) != null) { + if (segmentsToMerge.get(info) != null) { last++; break; } @@ -384,8 +385,8 @@ return null; } - // There is only one segment already, and it is optimized - if (maxNumSegments == 1 && last == 1 && isOptimized(infos.info(0))) { + // There is only one segment already, and it is merged + if (maxNumSegments == 1 && last == 1 && isMerged(infos.info(0))) { if (verbose()) { message("already 1 seg; skip"); } @@ -396,16 +397,16 @@ boolean anyTooLarge = false; for (int i = 0; i < last; i++) { SegmentInfo info = infos.info(i); - if (size(info) > maxMergeSizeForOptimize || sizeDocs(info) > maxMergeDocs) { + if (size(info) > maxMergeSizeForMergeIfNeeded || sizeDocs(info) > maxMergeDocs) { anyTooLarge = true; break; } } if (anyTooLarge) { - return findMergesForOptimizeSizeLimit(infos, maxNumSegments, last); + return findMergesSizeLimit(infos, maxNumSegments, last); } else { - return findMergesForOptimizeMaxNumSegments(infos, maxNumSegments, last); + return findMergesMaxNumSegments(infos, maxNumSegments, last); } } @@ -655,7 +656,7 @@ sb.append("minMergeSize=").append(minMergeSize).append(", "); sb.append("mergeFactor=").append(mergeFactor).append(", "); sb.append("maxMergeSize=").append(maxMergeSize).append(", "); - sb.append("maxMergeSizeForOptimize=").append(maxMergeSizeForOptimize).append(", "); + sb.append("maxMergeSizeForMergeIfNeeded=").append(maxMergeSizeForMergeIfNeeded).append(", "); sb.append("calibrateSizeByDeletes=").append(calibrateSizeByDeletes).append(", "); sb.append("maxMergeDocs=").append(maxMergeDocs).append(", "); sb.append("useCompoundFile=").append(useCompoundFile).append(", "); Index: lucene/src/java/org/apache/lucene/index/MultiReader.java =================================================================== --- lucene/src/java/org/apache/lucene/index/MultiReader.java (revision 1197316) +++ lucene/src/java/org/apache/lucene/index/MultiReader.java (working copy) @@ -234,12 +234,6 @@ } @Override - public boolean isOptimized() { - ensureOpen(); - return false; - } - - @Override public int numDocs() { // Don't call ensureOpen() here (it could affect performance) // NOTE: multiple threads may wind up init'ing Index: lucene/src/java/org/apache/lucene/index/IndexCommit.java =================================================================== --- lucene/src/java/org/apache/lucene/index/IndexCommit.java (revision 1197316) +++ lucene/src/java/org/apache/lucene/index/IndexCommit.java (working copy) @@ -75,8 +75,8 @@ public abstract boolean isDeleted(); - /** Returns true if this commit is an optimized index. */ - public abstract boolean isOptimized(); + /** Returns number of segments referenced by this commit. */ + public abstract int getSegmentCount(); /** Two IndexCommits are equal if both their Directory and versions are equal. */ @Override Index: lucene/src/java/org/apache/lucene/index/DirectoryReader.java =================================================================== --- lucene/src/java/org/apache/lucene/index/DirectoryReader.java (revision 1197316) +++ lucene/src/java/org/apache/lucene/index/DirectoryReader.java (working copy) @@ -546,17 +546,7 @@ subReaders[i].getTermFreqVector(docNumber - starts[i], mapper); } - /** - * Checks is the index is optimized (if it has a single segment and no deletions) - * @return true if the index is optimized; false otherwise - */ @Override - public boolean isOptimized() { - ensureOpen(); - return segmentInfos.size() == 1 && !hasDeletions(); - } - - @Override public int numDocs() { // Don't call ensureOpen() here (it could affect performance) @@ -981,8 +971,8 @@ Directory dir; long generation; long version; - final boolean isOptimized; final Map userData; + private final int segmentCount; ReaderCommit(SegmentInfos infos, Directory dir) throws IOException { segmentsFileName = infos.getCurrentSegmentFileName(); @@ -991,7 +981,7 @@ files = Collections.unmodifiableCollection(infos.files(dir, true)); version = infos.getVersion(); generation = infos.getGeneration(); - isOptimized = infos.size() == 1 && !infos.info(0).hasDeletions(); + segmentCount = infos.size(); } @Override @@ -1000,8 +990,8 @@ } @Override - public boolean isOptimized() { - return isOptimized; + public int getSegmentCount() { + return segmentCount; } @Override Index: lucene/src/java/org/apache/lucene/index/LogByteSizeMergePolicy.java =================================================================== --- lucene/src/java/org/apache/lucene/index/LogByteSizeMergePolicy.java (revision 1197316) +++ lucene/src/java/org/apache/lucene/index/LogByteSizeMergePolicy.java (working copy) @@ -31,13 +31,13 @@ public static final double DEFAULT_MAX_MERGE_MB = 2048; /** Default maximum segment size. A segment of this size - * or larger will never be merged during optimize. @see setMaxMergeMBForOptimize */ - public static final double DEFAULT_MAX_MERGE_MB_FOR_OPTIMIZE = Long.MAX_VALUE; + * or larger will never be merged during mergeIfNeeded. @see setMaxMergeMBForMergeIfNeeded */ + public static final double DEFAULT_MAX_MERGE_MB_FOR_MERGE_IF_NEEDED = Long.MAX_VALUE; public LogByteSizeMergePolicy() { minMergeSize = (long) (DEFAULT_MIN_MERGE_MB*1024*1024); maxMergeSize = (long) (DEFAULT_MAX_MERGE_MB*1024*1024); - maxMergeSizeForOptimize = (long) (DEFAULT_MAX_MERGE_MB_FOR_OPTIMIZE*1024*1024); + maxMergeSizeForMergeIfNeeded = (long) (DEFAULT_MAX_MERGE_MB_FOR_MERGE_IF_NEEDED*1024*1024); } @Override @@ -70,19 +70,19 @@ /**

Determines the largest segment (measured by total * byte size of the segment's files, in MB) that may be - * merged with other segments during optimize. Setting + * merged with other segments during mergeIfNeeded. Setting * it low will leave the index with more than 1 segment, - * even if {@link IndexWriter#optimize()} is called.*/ - public void setMaxMergeMBForOptimize(double mb) { - maxMergeSizeForOptimize = (long) (mb*1024*1024); + * even if {@link IndexWriter#mergeIfNeeded} is called.*/ + public void setMaxMergeMBForMergeIfNeeded(double mb) { + maxMergeSizeForMergeIfNeeded = (long) (mb*1024*1024); } /** Returns the largest segment (measured by total byte * size of the segment's files, in MB) that may be merged - * with other segments during optimize. - * @see #setMaxMergeMBForOptimize */ - public double getMaxMergeMBForOptimize() { - return ((double) maxMergeSizeForOptimize)/1024/1024; + * with other segments during mergeIfNeeded. + * @see #setMaxMergeMBForMergeIfNeeded */ + public double getMaxMergeMBForMergeIfNeeded() { + return ((double) maxMergeSizeForMergeIfNeeded)/1024/1024; } /** Sets the minimum size for the lowest level segments. Index: lucene/src/java/org/apache/lucene/index/FilterIndexReader.java =================================================================== --- lucene/src/java/org/apache/lucene/index/FilterIndexReader.java (revision 1197316) +++ lucene/src/java/org/apache/lucene/index/FilterIndexReader.java (working copy) @@ -431,12 +431,6 @@ } @Override - public boolean isOptimized() { - ensureOpen(); - return in.isOptimized(); - } - - @Override public IndexReader[] getSequentialSubReaders() { return in.getSequentialSubReaders(); } Index: lucene/src/java/org/apache/lucene/index/TieredMergePolicy.java =================================================================== --- lucene/src/java/org/apache/lucene/index/TieredMergePolicy.java (revision 1197316) +++ lucene/src/java/org/apache/lucene/index/TieredMergePolicy.java (working copy) @@ -60,7 +60,7 @@ *

NOTE: This policy always merges by byte size * of the segments, always pro-rates by percent deletes, * and does not apply any maximum segment size during - * optimize (unlike {@link LogByteSizeMergePolicy}). + * mergeIfNeeded (unlike {@link LogByteSizeMergePolicy}). * * @lucene.experimental */ @@ -86,7 +86,7 @@ /** Maximum number of segments to be merged at a time * during "normal" merging. For explicit merging (eg, - * optimize or expungeDeletes was called), see {@link + * mergeIfNeeded or expungeDeletes was called), see {@link * #setMaxMergeAtOnceExplicit}. Default is 10. */ public TieredMergePolicy setMaxMergeAtOnce(int v) { if (v < 2) { @@ -105,7 +105,7 @@ // if user calls IW.maybeMerge "explicitly" /** Maximum number of segments to be merged at a time, - * during optimize or expungeDeletes. Default is 30. */ + * during mergeIfNeeded or expungeDeletes. Default is 30. */ public TieredMergePolicy setMaxMergeAtOnceExplicit(int v) { if (v < 2) { throw new IllegalArgumentException("maxMergeAtOnceExplicit must be > 1 (got " + v + ")"); @@ -476,23 +476,23 @@ } @Override - public MergeSpecification findMergesForOptimize(SegmentInfos infos, int maxSegmentCount, Map segmentsToOptimize) throws IOException { + public MergeSpecification findMerges(SegmentInfos infos, int maxSegmentCount, Map segmentsToMerge) throws IOException { if (verbose()) { - message("findMergesForOptimize maxSegmentCount=" + maxSegmentCount + " infos=" + writer.get().segString(infos) + " segmentsToOptimize=" + segmentsToOptimize); + message("findMerges maxSegmentCount=" + maxSegmentCount + " infos=" + writer.get().segString(infos) + " segmentsToMerge=" + segmentsToMerge); } List eligible = new ArrayList(); - boolean optimizeMergeRunning = false; + boolean mergeIfNeededRunning = false; final Collection merging = writer.get().getMergingSegments(); boolean segmentIsOriginal = false; for(SegmentInfo info : infos) { - final Boolean isOriginal = segmentsToOptimize.get(info); + final Boolean isOriginal = segmentsToMerge.get(info); if (isOriginal != null) { segmentIsOriginal = isOriginal; if (!merging.contains(info)) { eligible.add(info); } else { - optimizeMergeRunning = true; + mergeIfNeededRunning = true; } } } @@ -502,9 +502,9 @@ } if ((maxSegmentCount > 1 && eligible.size() <= maxSegmentCount) || - (maxSegmentCount == 1 && eligible.size() == 1 && (!segmentIsOriginal || isOptimized(eligible.get(0))))) { + (maxSegmentCount == 1 && eligible.size() == 1 && (!segmentIsOriginal || isMerged(eligible.get(0))))) { if (verbose()) { - message("already optimized"); + message("already merged"); } return null; } @@ -513,7 +513,7 @@ if (verbose()) { message("eligible=" + eligible); - message("optimizeMergeRunning=" + optimizeMergeRunning); + message("mergeIfNeededRunning=" + mergeIfNeededRunning); } int end = eligible.size(); @@ -533,7 +533,7 @@ end -= maxMergeAtOnceExplicit; } - if (spec == null && !optimizeMergeRunning) { + if (spec == null && !mergeIfNeededRunning) { // Do final merge final int numToMerge = end - maxSegmentCount + 1; final OneMerge merge = new OneMerge(eligible.subList(end-numToMerge, end)); @@ -578,7 +578,7 @@ while(start < eligible.size()) { // Don't enforce max merged size here: app is explicitly // calling expungeDeletes, and knows this may take a - // long time / produce big segments (like optimize): + // long time / produce big segments (like mergeIfNeeded): final int end = Math.min(start + maxMergeAtOnceExplicit, eligible.size()); if (spec == null) { spec = new MergeSpecification(); @@ -617,7 +617,7 @@ public void close() { } - private boolean isOptimized(SegmentInfo info) + private boolean isMerged(SegmentInfo info) throws IOException { IndexWriter w = writer.get(); assert w != null; Index: lucene/src/java/org/apache/lucene/index/NoMergePolicy.java =================================================================== --- lucene/src/java/org/apache/lucene/index/NoMergePolicy.java (revision 1197316) +++ lucene/src/java/org/apache/lucene/index/NoMergePolicy.java (working copy) @@ -58,8 +58,8 @@ throws CorruptIndexException, IOException { return null; } @Override - public MergeSpecification findMergesForOptimize(SegmentInfos segmentInfos, - int maxSegmentCount, Map segmentsToOptimize) + public MergeSpecification findMerges(SegmentInfos segmentInfos, + int maxSegmentCount, Map segmentsToMerge) throws CorruptIndexException, IOException { return null; } @Override Index: lucene/src/java/org/apache/lucene/index/IndexReader.java =================================================================== --- lucene/src/java/org/apache/lucene/index/IndexReader.java (revision 1197316) +++ lucene/src/java/org/apache/lucene/index/IndexReader.java (working copy) @@ -908,16 +908,6 @@ } /** - * Checks is the index is optimized (if it has a single segment and - * no deletions). Not implemented in the IndexReader base class. - * @return true if the index is optimized; false otherwise - * @throws UnsupportedOperationException unless overridden in subclass - */ - public boolean isOptimized() { - throw new UnsupportedOperationException("This reader does not support this method."); - } - - /** * Return an array of term frequency vectors for the specified document. * The array contains a vector for each vectorized field in the document. * Each vector contains terms and frequencies for all terms in a given vectorized field. Index: lucene/src/java/org/apache/lucene/index/IndexWriter.java =================================================================== --- lucene/src/java/org/apache/lucene/index/IndexWriter.java (revision 1197316) +++ lucene/src/java/org/apache/lucene/index/IndexWriter.java (working copy) @@ -103,11 +103,6 @@ addDocument calls (see below for changing the {@link MergeScheduler}).

-

If an index will not have more documents added for a while and optimal search - performance is desired, then either the full {@link #optimize() optimize} - method or partial {@link #optimize(int)} method should be - called before the index is closed.

-

Opening an IndexWriter creates a lock file for the directory in use. Trying to open another IndexWriter on the same directory will lead to a {@link LockObtainFailedException}. The {@link LockObtainFailedException} @@ -136,9 +131,8 @@ The {@link MergePolicy} is invoked whenever there are changes to the segments in the index. Its role is to select which merges to do, if any, and return a {@link - MergePolicy.MergeSpecification} describing the merges. It - also selects merges to do for optimize(). (The default is - {@link LogByteSizeMergePolicy}. Then, the {@link + MergePolicy.MergeSpecification} describing the merges. + The default is {@link LogByteSizeMergePolicy}. Then, the {@link MergeScheduler} is invoked with the requested merges and it decides when and how to run the merges. The default is {@link ConcurrentMergeScheduler}.

@@ -228,8 +222,9 @@ private DocumentsWriter docWriter; final IndexFileDeleter deleter; - private Map segmentsToOptimize = new HashMap(); // used by optimize to note those needing optimization - private int optimizeMaxNumSegments; + // used by mergeIfNeeded to note those needing merging + private Map segmentsToMerge = new HashMap(); + private int mergeMaxNumSegments; private Lock writeLock; @@ -1274,7 +1269,7 @@ * readers/searchers are open against the index, and up to * 2X the size of all segments being merged when * readers/searchers are open against the index (see - * {@link #optimize()} for details). The sequence of + * {@link #mergeIfNeeded(int)} for details). The sequence of * primitive merge operations performed is governed by the * merge policy. * @@ -1625,55 +1620,51 @@ private static PrintStream defaultInfoStream; /** - * Requests an "optimize" operation on an index, priming the index - * for the fastest available search. Traditionally this has meant - * merging all segments into a single segment as is done in the - * default merge policy, but individual merge policies may implement - * optimize in different ways. + * Performs merging as needed to reduce segment count + * down to <= maxNumSEgments. The actual merges to be + * executed are determined by the {@link MergePolicy}. * - *

Optimize is a very costly operation, so you - * should only do it if your search performance really - * requires it. Many search applications do fine never - * calling optimize.

+ *

This is a very costly operation, especially when + * you pass a small {@code maxNumSegments}. Rarely is it + * necessary so think twice before doing it.

* - *

Note that optimize requires 2X the index size free + *

Note that this requires up to 2X the index size free * space in your Directory (3X if you're using compound * file format). For example, if your index size is 10 MB - * then you need 20 MB free for optimize to complete (30 + * then you need up to 20 MB free for this to complete (30 * MB if you're using compound file format). Also, - * it's best to call {@link #commit()} after the optimize - * completes to allow IndexWriter to free up disk space.

+ * it's best to call {@link #commit()} afterwards, + * to allow IndexWriter to free up disk space.

* - *

If some but not all readers re-open while an - * optimize is underway, this will cause > 2X temporary + *

If some but not all readers re-open while merging + * is underway, this will cause > 2X temporary * space to be consumed as those new readers will then - * hold open the partially optimized segments at that - * time. It is best not to re-open readers while optimize - * is running.

+ * hold open the temporary segments at that time. It is + * best not to re-open readers while merging is running.

* *

The actual temporary usage could be much less than * these figures (it depends on many factors).

* - *

In general, once the optimize completes, the total size of the + *

In general, once the this completes, the total size of the * index will be less than the size of the starting index. * It could be quite a bit smaller (if there were many * pending deletes) or just slightly smaller.

* - *

If an Exception is hit during optimize(), for example + *

If an Exception is hit, for example * due to disk full, the index will not be corrupt and no * documents will have been lost. However, it may have - * been partially optimized (some segments were merged but + * been partially merged (some segments were merged but * not all), and it's possible that one of the segments in * the index will be in non-compound format even when * using compound file format. This will occur when the * Exception is hit during conversion of the segment into * compound format.

* - *

This call will optimize those segments present in + *

This call will merge those segments present in * the index when the call started. If other threads are * still adding documents and flushing segments, those - * newly created segments will not be optimized unless you - * call optimize again.

+ * newly created segments will not be merged unless you + * call mergeIfNeeded again.

* *

NOTE: if this method hits an OutOfMemoryError * you should immediately close the writer. See NOTE: if this method hits an OutOfMemoryError - * you should immediately close the writer. See above for details.

- * * @param maxNumSegments maximum number of segments left - * in the index after optimization finishes - */ - public void optimize(int maxNumSegments) throws CorruptIndexException, IOException { - optimize(maxNumSegments, true); + * in the index after merging finishes + */ + public void mergeIfNeeded(int maxNumSegments) throws CorruptIndexException, IOException { + mergeIfNeeded(maxNumSegments, true); } - /** Just like {@link #optimize()}, except you can specify - * whether the call should block until the optimize - * completes. This is only meaningful with a + /** Just like {@link #mergeIfNeeded(int)}, except you can + * specify whether the call should block until + * all merging completes. This is only meaningful with a * {@link MergeScheduler} that is able to run merges in * background threads. * @@ -1718,64 +1696,48 @@ * you should immediately close the writer. See above for details.

*/ - public void optimize(boolean doWait) throws CorruptIndexException, IOException { - optimize(1, doWait); - } - - /** Just like {@link #optimize(int)}, except you can - * specify whether the call should block until the - * optimize completes. This is only meaningful with a - * {@link MergeScheduler} that is able to run merges in - * background threads. - * - *

NOTE: if this method hits an OutOfMemoryError - * you should immediately close the writer. See above for details.

- */ - public void optimize(int maxNumSegments, boolean doWait) throws CorruptIndexException, IOException { + public void mergeIfNeeded(int maxNumSegments, boolean doWait) throws CorruptIndexException, IOException { ensureOpen(); if (maxNumSegments < 1) throw new IllegalArgumentException("maxNumSegments must be >= 1; got " + maxNumSegments); if (infoStream != null) { - message("optimize: index now " + segString()); - message("now flush at optimize"); + message("mergeIfNeede: index now " + segString()); + message("now flush at mergeIfNeeded"); } flush(true, true); synchronized(this) { resetMergeExceptions(); - segmentsToOptimize.clear(); + segmentsToMerge.clear(); for(SegmentInfo info : segmentInfos) { - segmentsToOptimize.put(info, Boolean.TRUE); + segmentsToMerge.put(info, Boolean.TRUE); } - optimizeMaxNumSegments = maxNumSegments; + mergeMaxNumSegments = maxNumSegments; - // Now mark all pending & running merges as optimize - // merge: + // Now mark all pending & running merges as + // isMaxNumSegments: for(final MergePolicy.OneMerge merge : pendingMerges) { - merge.optimize = true; - merge.maxNumSegmentsOptimize = maxNumSegments; - segmentsToOptimize.put(merge.info, Boolean.TRUE); + merge.maxNumSegments = maxNumSegments; + segmentsToMerge.put(merge.info, Boolean.TRUE); } for ( final MergePolicy.OneMerge merge: runningMerges ) { - merge.optimize = true; - merge.maxNumSegmentsOptimize = maxNumSegments; - segmentsToOptimize.put(merge.info, Boolean.TRUE); + merge.maxNumSegments = maxNumSegments; + segmentsToMerge.put(merge.info, Boolean.TRUE); } } - maybeMerge(maxNumSegments, true); + maybeMerge(maxNumSegments); if (doWait) { synchronized(this) { while(true) { if (hitOOM) { - throw new IllegalStateException("this writer hit an OutOfMemoryError; cannot complete optimize"); + throw new IllegalStateException("this writer hit an OutOfMemoryError; cannot complete mergeIfNeeded"); } if (mergeExceptions.size() > 0) { @@ -1784,7 +1746,7 @@ final int size = mergeExceptions.size(); for(int i=0;iWhen an index * has many document deletions (or updates to existing - * documents), it's best to either call optimize or + * documents), it's best to either call mergeIfNeeded or * expungeDeletes to remove all unused data in the index * associated with the deleted documents. To see how * many deletions you have pending in your index, call * {@link IndexReader#numDeletedDocs} * This saves disk space and memory usage while * searching. expungeDeletes should be somewhat faster - * than optimize since it does not insist on reducing the + * than mergeIfNeeded since it does not insist on reducing the * index to a single segment (though, this depends on the * {@link MergePolicy}; see {@link * MergePolicy#findMergesToExpungeDeletes}.). Note that @@ -1956,22 +1918,18 @@ * href="#OOME">above for details.

*/ public final void maybeMerge() throws CorruptIndexException, IOException { - maybeMerge(false); + maybeMerge(-1); } - private final void maybeMerge(boolean optimize) throws CorruptIndexException, IOException { - maybeMerge(1, optimize); - } - - private final void maybeMerge(int maxNumSegmentsOptimize, boolean optimize) throws CorruptIndexException, IOException { + private final void maybeMerge(int maxNumSegments) throws CorruptIndexException, IOException { ensureOpen(false); - updatePendingMerges(maxNumSegmentsOptimize, optimize); + updatePendingMerges(maxNumSegments); mergeScheduler.merge(this); } - private synchronized void updatePendingMerges(int maxNumSegmentsOptimize, boolean optimize) + private synchronized void updatePendingMerges(int maxNumSegments) throws CorruptIndexException, IOException { - assert !optimize || maxNumSegmentsOptimize > 0; + assert maxNumSegments == -1 || maxNumSegments > 0; if (stopMerges) { return; @@ -1983,14 +1941,13 @@ } final MergePolicy.MergeSpecification spec; - if (optimize) { - spec = mergePolicy.findMergesForOptimize(segmentInfos, maxNumSegmentsOptimize, Collections.unmodifiableMap(segmentsToOptimize)); + if (maxNumSegments != -1) { + spec = mergePolicy.findMerges(segmentInfos, maxNumSegments, Collections.unmodifiableMap(segmentsToMerge)); if (spec != null) { final int numMerges = spec.merges.size(); for(int i=0;iNOTE: this method will forcefully abort all merges * in progress. If other threads are running {@link - * #optimize()}, {@link #addIndexes(IndexReader[])} or + * #mergeIfNeeded}, {@link #addIndexes(IndexReader[])} or * {@link #expungeDeletes} methods, they may receive * {@link MergePolicy.MergeAbortedException}s. */ @@ -2439,7 +2396,7 @@ * (including the starting index). If readers/searchers * are open against the starting index, then temporary * free space required will be higher by the size of the - * starting index (see {@link #optimize()} for details). + * starting index (see {@link #mergeIfNeeded(int)} for details). * *

* NOTE: this method only copies the segments of the incoming indexes @@ -2501,7 +2458,7 @@ && versionComparator.compare(info.getVersion(), "3.1") >= 0; } - IOContext context = new IOContext(new MergeInfo(info.docCount, info.sizeInBytes(true), true, false)); + IOContext context = new IOContext(new MergeInfo(info.docCount, info.sizeInBytes(true), true, -1)); if (createCFS) { copySegmentIntoCFS(info, newSegName, context); @@ -2525,7 +2482,6 @@ } /** Merges the provided indexes into this index. - *

After this completes, the index is optimized.

*

The provided IndexReaders are not closed.

* *

NOTE: while this is running, any attempts to @@ -2561,7 +2517,7 @@ for (IndexReader indexReader : readers) { numDocs += indexReader.numDocs(); } - final IOContext context = new IOContext(new MergeInfo(numDocs, -1, true, false)); + final IOContext context = new IOContext(new MergeInfo(numDocs, -1, true, -1)); // TODO: somehow we should fix this merge so it's // abortable so that IW.close(false) is able to stop it @@ -2838,7 +2794,7 @@ /** *

Commits all pending changes (added & deleted - * documents, optimizations, segment merges, added + * documents, segment merges, added * indexes, etc.) to the index, and syncs all referenced * index files, such that a reader will see the changes * and the index updates will survive an OS or machine @@ -3248,10 +3204,10 @@ // disk, updating SegmentInfo, etc.: readerPool.clear(merge.segments); - if (merge.optimize) { - // cascade the optimize: - if (!segmentsToOptimize.containsKey(merge.info)) { - segmentsToOptimize.put(merge.info, Boolean.FALSE); + if (merge.maxNumSegments != -1) { + // cascade the mergeIfNeeded: + if (!segmentsToMerge.containsKey(merge.info)) { + segmentsToMerge.put(merge.info, Boolean.FALSE); } } @@ -3265,7 +3221,7 @@ } // Set the exception on the merge, so if - // optimize() is waiting on us it sees the root + // mergeIfNeeded is waiting on us it sees the root // cause exception: merge.setException(t); addMergeException(merge); @@ -3332,8 +3288,8 @@ // This merge (and, generally, any change to the // segments) may now enable new merges, so we call // merge policy & update pending merges. - if (success && !merge.isAborted() && (merge.optimize || (!closed && !closing))) { - updatePendingMerges(merge.maxNumSegmentsOptimize, merge.optimize); + if (success && !merge.isAborted() && (merge.maxNumSegments != -1 || (!closed && !closing))) { + updatePendingMerges(merge.maxNumSegments); } } } @@ -3377,9 +3333,8 @@ if (info.dir != directory) { isExternal = true; } - if (segmentsToOptimize.containsKey(info)) { - merge.optimize = true; - merge.maxNumSegmentsOptimize = optimizeMaxNumSegments; + if (segmentsToMerge.containsKey(info)) { + merge.maxNumSegments = mergeMaxNumSegments; } } @@ -3440,7 +3395,7 @@ assert testPoint("startMergeInit"); assert merge.registerDone; - assert !merge.optimize || merge.maxNumSegmentsOptimize > 0; + assert merge.maxNumSegments == -1 || merge.maxNumSegments > 0; if (hitOOM) { throw new IllegalStateException("this writer hit an OutOfMemoryError; cannot merge"); @@ -3490,7 +3445,7 @@ // Lock order: IW -> BD bufferedDeletesStream.prune(segmentInfos); Map details = new HashMap(); - details.put("optimize", Boolean.toString(merge.optimize)); + details.put("mergeMaxNumSegments", ""+merge.maxNumSegments); details.put("mergeFactor", Integer.toString(merge.segments.size())); setDiagnostics(merge.info, "merge", details); @@ -3542,7 +3497,7 @@ * the synchronized lock on IndexWriter instance. */ final synchronized void mergeFinish(MergePolicy.OneMerge merge) throws IOException { - // Optimize, addIndexes or finishMerges may be waiting + // mergeIfNeeded, addIndexes or finishMerges may be waiting // on merges to finish. notifyAll(); @@ -4133,7 +4088,7 @@ * NOTE: the set {@link PayloadProcessorProvider} will be in effect * immediately, potentially for already running merges too. If you want to be * sure it is used for further operations only, such as {@link #addIndexes} or - * {@link #optimize}, you can call {@link #waitForMerges()} before. + * {@link #mergeIfNeeded}, you can call {@link #waitForMerges()} before. */ public void setPayloadProcessorProvider(PayloadProcessorProvider pcp) { ensureOpen(); Index: lucene/src/java/org/apache/lucene/index/IndexFileDeleter.java =================================================================== --- lucene/src/java/org/apache/lucene/index/IndexFileDeleter.java (revision 1197316) +++ lucene/src/java/org/apache/lucene/index/IndexFileDeleter.java (working copy) @@ -668,8 +668,8 @@ Collection commitsToDelete; long version; long generation; - final boolean isOptimized; final Map userData; + private final int segmentCount; public CommitPoint(Collection commitsToDelete, Directory directory, SegmentInfos segmentInfos) throws IOException { this.directory = directory; @@ -679,7 +679,7 @@ version = segmentInfos.getVersion(); generation = segmentInfos.getGeneration(); files = Collections.unmodifiableCollection(segmentInfos.files(directory, true)); - isOptimized = segmentInfos.size() == 1 && !segmentInfos.info(0).hasDeletions(); + segmentCount = segmentInfos.size(); } @Override @@ -688,8 +688,8 @@ } @Override - public boolean isOptimized() { - return isOptimized; + public int getSegmentCount() { + return segmentCount; } @Override Index: lucene/src/java/org/apache/lucene/index/IndexWriterConfig.java =================================================================== --- lucene/src/java/org/apache/lucene/index/IndexWriterConfig.java (revision 1197316) +++ lucene/src/java/org/apache/lucene/index/IndexWriterConfig.java (working copy) @@ -512,7 +512,7 @@ * Expert: {@link MergePolicy} is invoked whenever there are changes to the * segments in the index. Its role is to select which merges to do, if any, * and return a {@link MergePolicy.MergeSpecification} describing the merges. - * It also selects merges to do for optimize(). (The default is + * It also selects merges to do for mergeIfNeeded. (The default is * {@link LogByteSizeMergePolicy}. * *

Only takes effect when IndexWriter is first created. */ Index: lucene/src/java/org/apache/lucene/store/FlushInfo.java =================================================================== --- lucene/src/java/org/apache/lucene/store/FlushInfo.java (revision 1197316) +++ lucene/src/java/org/apache/lucene/store/FlushInfo.java (working copy) @@ -18,7 +18,7 @@ */ /** - *

A FlushInfo provides information required for a FLUSH context and other optimization operations. + *

A FlushInfo provides information required for a FLUSH context. * It is used as part of an {@link IOContext} in case of FLUSH context.

*/ Index: lucene/src/java/org/apache/lucene/store/MergeInfo.java =================================================================== --- lucene/src/java/org/apache/lucene/store/MergeInfo.java (revision 1197316) +++ lucene/src/java/org/apache/lucene/store/MergeInfo.java (working copy) @@ -17,7 +17,7 @@ */ /** - *

A MergeInfo provides information required for a MERGE context and other optimization operations. + *

A MergeInfo provides information required for a MERGE context. * It is used as part of an {@link IOContext} in case of MERGE context.

*/ @@ -29,7 +29,7 @@ public final boolean isExternal; - public final boolean optimize; + public final int mergeMaxNumSegments; /** @@ -40,11 +40,11 @@ * */ - public MergeInfo(int totalDocCount, long estimatedMergeBytes, boolean isExternal, boolean optimize) { + public MergeInfo(int totalDocCount, long estimatedMergeBytes, boolean isExternal, int mergeMaxNumSegments) { this.totalDocCount = totalDocCount; this.estimatedMergeBytes = estimatedMergeBytes; this.isExternal = isExternal; - this.optimize = optimize; + this.mergeMaxNumSegments = mergeMaxNumSegments; } @@ -55,7 +55,7 @@ result = prime * result + (int) (estimatedMergeBytes ^ (estimatedMergeBytes >>> 32)); result = prime * result + (isExternal ? 1231 : 1237); - result = prime * result + (optimize ? 1231 : 1237); + result = prime * result + mergeMaxNumSegments; result = prime * result + totalDocCount; return result; } @@ -73,7 +73,7 @@ return false; if (isExternal != other.isExternal) return false; - if (optimize != other.optimize) + if (mergeMaxNumSegments != other.mergeMaxNumSegments) return false; if (totalDocCount != other.totalDocCount) return false; @@ -84,6 +84,6 @@ public String toString() { return "MergeInfo [totalDocCount=" + totalDocCount + ", estimatedMergeBytes=" + estimatedMergeBytes + ", isExternal=" - + isExternal + ", optimize=" + optimize + "]"; + + isExternal + ", mergeMaxNumSegments=" + mergeMaxNumSegments + "]"; } } \ No newline at end of file Index: lucene/src/test-framework/org/apache/lucene/analysis/CollationTestBase.java =================================================================== --- lucene/src/test-framework/org/apache/lucene/analysis/CollationTestBase.java (revision 1197316) +++ lucene/src/test-framework/org/apache/lucene/analysis/CollationTestBase.java (working copy) @@ -216,7 +216,7 @@ doc.add(new TextField("Denmark", denmarkAnalyzer.tokenStream("Denmark", new StringReader(sortData[i][5])))); writer.addDocument(doc); } - writer.optimize(); + writer.mergeIfNeeded(-1); writer.close(); IndexSearcher searcher = new IndexSearcher(indexStore, true); Index: lucene/src/test-framework/org/apache/lucene/index/RandomIndexWriter.java =================================================================== --- lucene/src/test-framework/org/apache/lucene/index/RandomIndexWriter.java (revision 1197316) +++ lucene/src/test-framework/org/apache/lucene/index/RandomIndexWriter.java (working copy) @@ -38,7 +38,7 @@ /** Silly class that randomizes the indexing experience. EG * it may swap in a different merge policy/scheduler; may - * commit periodically; may or may not optimize in the end, + * commit periodically; may or may not mergeIfNeeded in the end, * may flush by doc count instead of RAM, etc. */ @@ -324,8 +324,8 @@ return getReader(true); } - private boolean doRandomOptimize = true; - private boolean doRandomOptimizeAssert = true; + private boolean doRandomMergeIfNeeded = true; + private boolean doRandomMergeIfNeededAssert = true; public void expungeDeletes(boolean doWait) throws IOException { w.expungeDeletes(doWait); @@ -335,25 +335,25 @@ w.expungeDeletes(); } - public void setDoRandomOptimize(boolean v) { - doRandomOptimize = v; + public void setDoRandomMergeIfNeeded(boolean v) { + doRandomMergeIfNeeded = v; } - public void setDoRandomOptimizeAssert(boolean v) { - doRandomOptimizeAssert = v; + public void setDoRandomMergeIfNeededAssert(boolean v) { + doRandomMergeIfNeededAssert = v; } - private void doRandomOptimize() throws IOException { - if (doRandomOptimize) { + private void doRandomMergeIfNeeded() throws IOException { + if (doRandomMergeIfNeeded) { final int segCount = w.getSegmentCount(); if (r.nextBoolean() || segCount == 0) { - // full optimize - w.optimize(); + // full mergeIfNeeded + w.mergeIfNeeded(1); } else { - // partial optimize + // partial mergeIfNeeded final int limit = _TestUtil.nextInt(r, 1, segCount); - w.optimize(limit); - assert !doRandomOptimizeAssert || w.getSegmentCount() <= limit: "limit=" + limit + " actual=" + w.getSegmentCount(); + w.mergeIfNeeded(limit); + assert !doRandomMergeIfNeededAssert || w.getSegmentCount() <= limit: "limit=" + limit + " actual=" + w.getSegmentCount(); } } switchDoDocValues(); @@ -362,7 +362,7 @@ public IndexReader getReader(boolean applyDeletions) throws IOException { getReaderCalled = true; if (r.nextInt(4) == 2) { - doRandomOptimize(); + doRandomMergeIfNeeded(); } // If we are writing with PreFlexRW, force a full // IndexReader.open so terms are sorted in codepoint @@ -395,21 +395,21 @@ */ public void close() throws IOException { // if someone isn't using getReader() API, we want to be sure to - // maybeOptimize since presumably they might open a reader on the dir. + // mergeIfNeeded since presumably they might open a reader on the dir. if (getReaderCalled == false && r.nextInt(8) == 2) { - doRandomOptimize(); + doRandomMergeIfNeeded(); } w.close(); } /** - * Forces an optimize. + * Forces a mergeIfNeeded. *

* NOTE: this should be avoided in tests unless absolutely necessary, * as it will result in less test coverage. - * @see IndexWriter#optimize() + * @see IndexWriter#mergeIfNeeded() */ - public void optimize() throws IOException { - w.optimize(); + public void mergeIfNeeded(int maxSegmentCount) throws IOException { + w.mergeIfNeeded(maxSegmentCount); } } Index: lucene/src/test-framework/org/apache/lucene/index/ThreadedIndexingAndSearchingTestCase.java =================================================================== --- lucene/src/test-framework/org/apache/lucene/index/ThreadedIndexingAndSearchingTestCase.java (revision 1197316) +++ lucene/src/test-framework/org/apache/lucene/index/ThreadedIndexingAndSearchingTestCase.java (working copy) @@ -54,7 +54,7 @@ import org.apache.lucene.util._TestUtil; // TODO -// - mix in optimize, addIndexes +// - mix in mergeIfNeeded, addIndexes // - randomly mix in non-congruent docs /** Utility class that spawns multiple indexing and Index: lucene/src/test-framework/org/apache/lucene/index/MockRandomMergePolicy.java =================================================================== --- lucene/src/test-framework/org/apache/lucene/index/MockRandomMergePolicy.java (revision 1197316) +++ lucene/src/test-framework/org/apache/lucene/index/MockRandomMergePolicy.java (working copy) @@ -55,18 +55,18 @@ } @Override - public MergeSpecification findMergesForOptimize( - SegmentInfos segmentInfos, int maxSegmentCount, Map segmentsToOptimize) + public MergeSpecification findMerges( + SegmentInfos segmentInfos, int maxSegmentCount, Map segmentsToMerge) throws CorruptIndexException, IOException { final List eligibleSegments = new ArrayList(); for(SegmentInfo info : segmentInfos) { - if (segmentsToOptimize.containsKey(info)) { + if (segmentsToMerge.containsKey(info)) { eligibleSegments.add(info); } } - //System.out.println("MRMP: findMergesForOptimize sis=" + segmentInfos + " eligible=" + eligibleSegments); + //System.out.println("MRMP: findMerges sis=" + segmentInfos + " eligible=" + eligibleSegments); MergeSpecification mergeSpec = null; if (eligibleSegments.size() > 1 || (eligibleSegments.size() == 1 && eligibleSegments.get(0).hasDeletions())) { mergeSpec = new MergeSpecification(); @@ -85,7 +85,7 @@ if (mergeSpec != null) { for(OneMerge merge : mergeSpec.merges) { for(SegmentInfo info : merge.segments) { - assert segmentsToOptimize.containsKey(info); + assert segmentsToMerge.containsKey(info); } } } Index: lucene/src/test-framework/org/apache/lucene/util/LuceneTestCase.java =================================================================== --- lucene/src/test-framework/org/apache/lucene/util/LuceneTestCase.java (revision 1197316) +++ lucene/src/test-framework/org/apache/lucene/util/LuceneTestCase.java (working copy) @@ -1404,7 +1404,7 @@ context = IOContext.READONCE; break; case 3: - context = new IOContext(new MergeInfo(randomNumDocs, size, true, false)); + context = new IOContext(new MergeInfo(randomNumDocs, size, true, -1)); break; case 4: context = new IOContext(new FlushInfo(randomNumDocs, size));