numStoredFields times. Note that this is
* called even if the document has no stored fields, in
* this case numStoredFields will be zero. */
public abstract void startDocument(int numStoredFields) throws IOException;
/** Writes a single stored field. */
- public abstract void writeField(FieldInfo info, IndexableField field) throws IOException;
+ public abstract void writeField(FieldInfo info, StorableField field) throws IOException;
/** Aborts writing entirely, implementation should remove
* any partially-written files, etc. */
@@ -68,7 +70,7 @@
/** Merges in the stored fields from the readers in
* mergeState. The default implementation skips
* over deleted documents, and uses {@link #startDocument(int)},
- * {@link #writeField(FieldInfo, IndexableField)}, and {@link #finish(int)},
+ * {@link #writeField(FieldInfo, StorableField)}, and {@link #finish(int)},
* returning the number of documents that were written.
* Implementations can override this method for more sophisticated
* merging (bulk-byte copying, etc). */
@@ -88,7 +90,7 @@
// on the fly?
// NOTE: it's very important to first assign to doc then pass it to
// fieldsWriter.addDocument; see LUCENE-1282
- Document doc = reader.reader.document(i);
+ StoredDocument doc = reader.reader.document(i);
addDocument(doc, mergeState.fieldInfos);
docCount++;
mergeState.checkAbort.work(300);
@@ -99,20 +101,16 @@
}
/** sugar method for startDocument() + writeField() for every stored field in the document */
- protected final void addDocument(Iterable doc, FieldInfos fieldInfos) throws IOException {
+ protected final void addDocument(Iterable doc, FieldInfos fieldInfos) throws IOException {
int storedCount = 0;
- for (IndexableField field : doc) {
- if (field.fieldType().stored()) {
- storedCount++;
- }
+ for (StorableField field : doc) {
+ storedCount++;
}
startDocument(storedCount);
- for (IndexableField field : doc) {
- if (field.fieldType().stored()) {
+ for (StorableField field : doc) {
writeField(fieldInfos.fieldInfo(field.name()), field);
- }
}
}
}
Index: lucene/core/src/java/org/apache/lucene/document/ByteDocValuesField.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/document/ByteDocValuesField.java (revision 1340366)
+++ lucene/core/src/java/org/apache/lucene/document/ByteDocValuesField.java (working copy)
@@ -34,7 +34,7 @@
* separate {@link StoredField} instance.
* */
-public class ByteDocValuesField extends Field {
+public class ByteDocValuesField extends StoredField {
public static final FieldType TYPE = new FieldType();
static {
Index: lucene/core/src/java/org/apache/lucene/document/DerefBytesDocValuesField.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/document/DerefBytesDocValuesField.java (revision 1340366)
+++ lucene/core/src/java/org/apache/lucene/document/DerefBytesDocValuesField.java (working copy)
@@ -39,7 +39,7 @@
* separate {@link StoredField} instance.
* */
-public class DerefBytesDocValuesField extends Field {
+public class DerefBytesDocValuesField extends StoredField {
// TODO: ideally indexer figures out var vs fixed on its own!?
public static final FieldType TYPE_FIXED_LEN = new FieldType();
Index: lucene/core/src/java/org/apache/lucene/document/Document.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/document/Document.java (revision 1340366)
+++ lucene/core/src/java/org/apache/lucene/document/Document.java (working copy)
@@ -19,8 +19,10 @@
import java.util.*;
+import org.apache.commons.lang.NotImplementedException;
import org.apache.lucene.index.IndexReader; // for javadoc
import org.apache.lucene.index.IndexableField;
+import org.apache.lucene.index.StorableField;
import org.apache.lucene.search.IndexSearcher; // for javadoc
import org.apache.lucene.search.ScoreDoc; // for javadoc
import org.apache.lucene.util.BytesRef;
@@ -38,16 +40,17 @@
* ScoreDoc#doc} or {@link IndexReader#document(int)}.
*/
-public final class Document implements Iterablebyte[] containing the binary field value or null
*/
public final BytesRef getBinaryValue(String name) {
- for (IndexableField field : fields) {
+ StoredFieldsIterator it = new StoredFieldsIterator();
+
+ while (it.hasNext()) {
+ Field field = it.next();
if (field.name().equals(name)) {
final BytesRef bytes = field.binaryValue();
if (bytes != null) {
@@ -188,7 +197,7 @@
* IndexReader#document(int)}.
*/
public final ListString[] of field values
*/
public final String[] getValues(String name) {
+ StoredFieldsIterator it = new StoredFieldsIterator();
+
ListSet<String>. */
@@ -62,13 +62,16 @@
@Override
public void stringField(FieldInfo fieldInfo, String value) throws IOException {
+ /*
final FieldType ft = new FieldType(TextField.TYPE_STORED);
ft.setStoreTermVectors(fieldInfo.storeTermVector);
ft.setStoreTermVectors(fieldInfo.storeTermVector);
ft.setIndexed(fieldInfo.isIndexed);
ft.setOmitNorms(fieldInfo.omitNorms);
ft.setIndexOptions(fieldInfo.indexOptions);
- doc.add(new Field(fieldInfo.name, value, ft));
+ */
+ doc.add(new StoredField(fieldInfo.name, value));
+ //doc.add(new Field(fieldInfo.name, value, ft));
}
@Override
@@ -96,7 +99,7 @@
return fieldsToAdd == null || fieldsToAdd.contains(fieldInfo.name) ? Status.YES : Status.NO;
}
- public Document getDocument() {
+ public StoredDocument getDocument() {
return doc;
}
}
Index: lucene/core/src/java/org/apache/lucene/document/DoubleDocValuesField.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/document/DoubleDocValuesField.java (revision 1340366)
+++ lucene/core/src/java/org/apache/lucene/document/DoubleDocValuesField.java (working copy)
@@ -34,7 +34,7 @@
* separate {@link StoredField} instance.
* */
-public class DoubleDocValuesField extends Field {
+public class DoubleDocValuesField extends StoredField {
public static final FieldType TYPE = new FieldType();
static {
Index: lucene/core/src/java/org/apache/lucene/document/DoubleField.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/document/DoubleField.java (revision 1340366)
+++ lucene/core/src/java/org/apache/lucene/document/DoubleField.java (working copy)
@@ -120,7 +120,6 @@
public static final FieldType TYPE = new FieldType();
static {
- TYPE.setIndexed(true);
TYPE.setTokenized(true);
TYPE.setOmitNorms(true);
TYPE.setIndexOptions(IndexOptions.DOCS_ONLY);
Index: lucene/core/src/java/org/apache/lucene/document/Field.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/document/Field.java (revision 1340366)
+++ lucene/core/src/java/org/apache/lucene/document/Field.java (working copy)
@@ -31,6 +31,7 @@
import org.apache.lucene.index.IndexableField;
import org.apache.lucene.index.IndexableFieldType;
import org.apache.lucene.index.Norm; // javadocs
+import org.apache.lucene.index.StorableField;
import org.apache.lucene.util.BytesRef;
import org.apache.lucene.index.FieldInvertState; // javadocs
@@ -59,7 +60,7 @@
* Field it is used in. It is strongly recommended that no
* changes be made after Field instantiation.
*/
-public class Field implements IndexableField {
+public class Field implements IndexableField, StorableField {
protected final FieldType type;
protected final String name;
Index: lucene/core/src/java/org/apache/lucene/document/FieldType.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/document/FieldType.java (revision 1340366)
+++ lucene/core/src/java/org/apache/lucene/document/FieldType.java (working copy)
@@ -20,13 +20,14 @@
import org.apache.lucene.index.DocValues;
import org.apache.lucene.index.FieldInfo.IndexOptions;
import org.apache.lucene.index.IndexableFieldType;
+import org.apache.lucene.index.StorableFieldType;
import org.apache.lucene.search.NumericRangeQuery; // javadocs
import org.apache.lucene.util.NumericUtils;
/**
* Describes the properties of a field.
*/
-public class FieldType implements IndexableFieldType {
+public class FieldType implements IndexableFieldType, StorableFieldType {
/** Data type of the numeric value
* @since 3.2
@@ -41,10 +42,10 @@
private boolean storeTermVectorPositions;
private boolean omitNorms;
private IndexOptions indexOptions = IndexOptions.DOCS_AND_FREQS_AND_POSITIONS;
- private DocValues.Type docValueType;
private NumericType numericType;
private boolean frozen;
private int numericPrecisionStep = NumericUtils.PRECISION_STEP_DEFAULT;
+ private DocValues.Type docValueType;
public FieldType(FieldType ref) {
this.indexed = ref.indexed();
@@ -150,16 +151,6 @@
this.indexOptions = value;
}
- public void setDocValueType(DocValues.Type type) {
- checkIfFrozen();
- docValueType = type;
- }
-
- @Override
- public DocValues.Type docValueType() {
- return docValueType;
- }
-
public void setNumericType(NumericType type) {
checkIfFrozen();
numericType = type;
@@ -238,4 +229,16 @@
return result.toString();
}
+
+ /* from StorableFieldType */
+
+ @Override
+ public DocValues.Type docValueType() {
+ return docValueType;
+ }
+
+ public void setDocValueType(DocValues.Type type) {
+ checkIfFrozen();
+ docValueType = type;
+ }
}
Index: lucene/core/src/java/org/apache/lucene/document/FloatDocValuesField.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/document/FloatDocValuesField.java (revision 1340366)
+++ lucene/core/src/java/org/apache/lucene/document/FloatDocValuesField.java (working copy)
@@ -34,7 +34,7 @@
* separate {@link StoredField} instance.
* */
-public class FloatDocValuesField extends Field {
+public class FloatDocValuesField extends StoredField {
public static final FieldType TYPE = new FieldType();
static {
Index: lucene/core/src/java/org/apache/lucene/document/FloatField.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/document/FloatField.java (revision 1340366)
+++ lucene/core/src/java/org/apache/lucene/document/FloatField.java (working copy)
@@ -120,7 +120,6 @@
public static final FieldType TYPE = new FieldType();
static {
- TYPE.setIndexed(true);
TYPE.setTokenized(true);
TYPE.setOmitNorms(true);
TYPE.setIndexOptions(IndexOptions.DOCS_ONLY);
Index: lucene/core/src/java/org/apache/lucene/document/IntDocValuesField.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/document/IntDocValuesField.java (revision 1340366)
+++ lucene/core/src/java/org/apache/lucene/document/IntDocValuesField.java (working copy)
@@ -34,7 +34,7 @@
* separate {@link StoredField} instance.
* */
-public class IntDocValuesField extends Field {
+public class IntDocValuesField extends StoredField {
public static final FieldType TYPE = new FieldType();
static {
Index: lucene/core/src/java/org/apache/lucene/document/IntField.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/document/IntField.java (revision 1340366)
+++ lucene/core/src/java/org/apache/lucene/document/IntField.java (working copy)
@@ -120,7 +120,6 @@
public static final FieldType TYPE = new FieldType();
static {
- TYPE.setIndexed(true);
TYPE.setTokenized(true);
TYPE.setOmitNorms(true);
TYPE.setIndexOptions(IndexOptions.DOCS_ONLY);
Index: lucene/core/src/java/org/apache/lucene/document/LongDocValuesField.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/document/LongDocValuesField.java (revision 1340366)
+++ lucene/core/src/java/org/apache/lucene/document/LongDocValuesField.java (working copy)
@@ -34,7 +34,7 @@
* separate {@link StoredField} instance.
* */
-public class LongDocValuesField extends Field {
+public class LongDocValuesField extends StoredField {
public static final FieldType TYPE = new FieldType();
static {
Index: lucene/core/src/java/org/apache/lucene/document/PackedLongDocValuesField.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/document/PackedLongDocValuesField.java (revision 1340366)
+++ lucene/core/src/java/org/apache/lucene/document/PackedLongDocValuesField.java (working copy)
@@ -37,7 +37,7 @@
* separate {@link StoredField} instance.
* */
-public class PackedLongDocValuesField extends Field {
+public class PackedLongDocValuesField extends StoredField {
public static final FieldType TYPE = new FieldType();
static {
Index: lucene/core/src/java/org/apache/lucene/document/ShortDocValuesField.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/document/ShortDocValuesField.java (revision 1340366)
+++ lucene/core/src/java/org/apache/lucene/document/ShortDocValuesField.java (working copy)
@@ -34,7 +34,7 @@
* separate {@link StoredField} instance.
* */
-public class ShortDocValuesField extends Field {
+public class ShortDocValuesField extends StoredField {
public static final FieldType TYPE = new FieldType();
static {
Index: lucene/core/src/java/org/apache/lucene/document/SortedBytesDocValuesField.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/document/SortedBytesDocValuesField.java (revision 1340366)
+++ lucene/core/src/java/org/apache/lucene/document/SortedBytesDocValuesField.java (working copy)
@@ -35,7 +35,7 @@
* separate {@link StoredField} instance.
* */
-public class SortedBytesDocValuesField extends Field {
+public class SortedBytesDocValuesField extends StoredField {
// TODO: ideally indexer figures out var vs fixed on its own!?
public static final FieldType TYPE_FIXED_LEN = new FieldType();
Index: lucene/core/src/java/org/apache/lucene/document/StoredDocument.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/document/StoredDocument.java (revision 0)
+++ lucene/core/src/java/org/apache/lucene/document/StoredDocument.java (working copy)
@@ -0,0 +1,192 @@
+package org.apache.lucene.document;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.IndexableField;
+import org.apache.lucene.index.StorableField;
+import org.apache.lucene.index.StorableField;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.util.BytesRef;
+
+/**
+ * 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.
+ */
+
+public class StoredDocument implements IterableRemoves all fields with the given name from the document. + * If there is no field with the specified name, the document remains unchanged.
+ *Note that the removeField(s) methods like the add method only make sense + * prior to adding a document to an index. These methods cannot + * be used to change the content of an existing index! In order to achieve this, + * a document has to be deleted from an index and a new changed version of that + * document has to be added.
+ */ + public final void removeFields(String name) { + Iteratorbyte[][] of binary field values
+ */
+ public final BytesRef[] getBinaryValues(String name) {
+ final Listnull
+ * if no binary fields with the specified name are available.
+ * There may be non-binary fields with the same name.
+ *
+ * @param name the name of the field.
+ * @return a byte[] containing the binary field value or null
+ */
+ public final BytesRef getBinaryValue(String name) {
+ for (StorableField field : fields) {
+ if (field.name().equals(name)) {
+ final BytesRef bytes = field.binaryValue();
+ if (bytes != null) {
+ return bytes;
+ }
+ }
+ }
+ return null;
+ }
+ private final static String[] NO_STRINGS = new String[0];
+
+ /**
+ * Returns an array of values of the field specified as the method parameter.
+ * This method returns an empty array when there are no
+ * matching fields. It never returns null.
+ * For {@link IntField}, {@link LongField}, {@link
+ * FloatField} and {@link DoubleField} it returns the string value of the number. If you want
+ * the actual numeric field instances back, use {@link #getFields}.
+ * @param name the name of the field
+ * @return a String[] of field values
+ */
+ public final String[] getValues(String name) {
+ ListThere are two different types of IndexReaders: -
IndexReader instances for indexes on disk are usually constructed
- with a call to one of the static DirectoryReader,open() methods,
- e.g. {@link DirectoryReader#open(Directory)}. {@link DirectoryReader} implements
- the {@link CompositeReader} interface, it is not possible to directly get postings.
-
-
For efficiency, in this API documents are often referred to via - document numbers, non-negative integers which each name a unique - document in the index. These document numbers are ephemeral -- they may change - as documents are added to and deleted from an index. Clients should thus not - rely on a given document having the same number between sessions. - -
NOTE: {@link
- IndexReader} instances are completely thread
- safe, meaning multiple threads can call any of its methods,
- concurrently. If your application requires external
- synchronization, you should not synchronize on the
- IndexReader instance; use your own
- (non-Lucene) objects instead.
-*/
+/**
+ * IndexReader is an abstract class, providing an interface for accessing an
+ * index. Search of an index is done entirely through this abstract interface,
+ * so that any subclass which implements it is searchable.
+ *
+ *
+ * There are two different types of IndexReaders: + *
+ * IndexReader instances for indexes on disk are usually constructed with a call
+ * to one of the static DirectoryReader,open() methods, e.g.
+ * {@link DirectoryReader#open(Directory)}. {@link DirectoryReader} implements
+ * the {@link CompositeReader} interface, it is not possible to directly get
+ * postings.
+ *
+ *
+ * For efficiency, in this API documents are often referred to via document + * numbers, non-negative integers which each name a unique document in the + * index. These document numbers are ephemeral -- they may change as documents + * are added to and deleted from an index. Clients should thus not rely on a + * given document having the same number between sessions. + * + *
+ * NOTE: {@link IndexReader} instances are completely thread safe,
+ * meaning multiple threads can call any of its methods, concurrently. If your
+ * application requires external synchronization, you should not
+ * synchronize on the
- * RefCounts are used to determine when a
- * reader can be closed safely, i.e. as soon as there are
- * no more references. Be sure to always call a
- * corresponding {@link #decRef}, in a finally clause;
- * otherwise the reader may never be closed. Note that
- * {@link #close} simply calls decRef(), which means that
- * the IndexReader will not really be closed until {@link
- * #decRef} has been called for all outstanding
- * references.
- *
+ * RefCounts are used to determine when a reader can be closed safely, i.e. as
+ * soon as there are no more references. Be sure to always call a
+ * corresponding {@link #decRef}, in a finally clause; otherwise the reader
+ * may never be closed. Note that {@link #close} simply calls decRef(), which
+ * means that the IndexReader will not really be closed until {@link #decRef}
+ * has been called for all outstanding references.
+ *
* @see #decRef
* @see #incRef
*/
public final boolean tryIncRef() {
int count;
while ((count = refCount.get()) > 0) {
- if (refCount.compareAndSet(count, count+1)) {
+ if (refCount.compareAndSet(count, count + 1)) {
return true;
}
}
return false;
}
-
+
/**
- * Expert: decreases the refCount of this IndexReader
- * instance. If the refCount drops to 0, then this
- * reader is closed. If an exception is hit, the refCount
- * is unchanged.
- *
- * @throws IOException in case an IOException occurs in doClose()
- *
+ * Expert: decreases the refCount of this IndexReader instance. If the
+ * refCount drops to 0, then this reader is closed. If an exception is hit,
+ * the refCount is unchanged.
+ *
+ * @throws IOException
+ * in case an IOException occurs in doClose()
+ *
* @see #incRef
*/
public final void decRef() throws IOException {
@@ -238,28 +244,34 @@
reportCloseToParentReaders();
notifyReaderClosedListeners();
} else if (rc < 0) {
- throw new IllegalStateException("too many decRef calls: refCount is " + rc + " after decrement");
+ throw new IllegalStateException("too many decRef calls: refCount is "
+ + rc + " after decrement");
}
}
/**
- * @throws AlreadyClosedException if this IndexReader is closed
+ * @throws AlreadyClosedException
+ * if this IndexReader is closed
*/
protected final void ensureOpen() throws AlreadyClosedException {
if (refCount.get() <= 0) {
throw new AlreadyClosedException("this IndexReader is closed");
}
- // the happens before rule on reading the refCount, which must be after the fake write,
+ // the happens before rule on reading the refCount, which must be after the
+ // fake write,
// ensures that we see the value:
if (closedByChild) {
- throw new AlreadyClosedException("this IndexReader cannot be used anymore as one of its child readers was closed");
+ throw new AlreadyClosedException(
+ "this IndexReader cannot be used anymore as one of its child readers was closed");
}
}
- /** {@inheritDoc}
- * For caching purposes, {@code IndexReader} subclasses are not allowed
- * to implement equals/hashCode, so methods are declared final.
- * To lookup instances from caches use {@link #getCoreCacheKey} and
+ /**
+ * {@inheritDoc}
+ *
+ * For caching purposes, {@code IndexReader} subclasses are not allowed to
+ * implement equals/hashCode, so methods are declared final. To lookup
+ * instances from caches use {@link #getCoreCacheKey} and
* {@link #getCombinedCoreAndDeletesKey}.
*/
@Override
@@ -267,10 +279,12 @@
return (this == obj);
}
- /** {@inheritDoc}
- * For caching purposes, {@code IndexReader} subclasses are not allowed
- * to implement equals/hashCode, so methods are declared final.
- * To lookup instances from caches use {@link #getCoreCacheKey} and
+ /**
+ * {@inheritDoc}
+ *
+ * For caching purposes, {@code IndexReader} subclasses are not allowed to
+ * implement equals/hashCode, so methods are declared final. To lookup
+ * instances from caches use {@link #getCoreCacheKey} and
* {@link #getCombinedCoreAndDeletesKey}.
*/
@Override
@@ -278,188 +292,222 @@
return System.identityHashCode(this);
}
- /** Returns a IndexReader reading the index in the given
- * Directory
- * @param directory the index directory
- * @throws CorruptIndexException if the index is corrupt
- * @throws IOException if there is a low-level IO error
+ /**
+ * Returns a IndexReader reading the index in the given Directory
+ *
+ * @param directory
+ * the index directory
+ * @throws CorruptIndexException
+ * if the index is corrupt
+ * @throws IOException
+ * if there is a low-level IO error
* @deprecated Use {@link DirectoryReader#open(Directory)}
*/
@Deprecated
- public static DirectoryReader open(final Directory directory) throws CorruptIndexException, IOException {
+ public static DirectoryReader open(final Directory directory)
+ throws CorruptIndexException, IOException {
return DirectoryReader.open(directory);
}
- /** Expert: Returns a IndexReader reading the index in the given
- * Directory with the given termInfosIndexDivisor.
- * @param directory the index directory
- * @param termInfosIndexDivisor Subsamples which indexed
- * terms are loaded into RAM. This has the same effect as {@link
- * IndexWriterConfig#setTermIndexInterval} except that setting
- * must be done at indexing time while this setting can be
- * set per reader. When set to N, then one in every
- * N*termIndexInterval terms in the index is loaded into
- * memory. By setting this to a value > 1 you can reduce
- * memory usage, at the expense of higher latency when
- * loading a TermInfo. The default value is 1. Set this
- * to -1 to skip loading the terms index entirely.
- * @throws CorruptIndexException if the index is corrupt
- * @throws IOException if there is a low-level IO error
+ /**
+ * Expert: Returns a IndexReader reading the index in the given Directory with
+ * the given termInfosIndexDivisor.
+ *
+ * @param directory
+ * the index directory
+ * @param termInfosIndexDivisor
+ * Subsamples which indexed terms are loaded into RAM. This has the
+ * same effect as {@link IndexWriterConfig#setTermIndexInterval}
+ * except that setting must be done at indexing time while this
+ * setting can be set per reader. When set to N, then one in every
+ * N*termIndexInterval terms in the index is loaded into memory. By
+ * setting this to a value > 1 you can reduce memory usage, at the
+ * expense of higher latency when loading a TermInfo. The default
+ * value is 1. Set this to -1 to skip loading the terms index
+ * entirely.
+ * @throws CorruptIndexException
+ * if the index is corrupt
+ * @throws IOException
+ * if there is a low-level IO error
* @deprecated Use {@link DirectoryReader#open(Directory,int)}
*/
@Deprecated
- public static DirectoryReader open(final Directory directory, int termInfosIndexDivisor) throws CorruptIndexException, IOException {
+ public static DirectoryReader open(final Directory directory,
+ int termInfosIndexDivisor) throws CorruptIndexException, IOException {
return DirectoryReader.open(directory, termInfosIndexDivisor);
}
/**
- * Open a near real time IndexReader from the {@link org.apache.lucene.index.IndexWriter}.
- *
- * @param writer The IndexWriter to open from
- * @param applyAllDeletes If true, all buffered deletes will
- * be applied (made visible) in the returned reader. If
- * false, the deletes are not applied but remain buffered
- * (in IndexWriter) so that they will be applied in the
- * future. Applying deletes can be costly, so if your app
- * can tolerate deleted documents being returned you might
- * gain some performance by passing false.
+ * Open a near real time IndexReader from the
+ * {@link org.apache.lucene.index.IndexWriter}.
+ *
+ * @param writer
+ * The IndexWriter to open from
+ * @param applyAllDeletes
+ * If true, all buffered deletes will be applied (made visible) in
+ * the returned reader. If false, the deletes are not applied but
+ * remain buffered (in IndexWriter) so that they will be applied in
+ * the future. Applying deletes can be costly, so if your app can
+ * tolerate deleted documents being returned you might gain some
+ * performance by passing false.
* @return The new IndexReader
* @throws CorruptIndexException
- * @throws IOException if there is a low-level IO error
- *
+ * @throws IOException
+ * if there is a low-level IO error
+ *
* @see DirectoryReader#openIfChanged(DirectoryReader,IndexWriter,boolean)
- *
+ *
* @lucene.experimental
* @deprecated Use {@link DirectoryReader#open(IndexWriter,boolean)}
*/
@Deprecated
- public static DirectoryReader open(final IndexWriter writer, boolean applyAllDeletes) throws CorruptIndexException, IOException {
+ public static DirectoryReader open(final IndexWriter writer,
+ boolean applyAllDeletes) throws CorruptIndexException, IOException {
return DirectoryReader.open(writer, applyAllDeletes);
}
-
- /** Expert: returns an IndexReader reading the index in the given
- * {@link IndexCommit}.
- * @param commit the commit point to open
- * @throws CorruptIndexException if the index is corrupt
- * @throws IOException if there is a low-level IO error
+
+ /**
+ * Expert: returns an IndexReader reading the index in the given
+ * {@link IndexCommit}.
+ *
+ * @param commit
+ * the commit point to open
+ * @throws CorruptIndexException
+ * if the index is corrupt
+ * @throws IOException
+ * if there is a low-level IO error
* @deprecated Use {@link DirectoryReader#open(IndexCommit)}
*/
@Deprecated
- public static DirectoryReader open(final IndexCommit commit) throws CorruptIndexException, IOException {
+ public static DirectoryReader open(final IndexCommit commit)
+ throws CorruptIndexException, IOException {
return DirectoryReader.open(commit);
}
-
-
- /** Expert: returns an IndexReader reading the index in the given
- * {@link IndexCommit} and termInfosIndexDivisor.
- * @param commit the commit point to open
- * @param termInfosIndexDivisor Subsamples which indexed
- * terms are loaded into RAM. This has the same effect as {@link
- * IndexWriterConfig#setTermIndexInterval} except that setting
- * must be done at indexing time while this setting can be
- * set per reader. When set to N, then one in every
- * N*termIndexInterval terms in the index is loaded into
- * memory. By setting this to a value > 1 you can reduce
- * memory usage, at the expense of higher latency when
- * loading a TermInfo. The default value is 1. Set this
- * to -1 to skip loading the terms index entirely.
- * @throws CorruptIndexException if the index is corrupt
- * @throws IOException if there is a low-level IO error
+
+ /**
+ * Expert: returns an IndexReader reading the index in the given
+ * {@link IndexCommit} and termInfosIndexDivisor.
+ *
+ * @param commit
+ * the commit point to open
+ * @param termInfosIndexDivisor
+ * Subsamples which indexed terms are loaded into RAM. This has the
+ * same effect as {@link IndexWriterConfig#setTermIndexInterval}
+ * except that setting must be done at indexing time while this
+ * setting can be set per reader. When set to N, then one in every
+ * N*termIndexInterval terms in the index is loaded into memory. By
+ * setting this to a value > 1 you can reduce memory usage, at the
+ * expense of higher latency when loading a TermInfo. The default
+ * value is 1. Set this to -1 to skip loading the terms index
+ * entirely.
+ * @throws CorruptIndexException
+ * if the index is corrupt
+ * @throws IOException
+ * if there is a low-level IO error
* @deprecated Use {@link DirectoryReader#open(IndexCommit,int)}
*/
@Deprecated
- public static DirectoryReader open(final IndexCommit commit, int termInfosIndexDivisor) throws CorruptIndexException, IOException {
+ public static DirectoryReader open(final IndexCommit commit,
+ int termInfosIndexDivisor) throws CorruptIndexException, IOException {
return DirectoryReader.open(commit, termInfosIndexDivisor);
}
-
- /** Retrieve term vectors for this document, or null if
- * term vectors were not indexed. The returned Fields
- * instance acts like a single-document inverted index
- * (the docID will be 0). */
- public abstract Fields getTermVectors(int docID)
- throws IOException;
-
- /** Retrieve term vector for this document and field, or
- * null if term vectors were not indexed. The returned
- * Fields instance acts like a single-document inverted
- * index (the docID will be 0). */
- public final Terms getTermVector(int docID, String field)
- throws IOException {
+
+ /**
+ * Retrieve term vectors for this document, or null if term vectors were not
+ * indexed. The returned Fields instance acts like a single-document inverted
+ * index (the docID will be 0).
+ */
+ public abstract Fields getTermVectors(int docID) throws IOException;
+
+ /**
+ * Retrieve term vector for this document and field, or null if term vectors
+ * were not indexed. The returned Fields instance acts like a single-document
+ * inverted index (the docID will be 0).
+ */
+ public final Terms getTermVector(int docID, String field) throws IOException {
Fields vectors = getTermVectors(docID);
if (vectors == null) {
return null;
}
return vectors.terms(field);
}
-
+
/** Returns the number of documents in this index. */
public abstract int numDocs();
-
- /** Returns one greater than the largest possible document number.
- * This may be used to, e.g., determine how big to allocate an array which
- * will have an element for every document number in an index.
+
+ /**
+ * Returns one greater than the largest possible document number. This may be
+ * used to, e.g., determine how big to allocate an array which will have an
+ * element for every document number in an index.
*/
public abstract int maxDoc();
-
+
/** Returns the number of deleted documents. */
public final int numDeletedDocs() {
return maxDoc() - numDocs();
}
-
- /** Expert: visits the fields of a stored document, for
- * custom processing/loading of each field. If you
- * simply want to load all fields, use {@link
- * #document(int)}. If you want to load a subset, use
- * {@link DocumentStoredFieldVisitor}. */
- public abstract void document(int docID, StoredFieldVisitor visitor) throws CorruptIndexException, IOException;
/**
+ * Expert: visits the fields of a stored document, for custom
+ * processing/loading of each field. If you simply want to load all fields,
+ * use {@link #document(int)}. If you want to load a subset, use
+ * {@link DocumentStoredFieldVisitor}.
+ */
+ public abstract void document(int docID, StoredFieldVisitor visitor)
+ throws CorruptIndexException, IOException;
+
+ /**
* Returns the stored fields of the
* NOTE: for performance reasons, this method does not check if the
* requested document is deleted, and therefore asking for a deleted document
* may yield unspecified results. Usually this is not required, however you
- * can test if the doc is deleted by checking the {@link
- * Bits} returned from {@link MultiFields#getLiveDocs}.
- *
- * NOTE: only the content of a field is returned,
- * if that field was stored during indexing. Metadata
- * like boost, omitNorm, IndexOptions, tokenized, etc.,
- * are not preserved.
+ * can test if the doc is deleted by checking the {@link Bits} returned from
+ * {@link MultiFields#getLiveDocs}.
*
- * @throws CorruptIndexException if the index is corrupt
- * @throws IOException if there is a low-level IO error
+ * NOTE: only the content of a field is returned, if that field was
+ * stored during indexing. Metadata like boost, omitNorm, IndexOptions,
+ * tokenized, etc., are not preserved.
+ *
+ * @throws CorruptIndexException
+ * if the index is corrupt
+ * @throws IOException
+ * if there is a low-level IO error
*/
// TODO: we need a separate StoredField, so that the
// Document returned here contains that class not
// IndexableField
- public final Document document(int docID) throws CorruptIndexException, IOException {
+ public final StoredDocument document(int docID) throws CorruptIndexException,
+ IOException {
final DocumentStoredFieldVisitor visitor = new DocumentStoredFieldVisitor();
document(docID, visitor);
return visitor.getDocument();
}
-
+
/**
- * Like {@link #document(int)} but only loads the specified
- * fields. Note that this is simply sugar for {@link
- * DocumentStoredFieldVisitor#DocumentStoredFieldVisitor(Set)}.
+ * Like {@link #document(int)} but only loads the specified fields. Note that
+ * this is simply sugar for
+ * {@link DocumentStoredFieldVisitor#DocumentStoredFieldVisitor(Set)}.
*/
- public final Document document(int docID, Set
- * Note: Any of the sub-{@link CompositeReaderContext} instances reference from this
- * top-level context holds a IndexReader instance; use your own
+ * (non-Lucene) objects instead.
+ */
public abstract class IndexReader implements Closeable {
private boolean closed = false;
private boolean closedByChild = false;
private final AtomicInteger refCount = new AtomicInteger(1);
-
+
IndexReader() {
- if (!(this instanceof CompositeReader || this instanceof AtomicReader))
- throw new Error("IndexReader should never be directly extended, subclass AtomicReader or CompositeReader instead.");
+ if (!(this instanceof CompositeReader || this instanceof AtomicReader)) throw new Error(
+ "IndexReader should never be directly extended, subclass AtomicReader or CompositeReader instead.");
}
/**
- * A custom listener that's invoked when the IndexReader
- * is closed.
- *
+ * A custom listener that's invoked when the IndexReader is closed.
+ *
* @lucene.experimental
*/
public static interface ReaderClosedListener {
public void onClose(IndexReader reader);
}
-
- private final Settrue iff the refCount was
- * successfully incremented, otherwise false.
- * If this method returns false the reader is either
- * already closed or is currently been closed. Either way this
- * reader instance shouldn't be used by an application unless
- * true is returned.
+ * Expert: increments the refCount of this IndexReader instance only if the
+ * IndexReader has not been closed yet and returns true iff the
+ * refCount was successfully incremented, otherwise false. If
+ * this method returns false the reader is either already closed
+ * or is currently been closed. Either way this reader instance shouldn't be
+ * used by an application unless true is returned.
* nth
- * Document in this index. This is just
- * sugar for using {@link DocumentStoredFieldVisitor}.
+ * Document in this index. This is just sugar for using
+ * {@link DocumentStoredFieldVisitor}.
* null {@link CompositeReaderContext#leaves()}
- * reference. Only the top-level context maintains the convenience leaf-view
- * for performance reasons.
+ * Note: Any of the sub-{@link CompositeReaderContext} instances reference
+ * from this top-level context holds a null
+ * {@link CompositeReaderContext#leaves()} reference. Only the top-level
+ * context maintains the convenience leaf-view for performance reasons.
*
* @lucene.experimental
*/
public abstract IndexReaderContext getTopReaderContext();
-
- /** Expert: Returns a key for this IndexReader, so FieldCache/CachingWrapperFilter can find
- * it again.
- * This key must not have equals()/hashCode() methods, so "equals" means "identical". */
+
+ /**
+ * Expert: Returns a key for this IndexReader, so
+ * FieldCache/CachingWrapperFilter can find it again. This key must not have
+ * equals()/hashCode() methods, so "equals" means
+ * "identical".
+ */
public Object getCoreCacheKey() {
// Don't can ensureOpen since FC calls this (to evict)
// on close
return this;
}
-
- /** Expert: Returns a key for this IndexReader that also includes deletions,
- * so FieldCache/CachingWrapperFilter can find it again.
- * This key must not have equals()/hashCode() methods, so "equals" means "identical". */
+
+ /**
+ * Expert: Returns a key for this IndexReader that also includes deletions, so
+ * FieldCache/CachingWrapperFilter can find it again. This key must not have
+ * equals()/hashCode() methods, so "equals" means
+ * "identical".
+ */
public Object getCombinedCoreAndDeletesKey() {
// Don't can ensureOpen since FC calls this (to evict)
// on close
return this;
}
- /** Returns the number of documents containing the
- * term. This method returns 0 if the term or
- * field does not exists. This method does not take into
- * account deleted documents that have not yet been merged
- * away. */
+ /**
+ * Returns the number of documents containing the term. This
+ * method returns 0 if the term or field does not exists. This method does not
+ * take into account deleted documents that have not yet been merged away.
+ */
public final int docFreq(Term term) throws IOException {
return docFreq(term.field(), term.bytes());
}
-
- /** Returns the number of documents containing the
- * term. This method returns 0 if the term or
- * field does not exists. This method does not take into
- * account deleted documents that have not yet been merged
- * away. */
+
+ /**
+ * Returns the number of documents containing the term. This
+ * method returns 0 if the term or field does not exists. This method does not
+ * take into account deleted documents that have not yet been merged away.
+ */
public abstract int docFreq(String field, BytesRef term) throws IOException;
}
Index: lucene/core/src/java/org/apache/lucene/index/IndexWriter.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/index/IndexWriter.java (revision 1340366)
+++ lucene/core/src/java/org/apache/lucene/index/IndexWriter.java (working copy)
@@ -1011,7 +1011,7 @@
* @throws CorruptIndexException if the index is corrupt
* @throws IOException if there is a low-level IO error
*/
- public void addDocument(Iterable doc) throws CorruptIndexException, IOException {
+ public void addDocument(IndexDocument doc) throws CorruptIndexException, IOException {
addDocument(doc, analyzer);
}
@@ -1030,7 +1030,7 @@
* @throws CorruptIndexException if the index is corrupt
* @throws IOException if there is a low-level IO error
*/
- public void addDocument(Iterable doc, Analyzer analyzer) throws CorruptIndexException, IOException {
+ public void addDocument(IndexDocument doc, Analyzer analyzer) throws CorruptIndexException, IOException {
updateDocument(null, doc, analyzer);
}
@@ -1068,7 +1068,7 @@
*
* @lucene.experimental
*/
- public void addDocuments(Iterable> docs) throws CorruptIndexException, IOException {
+ public void addDocuments(Iterable docs) throws CorruptIndexException, IOException {
addDocuments(docs, analyzer);
}
@@ -1083,7 +1083,7 @@
*
* @lucene.experimental
*/
- public void addDocuments(Iterable> docs, Analyzer analyzer) throws CorruptIndexException, IOException {
+ public void addDocuments(Iterable docs, Analyzer analyzer) throws CorruptIndexException, IOException {
updateDocuments(null, docs, analyzer);
}
@@ -1100,7 +1100,7 @@
*
* @lucene.experimental
*/
- public void updateDocuments(Term delTerm, Iterable> docs) throws CorruptIndexException, IOException {
+ public void updateDocuments(Term delTerm, Iterable docs) throws CorruptIndexException, IOException {
updateDocuments(delTerm, docs, analyzer);
}
@@ -1118,7 +1118,7 @@
*
* @lucene.experimental
*/
- public void updateDocuments(Term delTerm, Iterable> docs, Analyzer analyzer) throws CorruptIndexException, IOException {
+ public void updateDocuments(Term delTerm, Iterable docs, Analyzer analyzer) throws CorruptIndexException, IOException {
ensureOpen();
try {
boolean success = false;
@@ -1243,7 +1243,7 @@
* @throws CorruptIndexException if the index is corrupt
* @throws IOException if there is a low-level IO error
*/
- public void updateDocument(Term term, Iterable doc) throws CorruptIndexException, IOException {
+ public void updateDocument(Term term, IndexDocument doc) throws CorruptIndexException, IOException {
ensureOpen();
updateDocument(term, doc, getAnalyzer());
}
@@ -1266,7 +1266,7 @@
* @throws CorruptIndexException if the index is corrupt
* @throws IOException if there is a low-level IO error
*/
- public void updateDocument(Term term, Iterable doc, Analyzer analyzer)
+ public void updateDocument(Term term, IndexDocument doc, Analyzer analyzer)
throws CorruptIndexException, IOException {
ensureOpen();
try {
Index: lucene/core/src/java/org/apache/lucene/index/Norm.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/index/Norm.java (revision 1340366)
+++ lucene/core/src/java/org/apache/lucene/index/Norm.java (working copy)
@@ -26,6 +26,7 @@
import org.apache.lucene.document.PackedLongDocValuesField;
import org.apache.lucene.document.ShortDocValuesField;
import org.apache.lucene.document.SortedBytesDocValuesField;
+import org.apache.lucene.document.StoredField;
import org.apache.lucene.document.StraightBytesDocValuesField;
import org.apache.lucene.index.DocValues.Type;
import org.apache.lucene.search.similarities.Similarity;
@@ -43,13 +44,13 @@
* @lucene.internal
*/
public final class Norm {
- private Field field;
+ private StoredField field;
private BytesRef spare;
/**
* Returns the {@link IndexableField} representation for this norm
*/
- public IndexableField field() {
+ public StoredField field() {
return field;
}
Index: lucene/core/src/java/org/apache/lucene/index/NormsConsumerPerField.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/index/NormsConsumerPerField.java (revision 1340366)
+++ lucene/core/src/java/org/apache/lucene/index/NormsConsumerPerField.java (working copy)
@@ -51,10 +51,10 @@
similarity.computeNorm(fieldState, norm);
if (norm.type() != null) {
- IndexableField field = norm.field();
+ StorableField field = norm.field();
// some similarity might not compute any norms
DocValuesConsumer consumer = getConsumer(norm.type());
- consumer.add(docState.docID, field);
+ consumer.add(docState.docID, (StorableField) field);
}
}
}
Index: lucene/core/src/java/org/apache/lucene/index/PersistentSnapshotDeletionPolicy.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/index/PersistentSnapshotDeletionPolicy.java (revision 1340366)
+++ lucene/core/src/java/org/apache/lucene/index/PersistentSnapshotDeletionPolicy.java (working copy)
@@ -26,6 +26,8 @@
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.FieldType;
+import org.apache.lucene.document.StoredDocument;
+import org.apache.lucene.document.StoredField;
import org.apache.lucene.index.IndexWriterConfig.OpenMode;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.LockObtainFailedException;
@@ -68,12 +70,12 @@
int numDocs = r.numDocs();
// index is allowed to have exactly one document or 0.
if (numDocs == 1) {
- Document doc = r.document(r.maxDoc() - 1);
+ StoredDocument doc = r.document(r.maxDoc() - 1);
if (doc.getField(SNAPSHOTS_ID) == null) {
throw new IllegalStateException("directory is not a valid snapshots store!");
}
doc.removeField(SNAPSHOTS_ID);
- for (IndexableField f : doc) {
+ for (StorableField f : doc) {
snapshots.put(f.name(), f.stringValue());
}
} else if (numDocs != 0) {
@@ -186,14 +188,12 @@
private void persistSnapshotInfos(String id, String segment) throws IOException {
writer.deleteAll();
Document d = new Document();
- FieldType ft = new FieldType();
- ft.setStored(true);
- d.add(new Field(SNAPSHOTS_ID, "", ft));
+ d.add(new StoredField(SNAPSHOTS_ID, ""));
for (Entry.getIndexReader().document(docID, fieldsToLoad) */
- public final Document document(int docID, Set