Note that for simple usage, {@link NumericField} is - * recommended. {@link NumericField} disables norms and + *
Note that for simple usage, {@link IntField}, {@link + * LongField}, {@link FloatField} or {@link DoubleField} is + * recommended. These fields disable norms and * term freqs, as they are not usually needed during * searching. If you need to change these settings, you * should use this class. * - *
See {@link NumericField} for capabilities of fields - * indexed numerically.
- * *Here's an example usage, for an int field:
*
*
Index: lucene/core/src/java/org/apache/lucene/codecs/DocValuesConsumer.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/codecs/DocValuesConsumer.java (revision 1245156)
+++ lucene/core/src/java/org/apache/lucene/codecs/DocValuesConsumer.java (working copy)
@@ -167,18 +167,18 @@
case BYTES_VAR_DEREF:
case BYTES_VAR_SORTED:
case BYTES_VAR_STRAIGHT:
- scratchField.setValue(source.getBytes(sourceDoc, spare));
+ scratchField.setBytesValue(source.getBytes(sourceDoc, spare));
break;
case FIXED_INTS_16:
case FIXED_INTS_32:
case FIXED_INTS_64:
case FIXED_INTS_8:
case VAR_INTS:
- scratchField.setValue(source.getInt(sourceDoc));
+ scratchField.setLongValue(source.getInt(sourceDoc));
break;
case FLOAT_32:
case FLOAT_64:
- scratchField.setValue(source.getFloat(sourceDoc));
+ scratchField.setDoubleValue(source.getFloat(sourceDoc));
break;
}
add(docID, scratchField);
Index: lucene/core/src/java/org/apache/lucene/search/NumericRangeFilter.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/search/NumericRangeFilter.java (revision 1245156)
+++ lucene/core/src/java/org/apache/lucene/search/NumericRangeFilter.java (working copy)
@@ -18,13 +18,17 @@
*/
import org.apache.lucene.analysis.NumericTokenStream; // for javadocs
-import org.apache.lucene.document.NumericField; // for javadocs
+import org.apache.lucene.document.DoubleField; // for javadocs
+import org.apache.lucene.document.FloatField; // for javadocs
+import org.apache.lucene.document.IntField; // for javadocs
+import org.apache.lucene.document.LongField; // for javadocs
import org.apache.lucene.util.NumericUtils; // for javadocs
/**
* A {@link Filter} that only accepts numeric values within
* a specified range. To use this, you must first index the
- * numeric values using {@link NumericField} (expert: {@link
+ * numeric values using {@link IntField}, {@link
+ * FloatField}, {@link LongField} or {@link DoubleField} (expert: {@link
* NumericTokenStream}).
*
* You create a new NumericRangeFilter with the static
Index: lucene/core/src/java/org/apache/lucene/search/package.html
===================================================================
--- lucene/core/src/java/org/apache/lucene/search/package.html (revision 1245156)
+++ lucene/core/src/java/org/apache/lucene/search/package.html (working copy)
@@ -166,8 +166,9 @@
NumericRangeQuery
matches all documents that occur in a numeric range.
For NumericRangeQuery to work, you must index the values
- using a special
- NumericField.
+ using a one of the numeric fields (IntField,
+ LongField, FloatField,
+ or DoubleField).
Index: lucene/core/src/java/org/apache/lucene/search/NumericRangeQuery.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/search/NumericRangeQuery.java (revision 1245156)
+++ lucene/core/src/java/org/apache/lucene/search/NumericRangeQuery.java (working copy)
@@ -22,8 +22,11 @@
import java.util.LinkedList;
import org.apache.lucene.analysis.NumericTokenStream; // for javadocs
-import org.apache.lucene.document.NumericField; // for javadocs
-import org.apache.lucene.document.NumericField.DataType;
+import org.apache.lucene.document.DoubleField; // for javadocs
+import org.apache.lucene.document.FloatField; // for javadocs
+import org.apache.lucene.document.IntField; // for javadocs
+import org.apache.lucene.document.LongField; // for javadocs
+import org.apache.lucene.document.FieldType.NumericType;
import org.apache.lucene.index.FilteredTermsEnum;
import org.apache.lucene.index.Terms;
import org.apache.lucene.index.TermsEnum;
@@ -35,7 +38,8 @@
/**
*
A {@link Query} that matches numeric values within a
* specified range. To use this, you must first index the
- * numeric values using {@link NumericField} (expert: {@link
+ * numeric values using {@link IntField}, {@link
+ * FloatField}, {@link LongField} or {@link DoubleField} (expert: {@link
* NumericTokenStream}). If your terms are instead textual,
* you should use {@link TermRangeQuery}. {@link
* NumericRangeFilter} is the filter equivalent of this
@@ -137,7 +141,8 @@
*
precisionStep). Using {@link NumericField NumericFields} for sorting
+ * precisionStep). Using {@link IntField},
+ * {@link LongField}, {@link FloatField} or {@link DoubleField} for sorting
* is ideal, because building the field cache is much faster than with text-only numbers.
* These fields have one term per value and therefore also work with term enumeration for building distinct lists
* (e.g. facets / preselected values to search for).
@@ -155,7 +160,7 @@
**/
public final class NumericRangeQueryAs with all {@link FieldCache} based functionality, {@code FieldCacheRangeFilter} is only valid for Index: lucene/core/src/java/org/apache/lucene/index/Norm.java =================================================================== --- lucene/core/src/java/org/apache/lucene/index/Norm.java (revision 1245156) +++ lucene/core/src/java/org/apache/lucene/index/Norm.java (working copy) @@ -65,7 +65,7 @@ */ public void setFloat(float norm) { setType(Type.FLOAT_32); - this.field.setValue(norm); + this.field.setFloatValue(norm); } /** @@ -73,7 +73,7 @@ */ public void setDouble(double norm) { setType(Type.FLOAT_64); - this.field.setValue(norm); + this.field.setDoubleValue(norm); } /** @@ -81,7 +81,7 @@ */ public void setShort(short norm) { setType(Type.FIXED_INTS_16); - this.field.setValue(norm); + this.field.setIntValue(norm); } @@ -90,7 +90,7 @@ */ public void setInt(int norm) { setType(Type.FIXED_INTS_32); - this.field.setValue(norm); + this.field.setIntValue(norm); } /** @@ -98,7 +98,7 @@ */ public void setLong(long norm) { setType(Type.FIXED_INTS_64); - this.field.setValue(norm); + this.field.setLongValue(norm); } /** @@ -106,7 +106,7 @@ */ public void setByte(byte norm) { setType(Type.FIXED_INTS_8); - this.field.setValue(norm); + this.field.setIntValue(norm); } /** @@ -114,7 +114,7 @@ */ public void setBytes(BytesRef norm) { setType(Type.BYTES_FIXED_STRAIGHT); - this.field.setValue(norm); + this.field.setBytesValue(norm); } Index: lucene/core/src/java/org/apache/lucene/util/NumericUtils.java =================================================================== --- lucene/core/src/java/org/apache/lucene/util/NumericUtils.java (revision 1245156) +++ lucene/core/src/java/org/apache/lucene/util/NumericUtils.java (working copy) @@ -18,7 +18,10 @@ */ import org.apache.lucene.analysis.NumericTokenStream; -import org.apache.lucene.document.NumericField; +import org.apache.lucene.document.DoubleField; // javadocs +import org.apache.lucene.document.FloatField; // javadocs +import org.apache.lucene.document.IntField; // javadocs +import org.apache.lucene.document.LongField; // javadocs import org.apache.lucene.search.NumericRangeFilter; import org.apache.lucene.search.NumericRangeQuery; // for javadocs @@ -63,8 +66,10 @@ private NumericUtils() {} // no instance! /** - * The default precision step used by {@link NumericField}, {@link NumericTokenStream}, - * {@link NumericRangeQuery}, and {@link NumericRangeFilter} as default + * The default precision step used by {@link IntField}, + * {@link FloatField}, {@link LongField}, {@link + * DoubleField}, {@link NumericTokenStream}, {@link + * NumericRangeQuery}, and {@link NumericRangeFilter}. */ public static final int PRECISION_STEP_DEFAULT = 4; Index: lucene/core/src/java/org/apache/lucene/document/LongField.java =================================================================== --- lucene/core/src/java/org/apache/lucene/document/LongField.java (revision 0) +++ lucene/core/src/java/org/apache/lucene/document/LongField.java (working copy) @@ -0,0 +1,158 @@ +package org.apache.lucene.document; + +/** + * 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 org.apache.lucene.analysis.NumericTokenStream; // javadocs +import org.apache.lucene.index.FieldInfo.IndexOptions; +import org.apache.lucene.search.FieldCache; // javadocs +import org.apache.lucene.search.NumericRangeFilter; // javadocs +import org.apache.lucene.search.NumericRangeQuery; // javadocs +import org.apache.lucene.util.NumericUtils; + +/** + *
+ * This class provides a {@link Field} that enables indexing of long values + * for efficient range filtering and sorting. Here's an example usage: + * + *
+ * document.add(new LongField(name, 6L)); + *+ * + * For optimal performance, re-use the
LongField and
+ * {@link Document} instance for more than one document:
+ *
+ *
+ * LongField field = new LongField(name, 0L);
+ * Document document = new Document();
+ * document.add(field);
+ *
+ * for(all documents) {
+ * ...
+ * field.setLongValue(value)
+ * writer.addDocument(document);
+ * ...
+ * }
+ *
+ *
+ * See also {@link IntField}, {@link FloatField}, {@link
+ * DoubleField}.
+ *
+ * Any type that can be converted to long can also be
+ * indexed. For example, date/time values represented by a
+ * {@link java.util.Date} can be translated into a long
+ * value using the {@link java.util.Date#getTime} method. If you
+ * don't need millisecond precision, you can quantize the
+ * value, either by dividing the result of
+ * {@link java.util.Date#getTime} or using the separate getters
+ * (for year, month, etc.) to construct an int or
+ * long value.
+ *
+ * To perform range querying or filtering against a
+ * LongField, use {@link NumericRangeQuery} or {@link
+ * NumericRangeFilter}. To sort according to a
+ * LongField, use the normal numeric sort types, eg
+ * {@link org.apache.lucene.search.SortField.Type#LONG}. LongField
+ * values can also be loaded directly from {@link FieldCache}.
By default, a LongField's value is not stored but
+ * is indexed for range filtering and sorting. You can use
+ * {@link StoredField} to also store the value.
+ *
+ *
You may add the same field name as an LongField to
+ * the same document more than once. Range querying and
+ * filtering will be the logical OR of all values; so a range query
+ * will hit all documents that have at least one value in
+ * the range. However sort behavior is not defined. If you need to sort,
+ * you should separately index a single-valued LongField.
A LongField will consume somewhat more disk space
+ * in the index than an ordinary single-valued field.
+ * However, for a typical index that includes substantial
+ * textual content per document, this increase will likely
+ * be in the noise.
Within Lucene, each numeric value is indexed as a
+ * trie structure, where each term is logically
+ * assigned to larger and larger pre-defined brackets (which
+ * are simply lower-precision representations of the value).
+ * The step size between each successive bracket is called the
+ * precisionStep, measured in bits. Smaller
+ * precisionStep values result in larger number
+ * of brackets, which consumes more disk space in the index
+ * but may result in faster range search performance. The
+ * default value, 4, was selected for a reasonable tradeoff
+ * of disk space consumption versus performance. You can
+ * create a custom {@link FieldType} and invoke the {@link
+ * FieldType#setNumericPrecisionStep} method if you'd
+ * like to change the value. Note that you must also
+ * specify a congruent value when creating {@link
+ * NumericRangeQuery} or {@link NumericRangeFilter}.
+ * For low cardinality fields larger precision steps are good.
+ * If the cardinality is < 100, it is fair
+ * to use {@link Integer#MAX_VALUE}, which produces one
+ * term per value.
+ *
+ *
For more information on the internals of numeric trie
+ * indexing, including the precisionStep
+ * configuration, see {@link NumericRangeQuery}. The format of
+ * indexed values is described in {@link NumericUtils}.
+ *
+ *
If you only need to sort by numeric value, and never
+ * run range querying/filtering, you can index using a
+ * precisionStep of {@link Integer#MAX_VALUE}.
+ * This will minimize disk space consumed.
More advanced users can instead use {@link + * NumericTokenStream} directly, when indexing numbers. This + * class is a wrapper around this token stream type for + * easier, more intuitive usage.
+ * + * @since 2.9 + */ + +public final class LongField extends Field { + + public static final FieldType TYPE = new FieldType(); + static { + TYPE.setIndexed(true); + TYPE.setTokenized(true); + TYPE.setOmitNorms(true); + TYPE.setIndexOptions(IndexOptions.DOCS_ONLY); + TYPE.setNumericType(FieldType.NumericType.LONG); + TYPE.freeze(); + } + + /** Creates an LongField with the provided value + * and defaultprecisionStep {@link
+ * NumericUtils#PRECISION_STEP_DEFAULT} (4). */
+ public LongField(String name, long value) {
+ super(name, TYPE);
+ fieldsData = Long.valueOf(value);
+ }
+
+ /** Expert: allows you to customize the {@link
+ * FieldType}. */
+ public LongField(String name, long value, FieldType type) {
+ super(name, type);
+ if (type.numericType() != FieldType.NumericType.LONG) {
+ throw new IllegalArgumentException("type.numericType() must be LONG but got " + type.numericType());
+ }
+ fieldsData = Long.valueOf(value);
+ }
+}
Property changes on: lucene/core/src/java/org/apache/lucene/document/LongField.java
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
Index: lucene/core/src/java/org/apache/lucene/document/NumericField.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/document/NumericField.java (revision 1245156)
+++ lucene/core/src/java/org/apache/lucene/document/NumericField.java (working copy)
@@ -1,223 +0,0 @@
-package org.apache.lucene.document;
-
-/**
- * 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 org.apache.lucene.analysis.NumericTokenStream; // javadocs
-import org.apache.lucene.document.NumericField.DataType;
-import org.apache.lucene.index.FieldInfo.IndexOptions;
-import org.apache.lucene.search.FieldCache; // javadocs
-import org.apache.lucene.search.NumericRangeFilter; // javadocs
-import org.apache.lucene.search.NumericRangeQuery; // javadocs
-import org.apache.lucene.util.NumericUtils;
-
-/**
- * - * This class provides a {@link Field} that enables indexing of numeric values - * for efficient range filtering and sorting. Here's an example usage, adding an - * int value: - * - *
- * document.add(new NumericField(name, value)); - *- * - * For optimal performance, re-use the
NumericField and
- * {@link Document} instance for more than one document:
- *
- *
- * NumericField field = new NumericField(name, NumericField.DataType.INT);
- * Document document = new Document();
- * document.add(field);
- *
- * for(all documents) {
- * ...
- * field.setValue(value)
- * writer.addDocument(document);
- * ...
- * }
- *
- *
- * The java native types int, long,
- * float and double are
- * directly supported. However, any value that can be
- * converted into these native types can also be indexed.
- * For example, date/time values represented by a
- * {@link java.util.Date} can be translated into a long
- * value using the {@link java.util.Date#getTime} method. If you
- * don't need millisecond precision, you can quantize the
- * value, either by dividing the result of
- * {@link java.util.Date#getTime} or using the separate getters
- * (for year, month, etc.) to construct an int or
- * long value.
To perform range querying or filtering against a
- * NumericField, use {@link NumericRangeQuery} or {@link
- * NumericRangeFilter}. To sort according to a
- * NumericField, use the normal numeric sort types, eg
- * {@link org.apache.lucene.search.SortField.Type#INT}. NumericField
- * values can also be loaded directly from {@link FieldCache}.
By default, a NumericField's value is not stored but
- * is indexed for range filtering and sorting. You can use
- * {@link Field#Field(String,int,FieldType)}, etc.,
- * if you need to change these defaults.
You may add the same field name as a NumericField to
- * the same document more than once. Range querying and
- * filtering will be the logical OR of all values; so a range query
- * will hit all documents that have at least one value in
- * the range. However sort behavior is not defined. If you need to sort,
- * you should separately index a single-valued NumericField.
A NumericField will consume somewhat more disk space
- * in the index than an ordinary single-valued field.
- * However, for a typical index that includes substantial
- * textual content per document, this increase will likely
- * be in the noise.
Within Lucene, each numeric value is indexed as a
- * trie structure, where each term is logically
- * assigned to larger and larger pre-defined brackets (which
- * are simply lower-precision representations of the value).
- * The step size between each successive bracket is called the
- * precisionStep, measured in bits. Smaller
- * precisionStep values result in larger number
- * of brackets, which consumes more disk space in the index
- * but may result in faster range search performance. The
- * default value, 4, was selected for a reasonable tradeoff
- * of disk space consumption versus performance. You can
- * create a custom {@link FieldType} and invoke the {@link
- * FieldType#setNumericPrecisionStep} method if you'd
- * like to change the value. Note that you must also
- * specify a congruent value when creating {@link
- * NumericRangeQuery} or {@link NumericRangeFilter}.
- * For low cardinality fields larger precision steps are good.
- * If the cardinality is < 100, it is fair
- * to use {@link Integer#MAX_VALUE}, which produces one
- * term per value.
- *
- *
For more information on the internals of numeric trie
- * indexing, including the precisionStep
- * configuration, see {@link NumericRangeQuery}. The format of
- * indexed values is described in {@link NumericUtils}.
- *
- *
If you only need to sort by numeric value, and never
- * run range querying/filtering, you can index using a
- * precisionStep of {@link Integer#MAX_VALUE}.
- * This will minimize disk space consumed.
More advanced users can instead use {@link - * NumericTokenStream} directly, when indexing numbers. This - * class is a wrapper around this token stream type for - * easier, more intuitive usage.
- * - * @since 2.9 - */ -public final class NumericField extends Field { - - /** Data type of the value in {@link NumericField}. - * @since 3.2 - */ - public static enum DataType {INT, LONG, FLOAT, DOUBLE} - - /** @lucene.experimental */ - public static FieldType getFieldType(DataType type, boolean stored) { - final FieldType ft = new FieldType(); - ft.setIndexed(true); - ft.setStored(stored); - ft.setTokenized(true); - ft.setOmitNorms(true); - ft.setIndexOptions(IndexOptions.DOCS_ONLY); - ft.setNumericType(type); - ft.freeze(); - return ft; - } - - private static final FieldType INT_TYPE = getFieldType(DataType.INT, false); - private static final FieldType LONG_TYPE = getFieldType(DataType.LONG, false); - private static final FieldType FLOAT_TYPE = getFieldType(DataType.FLOAT, false); - private static final FieldType DOUBLE_TYPE = getFieldType(DataType.DOUBLE, false); - - /** Creates an int NumericField with the provided value - * and defaultprecisionStep {@link
- * NumericUtils#PRECISION_STEP_DEFAULT} (4). */
- public NumericField(String name, int value) {
- super(name, INT_TYPE);
- fieldsData = Integer.valueOf(value);
- }
-
- /** Creates a long NumericField with the provided value.
- * and default precisionStep {@link
- * NumericUtils#PRECISION_STEP_DEFAULT} (4). */
- public NumericField(String name, long value) {
- super(name, LONG_TYPE);
- fieldsData = Long.valueOf(value);
- }
-
- /** Creates a float NumericField with the provided value.
- * and default precisionStep {@link
- * NumericUtils#PRECISION_STEP_DEFAULT} (4). */
- public NumericField(String name, float value) {
- super(name, FLOAT_TYPE);
- fieldsData = Float.valueOf(value);
- }
-
- /** Creates a double NumericField with the provided value.
- * and default precisionStep {@link
- * NumericUtils#PRECISION_STEP_DEFAULT} (4). */
- public NumericField(String name, double value) {
- super(name, DOUBLE_TYPE);
- fieldsData = Double.valueOf(value);
- }
-
- public NumericField(String name, Number value, FieldType type) {
- super(name, type);
- final NumericField.DataType numericType = type.numericType();
- if (numericType == null) {
- throw new IllegalArgumentException("FieldType.numericType() cannot be null");
- }
-
- switch(numericType) {
- case INT:
- if (!(value instanceof Integer)) {
- throw new IllegalArgumentException("value must be an Integer but got " + value);
- }
- break;
- case LONG:
- if (!(value instanceof Long)) {
- throw new IllegalArgumentException("value must be a Long but got " + value);
- }
- break;
- case FLOAT:
- if (!(value instanceof Float)) {
- throw new IllegalArgumentException("value must be a Float but got " + value);
- }
- break;
- case DOUBLE:
- if (!(value instanceof Double)) {
- throw new IllegalArgumentException("value must be a Double but got " + value);
- }
- break;
- default:
- assert false : "Should never get here";
- }
-
- fieldsData = value;
- }
-}
Index: lucene/core/src/java/org/apache/lucene/document/FloatField.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/document/FloatField.java (revision 0)
+++ lucene/core/src/java/org/apache/lucene/document/FloatField.java (working copy)
@@ -0,0 +1,148 @@
+package org.apache.lucene.document;
+
+/**
+ * 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 org.apache.lucene.analysis.NumericTokenStream; // javadocs
+import org.apache.lucene.index.FieldInfo.IndexOptions;
+import org.apache.lucene.search.FieldCache; // javadocs
+import org.apache.lucene.search.NumericRangeFilter; // javadocs
+import org.apache.lucene.search.NumericRangeQuery; // javadocs
+import org.apache.lucene.util.NumericUtils;
+
+/**
+ * + * This class provides a {@link Field} that enables indexing of float values + * for efficient range filtering and sorting. Here's an example usage: + * + *
+ * document.add(new FloatField(name, 6.0F)); + *+ * + * For optimal performance, re-use the
FloatField and
+ * {@link Document} instance for more than one document:
+ *
+ *
+ * FloatField field = new FloatField(name, 0.0F);
+ * Document document = new Document();
+ * document.add(field);
+ *
+ * for(all documents) {
+ * ...
+ * field.setFloatValue(value)
+ * writer.addDocument(document);
+ * ...
+ * }
+ *
+ *
+ * See also {@link IntField}, {@link LongField}, {@link
+ * DoubleField}.
+ *
+ * To perform range querying or filtering against a
+ * FloatField, use {@link NumericRangeQuery} or {@link
+ * NumericRangeFilter}. To sort according to a
+ * FloatField, use the normal numeric sort types, eg
+ * {@link org.apache.lucene.search.SortField.Type#FLOAT}. FloatField
+ * values can also be loaded directly from {@link FieldCache}.
By default, a FloatField's value is not stored but
+ * is indexed for range filtering and sorting. You can use
+ * {@link StoredField} to also store the value.
+ *
+ *
You may add the same field name as an FloatField to
+ * the same document more than once. Range querying and
+ * filtering will be the logical OR of all values; so a range query
+ * will hit all documents that have at least one value in
+ * the range. However sort behavior is not defined. If you need to sort,
+ * you should separately index a single-valued FloatField.
A FloatField will consume somewhat more disk space
+ * in the index than an ordinary single-valued field.
+ * However, for a typical index that includes substantial
+ * textual content per document, this increase will likely
+ * be in the noise.
Within Lucene, each numeric value is indexed as a
+ * trie structure, where each term is logically
+ * assigned to larger and larger pre-defined brackets (which
+ * are simply lower-precision representations of the value).
+ * The step size between each successive bracket is called the
+ * precisionStep, measured in bits. Smaller
+ * precisionStep values result in larger number
+ * of brackets, which consumes more disk space in the index
+ * but may result in faster range search performance. The
+ * default value, 4, was selected for a reasonable tradeoff
+ * of disk space consumption versus performance. You can
+ * create a custom {@link FieldType} and invoke the {@link
+ * FieldType#setNumericPrecisionStep} method if you'd
+ * like to change the value. Note that you must also
+ * specify a congruent value when creating {@link
+ * NumericRangeQuery} or {@link NumericRangeFilter}.
+ * For low cardinality fields larger precision steps are good.
+ * If the cardinality is < 100, it is fair
+ * to use {@link Integer#MAX_VALUE}, which produces one
+ * term per value.
+ *
+ *
For more information on the internals of numeric trie
+ * indexing, including the precisionStep
+ * configuration, see {@link NumericRangeQuery}. The format of
+ * indexed values is described in {@link NumericUtils}.
+ *
+ *
If you only need to sort by numeric value, and never
+ * run range querying/filtering, you can index using a
+ * precisionStep of {@link Integer#MAX_VALUE}.
+ * This will minimize disk space consumed.
More advanced users can instead use {@link + * NumericTokenStream} directly, when indexing numbers. This + * class is a wrapper around this token stream type for + * easier, more intuitive usage.
+ * + * @since 2.9 + */ + +public final class FloatField extends Field { + + public static final FieldType TYPE = new FieldType(); + static { + TYPE.setIndexed(true); + TYPE.setTokenized(true); + TYPE.setOmitNorms(true); + TYPE.setIndexOptions(IndexOptions.DOCS_ONLY); + TYPE.setNumericType(FieldType.NumericType.FLOAT); + TYPE.freeze(); + } + + /** Creates an LongField with the provided value + * and defaultprecisionStep {@link
+ * NumericUtils#PRECISION_STEP_DEFAULT} (4). */
+ public FloatField(String name, float value) {
+ super(name, TYPE);
+ fieldsData = Float.valueOf(value);
+ }
+
+ /** Expert: allows you to customize the {@link
+ * FieldType}. */
+ public FloatField(String name, float value, FieldType type) {
+ super(name, type);
+ if (type.numericType() != FieldType.NumericType.FLOAT) {
+ throw new IllegalArgumentException("type.numericType() must be FLOAT but got " + type.numericType());
+ }
+ fieldsData = Float.valueOf(value);
+ }
+}
Property changes on: lucene/core/src/java/org/apache/lucene/document/FloatField.java
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
Index: lucene/core/src/java/org/apache/lucene/document/package.html
===================================================================
--- lucene/core/src/java/org/apache/lucene/document/package.html (revision 1245156)
+++ lucene/core/src/java/org/apache/lucene/document/package.html (working copy)
@@ -41,7 +41,8 @@
for extracting content from HTML.
The {@link org.apache.lucene.document.DateTools} is a utility class to make dates and times searchable -(remember, Lucene only searches text). {@link org.apache.lucene.document.NumericField} is a special helper class +(remember, Lucene only searches text). {@link org.apache.lucene.document.IntField}, {@link org.apache.lucene.document.LongField}, +{@link org.apache.lucene.document.FloatField} and {@link org.apache.lucene.document.DoubleField} are a special helper class to simplify indexing of numeric values (and also dates) for fast range range queries with {@link org.apache.lucene.search.NumericRangeQuery} (using a special sortable string representation of numeric values).