+++ /dev/null
-package org.apache.lucene.index;
-
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import java.io.Closeable;
-import java.io.IOException;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Random;
-
-import org.apache.lucene.analysis.Analyzer;
-import org.apache.lucene.analysis.MockAnalyzer;
-import org.apache.lucene.document.Document;
-import org.apache.lucene.index.IndexWriter; // javadoc
-import org.apache.lucene.search.Query;
-import org.apache.lucene.store.Directory;
-import org.apache.lucene.util.LuceneTestCase;
-import org.apache.lucene.util.Version;
-import org.apache.lucene.util._TestUtil;
-
-/** 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,
- * may flush by doc count instead of RAM, etc.
- */
-
-public class RandomIndexWriter implements Closeable {
-
- public IndexWriter w;
- private final Random r;
- int docCount;
- int flushAt;
- private double flushAtFactor = 1.0;
- private boolean getReaderCalled;
-
- // Randomly calls Thread.yield so we mixup thread scheduling
- private static final class MockIndexWriter extends IndexWriter {
-
- private final Random r;
-
- public MockIndexWriter(Random r,Directory dir, IndexWriterConfig conf) throws IOException {
- super(dir, conf);
- // must make a private random since our methods are
- // called from different threads; else test failures may
- // not be reproducible from the original seed
- this.r = new Random(r.nextInt());
- }
-
- @Override
- boolean testPoint(String name) {
- if (r.nextInt(4) == 2)
- Thread.yield();
- return true;
- }
- }
-
- /** create a RandomIndexWriter with a random config: Uses TEST_VERSION_CURRENT and Whitespace+LowercasingAnalyzer */
- public RandomIndexWriter(Random r, Directory dir) throws IOException {
- this(r, dir, LuceneTestCase.newIndexWriterConfig(r, LuceneTestCase.TEST_VERSION_CURRENT, new MockAnalyzer(r)));
- }
-
- /** create a RandomIndexWriter with a random config: Uses TEST_VERSION_CURRENT */
- public RandomIndexWriter(Random r, Directory dir, Analyzer a) throws IOException {
- this(r, dir, LuceneTestCase.newIndexWriterConfig(r, LuceneTestCase.TEST_VERSION_CURRENT, a));
- }
-
- /** create a RandomIndexWriter with a random config */
- public RandomIndexWriter(Random r, Directory dir, Version v, Analyzer a) throws IOException {
- this(r, dir, LuceneTestCase.newIndexWriterConfig(r, v, a));
- }
-
- /** create a RandomIndexWriter with the provided config */
- public RandomIndexWriter(Random r, Directory dir, IndexWriterConfig c) throws IOException {
- this.r = r;
- w = new MockIndexWriter(r, dir, c);
- flushAt = _TestUtil.nextInt(r, 10, 1000);
- if (LuceneTestCase.VERBOSE) {
- System.out.println("RIW config=" + w.getConfig());
- }
- }
-
- /**
- * Adds a Document.
- * @see IndexWriter#addDocument(Document)
- */
- public void addDocument(final Document doc) throws IOException {
- if (r.nextInt(5) == 3) {
- // TODO: maybe, we should simply buffer up added docs
- // (but we need to clone them), and only when
- // getReader, commit, etc. are called, we do an
- // addDocuments? Would be better testing.
- w.addDocuments(Collections.singletonList(doc));
- } else {
- w.addDocument(doc);
- }
- maybeCommit();
- }
-
- public void addDocuments(Collection<Document> docs) throws IOException {
- w.addDocuments(docs);
- maybeCommit();
- }
-
- public void updateDocuments(Term delTerm, Collection<Document> docs) throws IOException {
- w.updateDocuments(delTerm, docs);
- maybeCommit();
- }
-
- private void maybeCommit() throws IOException {
- if (docCount++ == flushAt) {
- if (LuceneTestCase.VERBOSE) {
- System.out.println("RIW.add/updateDocument: now doing a commit at docCount=" + docCount);
- }
- w.commit();
- flushAt += _TestUtil.nextInt(r, (int) (flushAtFactor * 10), (int) (flushAtFactor * 1000));
- if (flushAtFactor < 2e6) {
- // gradually but exponentially increase time b/w flushes
- flushAtFactor *= 1.05;
- }
- }
- }
-
- /**
- * Updates a document.
- * @see IndexWriter#updateDocument(Term, Document)
- */
- public void updateDocument(Term t, final Document doc) throws IOException {
- if (r.nextInt(5) == 3) {
- w.updateDocuments(t, Collections.singletonList(doc));
- } else {
- w.updateDocument(t, doc);
- }
- maybeCommit();
- }
-
- public void addIndexes(Directory... dirs) throws CorruptIndexException, IOException {
- w.addIndexes(dirs);
- }
-
- public void deleteDocuments(Term term) throws CorruptIndexException, IOException {
- w.deleteDocuments(term);
- }
-
- public void deleteDocuments(Query q) throws CorruptIndexException, IOException {
- w.deleteDocuments(q);
- }
-
- public void commit() throws CorruptIndexException, IOException {
- w.commit();
- }
-
- public int numDocs() throws IOException {
- return w.numDocs();
- }
-
- public int maxDoc() {
- return w.maxDoc();
- }
-
- public void deleteAll() throws IOException {
- w.deleteAll();
- }
-
- private boolean doRandomOptimize = true;
- private boolean doRandomOptimizeAssert = true;
-
- public void setDoRandomOptimize(boolean v) {
- doRandomOptimize = v;
- }
-
- public void setDoRandomOptimizeAssert(boolean v) {
- doRandomOptimizeAssert = v;
- }
-
- private void doRandomOptimize() throws IOException {
- if (doRandomOptimize) {
- final int segCount = w.getSegmentCount();
- if (r.nextBoolean() || segCount == 0) {
- // full optimize
- w.optimize();
- } else {
- // partial optimize
- final int limit = _TestUtil.nextInt(r, 1, segCount);
- w.optimize(limit);
- assert !doRandomOptimizeAssert || w.getSegmentCount() <= limit: "limit=" + limit + " actual=" + w.getSegmentCount();
- }
- }
- }
-
- public IndexReader getReader() throws IOException {
- return getReader(true);
- }
-
- public IndexReader getReader(boolean applyDeletions) throws IOException {
- getReaderCalled = true;
- if (r.nextInt(4) == 2) {
- doRandomOptimize();
- }
- if (r.nextBoolean()) {
- if (LuceneTestCase.VERBOSE) {
- System.out.println("RIW.getReader: use NRT reader");
- }
- if (r.nextInt(5) == 1) {
- w.commit();
- }
- return w.getReader(applyDeletions);
- } else {
- if (LuceneTestCase.VERBOSE) {
- System.out.println("RIW.getReader: open new reader");
- }
- w.commit();
- if (r.nextBoolean()) {
- return IndexReader.open(w.getDirectory(), new KeepOnlyLastCommitDeletionPolicy(), r.nextBoolean(), _TestUtil.nextInt(r, 1, 10));
- } else {
- return w.getReader(applyDeletions);
- }
- }
- }
-
- /**
- * Close this writer.
- * @see IndexWriter#close()
- */
- 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.
- if (getReaderCalled == false && r.nextInt(8) == 2) {
- doRandomOptimize();
- }
- w.close();
- }
-
- /**
- * Forces an optimize.
- * <p>
- * NOTE: this should be avoided in tests unless absolutely necessary,
- * as it will result in less test coverage.
- * @see IndexWriter#optimize()
- */
- public void optimize() throws IOException {
- w.optimize();
- }
-}
fnp / pylucene.git / blobdiff