You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by jp...@apache.org on 2017/05/30 08:34:08 UTC
[7/7] lucene-solr:master: LUCENE-7850: Move support for legacy
numerics to solr/.
LUCENE-7850: Move support for legacy numerics to solr/.
Project: http://git-wip-us.apache.org/repos/asf/lucene-solr/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucene-solr/commit/759fa42b
Tree: http://git-wip-us.apache.org/repos/asf/lucene-solr/tree/759fa42b
Diff: http://git-wip-us.apache.org/repos/asf/lucene-solr/diff/759fa42b
Branch: refs/heads/master
Commit: 759fa42b62779404c576710a2e589a6993aaf990
Parents: 412e4ae
Author: Adrien Grand <jp...@gmail.com>
Authored: Wed May 24 16:30:25 2017 +0200
Committer: Adrien Grand <jp...@gmail.com>
Committed: Tue May 30 10:33:08 2017 +0200
----------------------------------------------------------------------
lucene/CHANGES.txt | 2 +
lucene/MIGRATE.txt | 6 +
.../apache/lucene/legacy/LegacyDoubleField.java | 174 -----
.../org/apache/lucene/legacy/LegacyField.java | 90 ---
.../apache/lucene/legacy/LegacyFieldType.java | 149 ----
.../apache/lucene/legacy/LegacyFloatField.java | 174 -----
.../apache/lucene/legacy/LegacyIntField.java | 175 -----
.../apache/lucene/legacy/LegacyLongField.java | 184 -----
.../lucene/legacy/LegacyNumericRangeQuery.java | 537 --------------
.../lucene/legacy/LegacyNumericTokenStream.java | 357 ----------
.../apache/lucene/legacy/LegacyNumericType.java | 34 -
.../lucene/legacy/LegacyNumericUtils.java | 510 --------------
.../lucene/legacy/doc-files/nrq-formula-1.png | Bin 3171 -> 0 bytes
.../lucene/legacy/doc-files/nrq-formula-2.png | Bin 3694 -> 0 bytes
.../org/apache/lucene/legacy/package-info.java | 21 -
.../index/TestBackwardsCompatibility.java | 52 --
.../apache/lucene/legacy/TestLegacyField.java | 186 -----
.../lucene/legacy/TestLegacyFieldReuse.java | 81 ---
.../lucene/legacy/TestLegacyNumericUtils.java | 571 ---------------
.../apache/lucene/legacy/TestLegacyTerms.java | 164 -----
.../TestMultiValuedNumericRangeQuery.java | 84 ---
.../lucene/legacy/TestNumericRangeQuery32.java | 461 ------------
.../lucene/legacy/TestNumericRangeQuery64.java | 490 -------------
.../lucene/legacy/TestNumericTokenStream.java | 188 -----
.../lucene/spatial/bbox/BBoxStrategy.java | 59 +-
.../prefix/BytesRefIteratorTokenStream.java | 2 -
.../spatial/vector/PointVectorStrategy.java | 52 --
.../lucene/spatial/DistanceStrategyTest.java | 3 -
.../lucene/spatial/QueryEqualsHashCodeTest.java | 2 -
.../lucene/spatial/bbox/TestBBoxStrategy.java | 33 +-
.../spatial/vector/TestPointVectorStrategy.java | 7 +-
.../solr/analytics/util/AnalyticsParsers.java | 2 +-
.../util/valuesource/DateFieldSource.java | 2 +-
.../org/apache/solr/legacy/BBoxStrategy.java | 706 +++++++++++++++++++
.../org/apache/solr/legacy/BBoxValueSource.java | 135 ++++
.../apache/solr/legacy/DistanceValueSource.java | 133 ++++
.../apache/solr/legacy/LegacyDoubleField.java | 174 +++++
.../org/apache/solr/legacy/LegacyField.java | 90 +++
.../org/apache/solr/legacy/LegacyFieldType.java | 149 ++++
.../apache/solr/legacy/LegacyFloatField.java | 174 +++++
.../org/apache/solr/legacy/LegacyIntField.java | 175 +++++
.../org/apache/solr/legacy/LegacyLongField.java | 184 +++++
.../solr/legacy/LegacyNumericRangeQuery.java | 537 ++++++++++++++
.../solr/legacy/LegacyNumericTokenStream.java | 357 ++++++++++
.../apache/solr/legacy/LegacyNumericType.java | 34 +
.../apache/solr/legacy/LegacyNumericUtils.java | 510 ++++++++++++++
.../apache/solr/legacy/PointVectorStrategy.java | 292 ++++++++
.../solr/legacy/doc-files/nrq-formula-1.png | Bin 0 -> 3171 bytes
.../solr/legacy/doc-files/nrq-formula-2.png | Bin 0 -> 3694 bytes
.../org/apache/solr/legacy/package-info.java | 21 +
.../java/org/apache/solr/schema/BBoxField.java | 4 +-
.../java/org/apache/solr/schema/EnumField.java | 10 +-
.../schema/SpatialPointVectorFieldType.java | 4 +-
.../org/apache/solr/schema/TrieDoubleField.java | 2 +-
.../java/org/apache/solr/schema/TrieField.java | 24 +-
.../org/apache/solr/schema/TrieFloatField.java | 2 +-
.../org/apache/solr/schema/TrieIntField.java | 2 +-
.../org/apache/solr/schema/TrieLongField.java | 2 +-
.../search/LegacyNumericRangeQueryBuilder.java | 8 +-
.../org/apache/solr/search/QueryParsing.java | 2 +-
.../apache/solr/search/QueryWrapperFilter.java | 2 +-
.../apache/solr/search/mlt/CloudMLTQParser.java | 2 +-
.../solr/search/mlt/SimpleMLTQParser.java | 2 +-
.../org/apache/solr/uninverting/FieldCache.java | 20 +-
.../solr/uninverting/UninvertingReader.java | 16 +-
.../org/apache/solr/update/VersionInfo.java | 2 +-
.../org/apache/solr/legacy/TestLegacyField.java | 186 +++++
.../solr/legacy/TestLegacyFieldReuse.java | 81 +++
.../solr/legacy/TestLegacyNumericUtils.java | 571 +++++++++++++++
.../org/apache/solr/legacy/TestLegacyTerms.java | 164 +++++
.../TestMultiValuedNumericRangeQuery.java | 84 +++
.../solr/legacy/TestNumericRangeQuery32.java | 461 ++++++++++++
.../solr/legacy/TestNumericRangeQuery64.java | 490 +++++++++++++
.../solr/legacy/TestNumericTokenStream.java | 188 +++++
.../TestLegacyNumericRangeQueryBuilder.java | 2 +-
.../solr/search/TestMaxScoreQueryParser.java | 2 +-
.../apache/solr/search/TestSolr4Spatial.java | 2 +-
.../solr/search/function/TestOrdValues.java | 4 +-
.../solr/uninverting/TestDocTermOrds.java | 6 +-
.../solr/uninverting/TestFieldCacheSort.java | 8 +-
.../solr/uninverting/TestLegacyFieldCache.java | 8 +-
.../solr/uninverting/TestNumericTerms32.java | 6 +-
.../solr/uninverting/TestNumericTerms64.java | 6 +-
.../solr/uninverting/TestUninvertingReader.java | 8 +-
84 files changed, 5991 insertions(+), 4913 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/759fa42b/lucene/CHANGES.txt
----------------------------------------------------------------------
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txt
index 0dfc709..0c1d351 100644
--- a/lucene/CHANGES.txt
+++ b/lucene/CHANGES.txt
@@ -57,6 +57,8 @@ API Changes
instead, which derived from the UH. WholeBreakIterator and
CustomSeparatorBreakIterator were moved to UH's package. (David Smiley)
+* LUCENE-7850: Removed support for legacy numerics. (Adrien Grand)
+
Bug Fixes
* LUCENE-7626: IndexWriter will no longer accept broken token offsets
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/759fa42b/lucene/MIGRATE.txt
----------------------------------------------------------------------
diff --git a/lucene/MIGRATE.txt b/lucene/MIGRATE.txt
index c7936a4..89b2d76 100644
--- a/lucene/MIGRATE.txt
+++ b/lucene/MIGRATE.txt
@@ -74,3 +74,9 @@ collecting TopDocs for each group, but instead takes a GroupReducer that will
perform any type of reduction on the top groups collected on a first-pass. To
reproduce the old behaviour of SecondPassGroupingCollector, you should instead
use TopGroupsCollector.
+
+## Removed legacy numerics (LUCENE-7850)
+
+Support for legacy numerics has been removed since legacy numerics had been
+deprecated since Lucene 6.0. Points should be used instead, see
+org.apache.lucene.index.PointValues for an introduction.
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/759fa42b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyDoubleField.java
----------------------------------------------------------------------
diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyDoubleField.java b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyDoubleField.java
deleted file mode 100644
index e98a4f0..0000000
--- a/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyDoubleField.java
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
- * 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.
- */
-package org.apache.lucene.legacy;
-
-
-import org.apache.lucene.document.Document;
-import org.apache.lucene.document.DoublePoint;
-import org.apache.lucene.index.IndexOptions;
-
-
-/**
- * <p>
- * Field that indexes <code>double</code> values
- * for efficient range filtering and sorting. Here's an example usage:
- *
- * <pre class="prettyprint">
- * document.add(new LegacyDoubleField(name, 6.0, Field.Store.NO));
- * </pre>
- *
- * For optimal performance, re-use the <code>LegacyDoubleField</code> and
- * {@link Document} instance for more than one document:
- *
- * <pre class="prettyprint">
- * LegacyDoubleField field = new LegacyDoubleField(name, 0.0, Field.Store.NO);
- * Document document = new Document();
- * document.add(field);
- *
- * for(all documents) {
- * ...
- * field.setDoubleValue(value)
- * writer.addDocument(document);
- * ...
- * }
- * </pre>
- *
- * See also {@link LegacyIntField}, {@link LegacyLongField}, {@link
- * LegacyFloatField}.
- *
- * <p>To perform range querying or filtering against a
- * <code>LegacyDoubleField</code>, use {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}.
- * To sort according to a
- * <code>LegacyDoubleField</code>, use the normal numeric sort types, eg
- * {@link org.apache.lucene.search.SortField.Type#DOUBLE}. <code>LegacyDoubleField</code>
- * values can also be loaded directly from {@link org.apache.lucene.index.LeafReader#getNumericDocValues}.</p>
- *
- * <p>You may add the same field name as an <code>LegacyDoubleField</code> 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 <code>LegacyDoubleField</code>.</p>
- *
- * <p>A <code>LegacyDoubleField</code> 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. </p>
- *
- * <p>Within Lucene, each numeric value is indexed as a
- * <em>trie</em> 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
- * <code>precisionStep</code>, measured in bits. Smaller
- * <code>precisionStep</code> 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, 16, was selected for a reasonable tradeoff
- * of disk space consumption versus performance. You can
- * create a custom {@link LegacyFieldType} and invoke the {@link
- * LegacyFieldType#setNumericPrecisionStep} method if you'd
- * like to change the value. Note that you must also
- * specify a congruent value when creating {@link
- * org.apache.lucene.legacy.LegacyNumericRangeQuery}.
- * 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.
- *
- * <p>For more information on the internals of numeric trie
- * indexing, including the <a
- * href="LegacyNumericRangeQuery.html#precisionStepDesc"><code>precisionStep</code></a>
- * configuration, see {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}. The format of
- * indexed values is described in {@link org.apache.lucene.legacy.LegacyNumericUtils}.
- *
- * <p>If you only need to sort by numeric value, and never
- * run range querying/filtering, you can index using a
- * <code>precisionStep</code> of {@link Integer#MAX_VALUE}.
- * This will minimize disk space consumed. </p>
- *
- * <p>More advanced users can instead use {@link
- * org.apache.lucene.legacy.LegacyNumericTokenStream} directly, when indexing numbers. This
- * class is a wrapper around this token stream type for
- * easier, more intuitive usage.</p>
- *
- * @deprecated Please use {@link DoublePoint} instead
- *
- * @since 2.9
- */
-
-@Deprecated
-public final class LegacyDoubleField extends LegacyField {
-
- /**
- * Type for a LegacyDoubleField that is not stored:
- * normalization factors, frequencies, and positions are omitted.
- */
- public static final LegacyFieldType TYPE_NOT_STORED = new LegacyFieldType();
- static {
- TYPE_NOT_STORED.setTokenized(true);
- TYPE_NOT_STORED.setOmitNorms(true);
- TYPE_NOT_STORED.setIndexOptions(IndexOptions.DOCS);
- TYPE_NOT_STORED.setNumericType(LegacyNumericType.DOUBLE);
- TYPE_NOT_STORED.freeze();
- }
-
- /**
- * Type for a stored LegacyDoubleField:
- * normalization factors, frequencies, and positions are omitted.
- */
- public static final LegacyFieldType TYPE_STORED = new LegacyFieldType();
- static {
- TYPE_STORED.setTokenized(true);
- TYPE_STORED.setOmitNorms(true);
- TYPE_STORED.setIndexOptions(IndexOptions.DOCS);
- TYPE_STORED.setNumericType(LegacyNumericType.DOUBLE);
- TYPE_STORED.setStored(true);
- TYPE_STORED.freeze();
- }
-
- /** Creates a stored or un-stored LegacyDoubleField with the provided value
- * and default <code>precisionStep</code> {@link
- * org.apache.lucene.legacy.LegacyNumericUtils#PRECISION_STEP_DEFAULT} (16).
- * @param name field name
- * @param value 64-bit double value
- * @param stored Store.YES if the content should also be stored
- * @throws IllegalArgumentException if the field name is null.
- */
- public LegacyDoubleField(String name, double value, Store stored) {
- super(name, stored == Store.YES ? TYPE_STORED : TYPE_NOT_STORED);
- fieldsData = Double.valueOf(value);
- }
-
- /** Expert: allows you to customize the {@link
- * LegacyFieldType}.
- * @param name field name
- * @param value 64-bit double value
- * @param type customized field type: must have {@link LegacyFieldType#numericType()}
- * of {@link LegacyNumericType#DOUBLE}.
- * @throws IllegalArgumentException if the field name or type is null, or
- * if the field type does not have a DOUBLE numericType()
- */
- public LegacyDoubleField(String name, double value, LegacyFieldType type) {
- super(name, type);
- if (type.numericType() != LegacyNumericType.DOUBLE) {
- throw new IllegalArgumentException("type.numericType() must be DOUBLE but got " + type.numericType());
- }
- fieldsData = Double.valueOf(value);
- }
-}
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/759fa42b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyField.java
----------------------------------------------------------------------
diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyField.java b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyField.java
deleted file mode 100644
index 87ac0e5..0000000
--- a/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyField.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * 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.
- */
-package org.apache.lucene.legacy;
-
-import org.apache.lucene.analysis.Analyzer;
-import org.apache.lucene.analysis.TokenStream;
-import org.apache.lucene.document.Field;
-import org.apache.lucene.index.IndexOptions;
-
-/**
- * Field extension with support for legacy numerics
- * @deprecated Please switch to {@link org.apache.lucene.index.PointValues} instead
- */
-@Deprecated
-public class LegacyField extends Field {
-
- /**
- * Expert: creates a field with no initial value.
- * Intended only for custom LegacyField subclasses.
- * @param name field name
- * @param type field type
- * @throws IllegalArgumentException if either the name or type
- * is null.
- */
- public LegacyField(String name, LegacyFieldType type) {
- super(name, type);
- }
-
- @Override
- public TokenStream tokenStream(Analyzer analyzer, TokenStream reuse) {
- if (fieldType().indexOptions() == IndexOptions.NONE) {
- // Not indexed
- return null;
- }
- final LegacyFieldType fieldType = (LegacyFieldType) fieldType();
- final LegacyNumericType numericType = fieldType.numericType();
- if (numericType != null) {
- if (!(reuse instanceof LegacyNumericTokenStream && ((LegacyNumericTokenStream)reuse).getPrecisionStep() == fieldType.numericPrecisionStep())) {
- // lazy init the TokenStream as it is heavy to instantiate
- // (attributes,...) if not needed (stored field loading)
- reuse = new LegacyNumericTokenStream(fieldType.numericPrecisionStep());
- }
- final LegacyNumericTokenStream nts = (LegacyNumericTokenStream) reuse;
- // initialize value in TokenStream
- final Number val = (Number) fieldsData;
- switch (numericType) {
- case INT:
- nts.setIntValue(val.intValue());
- break;
- case LONG:
- nts.setLongValue(val.longValue());
- break;
- case FLOAT:
- nts.setFloatValue(val.floatValue());
- break;
- case DOUBLE:
- nts.setDoubleValue(val.doubleValue());
- break;
- default:
- throw new AssertionError("Should never get here");
- }
- return reuse;
- }
- return super.tokenStream(analyzer, reuse);
- }
-
- @Override
- public void setTokenStream(TokenStream tokenStream) {
- final LegacyFieldType fieldType = (LegacyFieldType) fieldType();
- if (fieldType.numericType() != null) {
- throw new IllegalArgumentException("cannot set private TokenStream on numeric fields");
- }
- super.setTokenStream(tokenStream);
- }
-
-}
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/759fa42b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyFieldType.java
----------------------------------------------------------------------
diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyFieldType.java b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyFieldType.java
deleted file mode 100644
index 1f4b0af..0000000
--- a/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyFieldType.java
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
- * 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.
- */
-package org.apache.lucene.legacy;
-
-import org.apache.lucene.document.FieldType;
-import org.apache.lucene.index.IndexOptions;
-
-/**
- * FieldType extension with support for legacy numerics
- * @deprecated Please switch to {@link org.apache.lucene.index.PointValues} instead
- */
-@Deprecated
-public final class LegacyFieldType extends FieldType {
- private LegacyNumericType numericType;
- private int numericPrecisionStep = LegacyNumericUtils.PRECISION_STEP_DEFAULT;
-
- /**
- * Create a new mutable LegacyFieldType with all of the properties from <code>ref</code>
- */
- public LegacyFieldType(LegacyFieldType ref) {
- super(ref);
- this.numericType = ref.numericType;
- this.numericPrecisionStep = ref.numericPrecisionStep;
- }
-
- /**
- * Create a new FieldType with default properties.
- */
- public LegacyFieldType() {
- }
-
- /**
- * Specifies the field's numeric type.
- * @param type numeric type, or null if the field has no numeric type.
- * @throws IllegalStateException if this FieldType is frozen against
- * future modifications.
- * @see #numericType()
- *
- * @deprecated Please switch to {@link org.apache.lucene.index.PointValues} instead
- */
- @Deprecated
- public void setNumericType(LegacyNumericType type) {
- checkIfFrozen();
- numericType = type;
- }
-
- /**
- * LegacyNumericType: if non-null then the field's value will be indexed
- * numerically so that {@link org.apache.lucene.legacy.LegacyNumericRangeQuery} can be used at
- * search time.
- * <p>
- * The default is <code>null</code> (no numeric type)
- * @see #setNumericType(LegacyNumericType)
- *
- * @deprecated Please switch to {@link org.apache.lucene.index.PointValues} instead
- */
- @Deprecated
- public LegacyNumericType numericType() {
- return numericType;
- }
-
- /**
- * Sets the numeric precision step for the field.
- * @param precisionStep numeric precision step for the field
- * @throws IllegalArgumentException if precisionStep is less than 1.
- * @throws IllegalStateException if this FieldType is frozen against
- * future modifications.
- * @see #numericPrecisionStep()
- *
- * @deprecated Please switch to {@link org.apache.lucene.index.PointValues} instead
- */
- @Deprecated
- public void setNumericPrecisionStep(int precisionStep) {
- checkIfFrozen();
- if (precisionStep < 1) {
- throw new IllegalArgumentException("precisionStep must be >= 1 (got " + precisionStep + ")");
- }
- this.numericPrecisionStep = precisionStep;
- }
-
- /**
- * Precision step for numeric field.
- * <p>
- * This has no effect if {@link #numericType()} returns null.
- * <p>
- * The default is {@link org.apache.lucene.legacy.LegacyNumericUtils#PRECISION_STEP_DEFAULT}
- * @see #setNumericPrecisionStep(int)
- *
- * @deprecated Please switch to {@link org.apache.lucene.index.PointValues} instead
- */
- @Deprecated
- public int numericPrecisionStep() {
- return numericPrecisionStep;
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = super.hashCode();
- result = prime * result + numericPrecisionStep;
- result = prime * result + ((numericType == null) ? 0 : numericType.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (!super.equals(obj)) {
- return false;
- }
- if (getClass() != obj.getClass()) return false;
- LegacyFieldType other = (LegacyFieldType) obj;
- if (numericPrecisionStep != other.numericPrecisionStep) return false;
- if (numericType != other.numericType) return false;
- return true;
- }
-
- /** Prints a Field for human consumption. */
- @Override
- public String toString() {
- StringBuilder result = new StringBuilder();
- result.append(super.toString());
- if (indexOptions() != IndexOptions.NONE) {
- if (result.length() > 0) {
- result.append(",");
- }
- if (numericType != null) {
- result.append(",numericType=");
- result.append(numericType);
- result.append(",numericPrecisionStep=");
- result.append(numericPrecisionStep);
- }
- }
- return result.toString();
- }
-}
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/759fa42b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyFloatField.java
----------------------------------------------------------------------
diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyFloatField.java b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyFloatField.java
deleted file mode 100644
index ea3b84a..0000000
--- a/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyFloatField.java
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
- * 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.
- */
-package org.apache.lucene.legacy;
-
-import org.apache.lucene.document.Document;
-import org.apache.lucene.document.FloatPoint;
-import org.apache.lucene.index.IndexOptions;
-
-/**
- * <p>
- * Field that indexes <code>float</code> values
- * for efficient range filtering and sorting. Here's an example usage:
- *
- * <pre class="prettyprint">
- * document.add(new LegacyFloatField(name, 6.0F, Field.Store.NO));
- * </pre>
- *
- * For optimal performance, re-use the <code>LegacyFloatField</code> and
- * {@link Document} instance for more than one document:
- *
- * <pre class="prettyprint">
- * LegacyFloatField field = new LegacyFloatField(name, 0.0F, Field.Store.NO);
- * Document document = new Document();
- * document.add(field);
- *
- * for(all documents) {
- * ...
- * field.setFloatValue(value)
- * writer.addDocument(document);
- * ...
- * }
- * </pre>
- *
- * See also {@link LegacyIntField}, {@link LegacyLongField}, {@link
- * LegacyDoubleField}.
- *
- * <p>To perform range querying or filtering against a
- * <code>LegacyFloatField</code>, use {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}.
- * To sort according to a
- * <code>LegacyFloatField</code>, use the normal numeric sort types, eg
- * {@link org.apache.lucene.search.SortField.Type#FLOAT}. <code>LegacyFloatField</code>
- * values can also be loaded directly from {@link org.apache.lucene.index.LeafReader#getNumericDocValues}.</p>
- *
- * <p>You may add the same field name as an <code>LegacyFloatField</code> 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 <code>LegacyFloatField</code>.</p>
- *
- * <p>A <code>LegacyFloatField</code> 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. </p>
- *
- * <p>Within Lucene, each numeric value is indexed as a
- * <em>trie</em> 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
- * <code>precisionStep</code>, measured in bits. Smaller
- * <code>precisionStep</code> 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, 8, was selected for a reasonable tradeoff
- * of disk space consumption versus performance. You can
- * create a custom {@link LegacyFieldType} and invoke the {@link
- * LegacyFieldType#setNumericPrecisionStep} method if you'd
- * like to change the value. Note that you must also
- * specify a congruent value when creating {@link
- * org.apache.lucene.legacy.LegacyNumericRangeQuery}.
- * 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.
- *
- * <p>For more information on the internals of numeric trie
- * indexing, including the <a
- * href="LegacyNumericRangeQuery.html#precisionStepDesc"><code>precisionStep</code></a>
- * configuration, see {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}. The format of
- * indexed values is described in {@link org.apache.lucene.legacy.LegacyNumericUtils}.
- *
- * <p>If you only need to sort by numeric value, and never
- * run range querying/filtering, you can index using a
- * <code>precisionStep</code> of {@link Integer#MAX_VALUE}.
- * This will minimize disk space consumed. </p>
- *
- * <p>More advanced users can instead use {@link
- * org.apache.lucene.legacy.LegacyNumericTokenStream} directly, when indexing numbers. This
- * class is a wrapper around this token stream type for
- * easier, more intuitive usage.</p>
- *
- * @deprecated Please use {@link FloatPoint} instead
- *
- * @since 2.9
- */
-
-@Deprecated
-public final class LegacyFloatField extends LegacyField {
-
- /**
- * Type for a LegacyFloatField that is not stored:
- * normalization factors, frequencies, and positions are omitted.
- */
- public static final LegacyFieldType TYPE_NOT_STORED = new LegacyFieldType();
- static {
- TYPE_NOT_STORED.setTokenized(true);
- TYPE_NOT_STORED.setOmitNorms(true);
- TYPE_NOT_STORED.setIndexOptions(IndexOptions.DOCS);
- TYPE_NOT_STORED.setNumericType(LegacyNumericType.FLOAT);
- TYPE_NOT_STORED.setNumericPrecisionStep(LegacyNumericUtils.PRECISION_STEP_DEFAULT_32);
- TYPE_NOT_STORED.freeze();
- }
-
- /**
- * Type for a stored LegacyFloatField:
- * normalization factors, frequencies, and positions are omitted.
- */
- public static final LegacyFieldType TYPE_STORED = new LegacyFieldType();
- static {
- TYPE_STORED.setTokenized(true);
- TYPE_STORED.setOmitNorms(true);
- TYPE_STORED.setIndexOptions(IndexOptions.DOCS);
- TYPE_STORED.setNumericType(LegacyNumericType.FLOAT);
- TYPE_STORED.setNumericPrecisionStep(LegacyNumericUtils.PRECISION_STEP_DEFAULT_32);
- TYPE_STORED.setStored(true);
- TYPE_STORED.freeze();
- }
-
- /** Creates a stored or un-stored LegacyFloatField with the provided value
- * and default <code>precisionStep</code> {@link
- * org.apache.lucene.legacy.LegacyNumericUtils#PRECISION_STEP_DEFAULT_32} (8).
- * @param name field name
- * @param value 32-bit double value
- * @param stored Store.YES if the content should also be stored
- * @throws IllegalArgumentException if the field name is null.
- */
- public LegacyFloatField(String name, float value, Store stored) {
- super(name, stored == Store.YES ? TYPE_STORED : TYPE_NOT_STORED);
- fieldsData = Float.valueOf(value);
- }
-
- /** Expert: allows you to customize the {@link
- * LegacyFieldType}.
- * @param name field name
- * @param value 32-bit float value
- * @param type customized field type: must have {@link LegacyFieldType#numericType()}
- * of {@link LegacyNumericType#FLOAT}.
- * @throws IllegalArgumentException if the field name or type is null, or
- * if the field type does not have a FLOAT numericType()
- */
- public LegacyFloatField(String name, float value, LegacyFieldType type) {
- super(name, type);
- if (type.numericType() != LegacyNumericType.FLOAT) {
- throw new IllegalArgumentException("type.numericType() must be FLOAT but got " + type.numericType());
- }
- fieldsData = Float.valueOf(value);
- }
-}
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/759fa42b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyIntField.java
----------------------------------------------------------------------
diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyIntField.java b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyIntField.java
deleted file mode 100644
index e3ae965..0000000
--- a/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyIntField.java
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
- * 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.
- */
-package org.apache.lucene.legacy;
-
-
-import org.apache.lucene.document.Document;
-import org.apache.lucene.document.IntPoint;
-import org.apache.lucene.index.IndexOptions;
-
-/**
- * <p>
- * Field that indexes <code>int</code> values
- * for efficient range filtering and sorting. Here's an example usage:
- *
- * <pre class="prettyprint">
- * document.add(new LegacyIntField(name, 6, Field.Store.NO));
- * </pre>
- *
- * For optimal performance, re-use the <code>LegacyIntField</code> and
- * {@link Document} instance for more than one document:
- *
- * <pre class="prettyprint">
- * LegacyIntField field = new LegacyIntField(name, 6, Field.Store.NO);
- * Document document = new Document();
- * document.add(field);
- *
- * for(all documents) {
- * ...
- * field.setIntValue(value)
- * writer.addDocument(document);
- * ...
- * }
- * </pre>
- *
- * See also {@link LegacyLongField}, {@link LegacyFloatField}, {@link
- * LegacyDoubleField}.
- *
- * <p>To perform range querying or filtering against a
- * <code>LegacyIntField</code>, use {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}.
- * To sort according to a
- * <code>LegacyIntField</code>, use the normal numeric sort types, eg
- * {@link org.apache.lucene.search.SortField.Type#INT}. <code>LegacyIntField</code>
- * values can also be loaded directly from {@link org.apache.lucene.index.LeafReader#getNumericDocValues}.</p>
- *
- * <p>You may add the same field name as an <code>LegacyIntField</code> 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 <code>LegacyIntField</code>.</p>
- *
- * <p>An <code>LegacyIntField</code> 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. </p>
- *
- * <p>Within Lucene, each numeric value is indexed as a
- * <em>trie</em> 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
- * <code>precisionStep</code>, measured in bits. Smaller
- * <code>precisionStep</code> 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, 8, was selected for a reasonable tradeoff
- * of disk space consumption versus performance. You can
- * create a custom {@link LegacyFieldType} and invoke the {@link
- * LegacyFieldType#setNumericPrecisionStep} method if you'd
- * like to change the value. Note that you must also
- * specify a congruent value when creating {@link
- * org.apache.lucene.legacy.LegacyNumericRangeQuery}.
- * 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.
- *
- * <p>For more information on the internals of numeric trie
- * indexing, including the <a
- * href="LegacyNumericRangeQuery.html#precisionStepDesc"><code>precisionStep</code></a>
- * configuration, see {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}. The format of
- * indexed values is described in {@link org.apache.lucene.legacy.LegacyNumericUtils}.
- *
- * <p>If you only need to sort by numeric value, and never
- * run range querying/filtering, you can index using a
- * <code>precisionStep</code> of {@link Integer#MAX_VALUE}.
- * This will minimize disk space consumed. </p>
- *
- * <p>More advanced users can instead use {@link
- * org.apache.lucene.legacy.LegacyNumericTokenStream} directly, when indexing numbers. This
- * class is a wrapper around this token stream type for
- * easier, more intuitive usage.</p>
- *
- * @deprecated Please use {@link IntPoint} instead
- *
- * @since 2.9
- */
-
-@Deprecated
-public final class LegacyIntField extends LegacyField {
-
- /**
- * Type for an LegacyIntField that is not stored:
- * normalization factors, frequencies, and positions are omitted.
- */
- public static final LegacyFieldType TYPE_NOT_STORED = new LegacyFieldType();
- static {
- TYPE_NOT_STORED.setTokenized(true);
- TYPE_NOT_STORED.setOmitNorms(true);
- TYPE_NOT_STORED.setIndexOptions(IndexOptions.DOCS);
- TYPE_NOT_STORED.setNumericType(LegacyNumericType.INT);
- TYPE_NOT_STORED.setNumericPrecisionStep(LegacyNumericUtils.PRECISION_STEP_DEFAULT_32);
- TYPE_NOT_STORED.freeze();
- }
-
- /**
- * Type for a stored LegacyIntField:
- * normalization factors, frequencies, and positions are omitted.
- */
- public static final LegacyFieldType TYPE_STORED = new LegacyFieldType();
- static {
- TYPE_STORED.setTokenized(true);
- TYPE_STORED.setOmitNorms(true);
- TYPE_STORED.setIndexOptions(IndexOptions.DOCS);
- TYPE_STORED.setNumericType(LegacyNumericType.INT);
- TYPE_STORED.setNumericPrecisionStep(LegacyNumericUtils.PRECISION_STEP_DEFAULT_32);
- TYPE_STORED.setStored(true);
- TYPE_STORED.freeze();
- }
-
- /** Creates a stored or un-stored LegacyIntField with the provided value
- * and default <code>precisionStep</code> {@link
- * org.apache.lucene.legacy.LegacyNumericUtils#PRECISION_STEP_DEFAULT_32} (8).
- * @param name field name
- * @param value 32-bit integer value
- * @param stored Store.YES if the content should also be stored
- * @throws IllegalArgumentException if the field name is null.
- */
- public LegacyIntField(String name, int value, Store stored) {
- super(name, stored == Store.YES ? TYPE_STORED : TYPE_NOT_STORED);
- fieldsData = Integer.valueOf(value);
- }
-
- /** Expert: allows you to customize the {@link
- * LegacyFieldType}.
- * @param name field name
- * @param value 32-bit integer value
- * @param type customized field type: must have {@link LegacyFieldType#numericType()}
- * of {@link LegacyNumericType#INT}.
- * @throws IllegalArgumentException if the field name or type is null, or
- * if the field type does not have a INT numericType()
- */
- public LegacyIntField(String name, int value, LegacyFieldType type) {
- super(name, type);
- if (type.numericType() != LegacyNumericType.INT) {
- throw new IllegalArgumentException("type.numericType() must be INT but got " + type.numericType());
- }
- fieldsData = Integer.valueOf(value);
- }
-}
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/759fa42b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyLongField.java
----------------------------------------------------------------------
diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyLongField.java b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyLongField.java
deleted file mode 100644
index 3e20b44..0000000
--- a/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyLongField.java
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
- * 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.
- */
-package org.apache.lucene.legacy;
-
-
-import org.apache.lucene.document.Document;
-import org.apache.lucene.document.LongPoint;
-import org.apache.lucene.index.IndexOptions;
-
-
-/**
- * <p>
- * Field that indexes <code>long</code> values
- * for efficient range filtering and sorting. Here's an example usage:
- *
- * <pre class="prettyprint">
- * document.add(new LegacyLongField(name, 6L, Field.Store.NO));
- * </pre>
- *
- * For optimal performance, re-use the <code>LegacyLongField</code> and
- * {@link Document} instance for more than one document:
- *
- * <pre class="prettyprint">
- * LegacyLongField field = new LegacyLongField(name, 0L, Field.Store.NO);
- * Document document = new Document();
- * document.add(field);
- *
- * for(all documents) {
- * ...
- * field.setLongValue(value)
- * writer.addDocument(document);
- * ...
- * }
- * </pre>
- *
- * See also {@link LegacyIntField}, {@link LegacyFloatField}, {@link
- * LegacyDoubleField}.
- *
- * 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 <code>int</code> or
- * <code>long</code> value.
- *
- * <p>To perform range querying or filtering against a
- * <code>LegacyLongField</code>, use {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}.
- * To sort according to a
- * <code>LegacyLongField</code>, use the normal numeric sort types, eg
- * {@link org.apache.lucene.search.SortField.Type#LONG}. <code>LegacyLongField</code>
- * values can also be loaded directly from {@link org.apache.lucene.index.LeafReader#getNumericDocValues}.
- *
- * <p>You may add the same field name as an <code>LegacyLongField</code> 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 <code>LegacyLongField</code>.
- *
- * <p>A <code>LegacyLongField</code> 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. </p>
- *
- * <p>Within Lucene, each numeric value is indexed as a
- * <em>trie</em> 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
- * <code>precisionStep</code>, measured in bits. Smaller
- * <code>precisionStep</code> 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, 16, was selected for a reasonable tradeoff
- * of disk space consumption versus performance. You can
- * create a custom {@link LegacyFieldType} and invoke the {@link
- * LegacyFieldType#setNumericPrecisionStep} method if you'd
- * like to change the value. Note that you must also
- * specify a congruent value when creating {@link
- * org.apache.lucene.legacy.LegacyNumericRangeQuery}.
- * 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.
- *
- * <p>For more information on the internals of numeric trie
- * indexing, including the <a
- * href="LegacyNumericRangeQuery.html#precisionStepDesc"><code>precisionStep</code></a>
- * configuration, see {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}. The format of
- * indexed values is described in {@link org.apache.lucene.legacy.LegacyNumericUtils}.
- *
- * <p>If you only need to sort by numeric value, and never
- * run range querying/filtering, you can index using a
- * <code>precisionStep</code> of {@link Integer#MAX_VALUE}.
- * This will minimize disk space consumed.
- *
- * <p>More advanced users can instead use {@link
- * org.apache.lucene.legacy.LegacyNumericTokenStream} directly, when indexing numbers. This
- * class is a wrapper around this token stream type for
- * easier, more intuitive usage.</p>
- *
- * @deprecated Please use {@link LongPoint} instead
- *
- * @since 2.9
- */
-
-@Deprecated
-public final class LegacyLongField extends LegacyField {
-
- /**
- * Type for a LegacyLongField that is not stored:
- * normalization factors, frequencies, and positions are omitted.
- */
- public static final LegacyFieldType TYPE_NOT_STORED = new LegacyFieldType();
- static {
- TYPE_NOT_STORED.setTokenized(true);
- TYPE_NOT_STORED.setOmitNorms(true);
- TYPE_NOT_STORED.setIndexOptions(IndexOptions.DOCS);
- TYPE_NOT_STORED.setNumericType(LegacyNumericType.LONG);
- TYPE_NOT_STORED.freeze();
- }
-
- /**
- * Type for a stored LegacyLongField:
- * normalization factors, frequencies, and positions are omitted.
- */
- public static final LegacyFieldType TYPE_STORED = new LegacyFieldType();
- static {
- TYPE_STORED.setTokenized(true);
- TYPE_STORED.setOmitNorms(true);
- TYPE_STORED.setIndexOptions(IndexOptions.DOCS);
- TYPE_STORED.setNumericType(LegacyNumericType.LONG);
- TYPE_STORED.setStored(true);
- TYPE_STORED.freeze();
- }
-
- /** Creates a stored or un-stored LegacyLongField with the provided value
- * and default <code>precisionStep</code> {@link
- * org.apache.lucene.legacy.LegacyNumericUtils#PRECISION_STEP_DEFAULT} (16).
- * @param name field name
- * @param value 64-bit long value
- * @param stored Store.YES if the content should also be stored
- * @throws IllegalArgumentException if the field name is null.
- */
- public LegacyLongField(String name, long value, Store stored) {
- super(name, stored == Store.YES ? TYPE_STORED : TYPE_NOT_STORED);
- fieldsData = Long.valueOf(value);
- }
-
- /** Expert: allows you to customize the {@link
- * LegacyFieldType}.
- * @param name field name
- * @param value 64-bit long value
- * @param type customized field type: must have {@link LegacyFieldType#numericType()}
- * of {@link LegacyNumericType#LONG}.
- * @throws IllegalArgumentException if the field name or type is null, or
- * if the field type does not have a LONG numericType()
- */
- public LegacyLongField(String name, long value, LegacyFieldType type) {
- super(name, type);
- if (type.numericType() != LegacyNumericType.LONG) {
- throw new IllegalArgumentException("type.numericType() must be LONG but got " + type.numericType());
- }
- fieldsData = Long.valueOf(value);
- }
-}
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/759fa42b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericRangeQuery.java
----------------------------------------------------------------------
diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericRangeQuery.java b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericRangeQuery.java
deleted file mode 100644
index f172a20..0000000
--- a/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericRangeQuery.java
+++ /dev/null
@@ -1,537 +0,0 @@
-/*
- * 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.
- */
-package org.apache.lucene.legacy;
-
-
-import java.io.IOException;
-import java.util.LinkedList;
-import java.util.Objects;
-
-import org.apache.lucene.document.DoublePoint;
-import org.apache.lucene.document.FloatPoint;
-import org.apache.lucene.document.IntPoint;
-import org.apache.lucene.document.LongPoint;
-import org.apache.lucene.index.FilteredTermsEnum;
-import org.apache.lucene.index.PointValues;
-import org.apache.lucene.index.Terms;
-import org.apache.lucene.index.TermsEnum;
-import org.apache.lucene.search.BooleanQuery;
-import org.apache.lucene.search.MultiTermQuery;
-import org.apache.lucene.search.Query;
-import org.apache.lucene.search.TermRangeQuery;
-import org.apache.lucene.util.AttributeSource;
-import org.apache.lucene.util.BytesRef;
-import org.apache.lucene.util.NumericUtils;
-import org.apache.lucene.index.Term; // for javadocs
-
-/**
- * <p>A {@link Query} that matches numeric values within a
- * specified range. To use this, you must first index the
- * numeric values using {@link org.apache.lucene.legacy.LegacyIntField}, {@link
- * org.apache.lucene.legacy.LegacyFloatField}, {@link org.apache.lucene.legacy.LegacyLongField} or {@link org.apache.lucene.legacy.LegacyDoubleField} (expert: {@link
- * org.apache.lucene.legacy.LegacyNumericTokenStream}). If your terms are instead textual,
- * you should use {@link TermRangeQuery}.</p>
- *
- * <p>You create a new LegacyNumericRangeQuery with the static
- * factory methods, eg:
- *
- * <pre class="prettyprint">
- * Query q = LegacyNumericRangeQuery.newFloatRange("weight", 0.03f, 0.10f, true, true);
- * </pre>
- *
- * matches all documents whose float valued "weight" field
- * ranges from 0.03 to 0.10, inclusive.
- *
- * <p>The performance of LegacyNumericRangeQuery is much better
- * than the corresponding {@link TermRangeQuery} because the
- * number of terms that must be searched is usually far
- * fewer, thanks to trie indexing, described below.</p>
- *
- * <p>You can optionally specify a <a
- * href="#precisionStepDesc"><code>precisionStep</code></a>
- * when creating this query. This is necessary if you've
- * changed this configuration from its default (4) during
- * indexing. Lower values consume more disk space but speed
- * up searching. Suitable values are between <b>1</b> and
- * <b>8</b>. A good starting point to test is <b>4</b>,
- * which is the default value for all <code>Numeric*</code>
- * classes. See <a href="#precisionStepDesc">below</a> for
- * details.
- *
- * <p>This query defaults to {@linkplain
- * MultiTermQuery#CONSTANT_SCORE_REWRITE}.
- * With precision steps of ≤4, this query can be run with
- * one of the BooleanQuery rewrite methods without changing
- * BooleanQuery's default max clause count.
- *
- * <br><h3>How it works</h3>
- *
- * <p>See the publication about <a target="_blank" href="http://www.panfmp.org">panFMP</a>,
- * where this algorithm was described (referred to as <code>TrieRangeQuery</code>):
- *
- * <blockquote><strong>Schindler, U, Diepenbroek, M</strong>, 2008.
- * <em>Generic XML-based Framework for Metadata Portals.</em>
- * Computers & Geosciences 34 (12), 1947-1955.
- * <a href="http://dx.doi.org/10.1016/j.cageo.2008.02.023"
- * target="_blank">doi:10.1016/j.cageo.2008.02.023</a></blockquote>
- *
- * <p><em>A quote from this paper:</em> Because Apache Lucene is a full-text
- * search engine and not a conventional database, it cannot handle numerical ranges
- * (e.g., field value is inside user defined bounds, even dates are numerical values).
- * We have developed an extension to Apache Lucene that stores
- * the numerical values in a special string-encoded format with variable precision
- * (all numerical values like doubles, longs, floats, and ints are converted to
- * lexicographic sortable string representations and stored with different precisions
- * (for a more detailed description of how the values are stored,
- * see {@link org.apache.lucene.legacy.LegacyNumericUtils}). A range is then divided recursively into multiple intervals for searching:
- * The center of the range is searched only with the lowest possible precision in the <em>trie</em>,
- * while the boundaries are matched more exactly. This reduces the number of terms dramatically.</p>
- *
- * <p>For the variant that stores long values in 8 different precisions (each reduced by 8 bits) that
- * uses a lowest precision of 1 byte, the index contains only a maximum of 256 distinct values in the
- * lowest precision. Overall, a range could consist of a theoretical maximum of
- * <code>7*255*2 + 255 = 3825</code> distinct terms (when there is a term for every distinct value of an
- * 8-byte-number in the index and the range covers almost all of them; a maximum of 255 distinct values is used
- * because it would always be possible to reduce the full 256 values to one term with degraded precision).
- * In practice, we have seen up to 300 terms in most cases (index with 500,000 metadata records
- * and a uniform value distribution).</p>
- *
- * <h3><a name="precisionStepDesc">Precision Step</a></h3>
- * <p>You can choose any <code>precisionStep</code> when encoding values.
- * Lower step values mean more precisions and so more terms in index (and index gets larger). The number
- * of indexed terms per value is (those are generated by {@link org.apache.lucene.legacy.LegacyNumericTokenStream}):
- * <p style="font-family:serif">
- * indexedTermsPerValue = <b>ceil</b><big>(</big>bitsPerValue / precisionStep<big>)</big>
- * </p>
- * As the lower precision terms are shared by many values, the additional terms only
- * slightly grow the term dictionary (approx. 7% for <code>precisionStep=4</code>), but have a larger
- * impact on the postings (the postings file will have more entries, as every document is linked to
- * <code>indexedTermsPerValue</code> terms instead of one). The formula to estimate the growth
- * of the term dictionary in comparison to one term per value:
- * <p>
- * <!-- the formula in the alt attribute was transformed from latex to PNG with http://1.618034.com/latex.php (with 110 dpi): -->
- * <img src="doc-files/nrq-formula-1.png" alt="\mathrm{termDictOverhead} = \sum\limits_{i=0}^{\mathrm{indexedTermsPerValue}-1} \frac{1}{2^{\mathrm{precisionStep}\cdot i}}">
- * </p>
- * <p>On the other hand, if the <code>precisionStep</code> is smaller, the maximum number of terms to match reduces,
- * which optimizes query speed. The formula to calculate the maximum number of terms that will be visited while
- * executing the query is:
- * <p>
- * <!-- the formula in the alt attribute was transformed from latex to PNG with http://1.618034.com/latex.php (with 110 dpi): -->
- * <img src="doc-files/nrq-formula-2.png" alt="\mathrm{maxQueryTerms} = \left[ \left( \mathrm{indexedTermsPerValue} - 1 \right) \cdot \left(2^\mathrm{precisionStep} - 1 \right) \cdot 2 \right] + \left( 2^\mathrm{precisionStep} - 1 \right)">
- * </p>
- * <p>For longs stored using a precision step of 4, <code>maxQueryTerms = 15*15*2 + 15 = 465</code>, and for a precision
- * step of 2, <code>maxQueryTerms = 31*3*2 + 3 = 189</code>. But the faster search speed is reduced by more seeking
- * in the term enum of the index. Because of this, the ideal <code>precisionStep</code> value can only
- * be found out by testing. <b>Important:</b> You can index with a lower precision step value and test search speed
- * using a multiple of the original step value.</p>
- *
- * <p>Good values for <code>precisionStep</code> are depending on usage and data type:
- * <ul>
- * <li>The default for all data types is <b>4</b>, which is used, when no <code>precisionStep</code> is given.
- * <li>Ideal value in most cases for <em>64 bit</em> data types <em>(long, double)</em> is <b>6</b> or <b>8</b>.
- * <li>Ideal value in most cases for <em>32 bit</em> data types <em>(int, float)</em> is <b>4</b>.
- * <li>For low cardinality fields larger precision steps are good. If the cardinality is < 100, it is
- * fair to use {@link Integer#MAX_VALUE} (see below).
- * <li>Steps <b>≥64</b> for <em>long/double</em> and <b>≥32</b> for <em>int/float</em> produces one token
- * per value in the index and querying is as slow as a conventional {@link TermRangeQuery}. But it can be used
- * to produce fields, that are solely used for sorting (in this case simply use {@link Integer#MAX_VALUE} as
- * <code>precisionStep</code>). Using {@link org.apache.lucene.legacy.LegacyIntField},
- * {@link org.apache.lucene.legacy.LegacyLongField}, {@link org.apache.lucene.legacy.LegacyFloatField} or {@link org.apache.lucene.legacy.LegacyDoubleField} 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).
- * Sorting is also possible with range query optimized fields using one of the above <code>precisionSteps</code>.
- * </ul>
- *
- * <p>Comparisons of the different types of RangeQueries on an index with about 500,000 docs showed
- * that {@link TermRangeQuery} in boolean rewrite mode (with raised {@link BooleanQuery} clause count)
- * took about 30-40 secs to complete, {@link TermRangeQuery} in constant score filter rewrite mode took 5 secs
- * and executing this class took <100ms to complete (on an Opteron64 machine, Java 1.5, 8 bit
- * precision step). This query type was developed for a geographic portal, where the performance for
- * e.g. bounding boxes or exact date/time stamps is important.</p>
- *
- * @deprecated Instead index with {@link IntPoint}, {@link LongPoint}, {@link FloatPoint}, {@link DoublePoint}, and
- * create range queries with {@link IntPoint#newRangeQuery(String, int, int) IntPoint.newRangeQuery()},
- * {@link LongPoint#newRangeQuery(String, long, long) LongPoint.newRangeQuery()},
- * {@link FloatPoint#newRangeQuery(String, float, float) FloatPoint.newRangeQuery()},
- * {@link DoublePoint#newRangeQuery(String, double, double) DoublePoint.newRangeQuery()} respectively.
- * See {@link PointValues} for background information on Points.
- *
- * @since 2.9
- **/
-
-@Deprecated
-public final class LegacyNumericRangeQuery<T extends Number> extends MultiTermQuery {
-
- private LegacyNumericRangeQuery(final String field, final int precisionStep, final LegacyNumericType dataType,
- T min, T max, final boolean minInclusive, final boolean maxInclusive) {
- super(field);
- if (precisionStep < 1)
- throw new IllegalArgumentException("precisionStep must be >=1");
- this.precisionStep = precisionStep;
- this.dataType = Objects.requireNonNull(dataType, "LegacyNumericType must not be null");
- this.min = min;
- this.max = max;
- this.minInclusive = minInclusive;
- this.maxInclusive = maxInclusive;
- }
-
- /**
- * Factory that creates a <code>LegacyNumericRangeQuery</code>, that queries a <code>long</code>
- * range using the given <a href="#precisionStepDesc"><code>precisionStep</code></a>.
- * You can have half-open ranges (which are in fact </≤ or >/≥ queries)
- * by setting the min or max value to <code>null</code>. By setting inclusive to false, it will
- * match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
- */
- public static LegacyNumericRangeQuery<Long> newLongRange(final String field, final int precisionStep,
- Long min, Long max, final boolean minInclusive, final boolean maxInclusive
- ) {
- return new LegacyNumericRangeQuery<>(field, precisionStep, LegacyNumericType.LONG, min, max, minInclusive, maxInclusive);
- }
-
- /**
- * Factory that creates a <code>LegacyNumericRangeQuery</code>, that queries a <code>long</code>
- * range using the default <code>precisionStep</code> {@link org.apache.lucene.legacy.LegacyNumericUtils#PRECISION_STEP_DEFAULT} (16).
- * You can have half-open ranges (which are in fact </≤ or >/≥ queries)
- * by setting the min or max value to <code>null</code>. By setting inclusive to false, it will
- * match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
- */
- public static LegacyNumericRangeQuery<Long> newLongRange(final String field,
- Long min, Long max, final boolean minInclusive, final boolean maxInclusive
- ) {
- return new LegacyNumericRangeQuery<>(field, LegacyNumericUtils.PRECISION_STEP_DEFAULT, LegacyNumericType.LONG, min, max, minInclusive, maxInclusive);
- }
-
- /**
- * Factory that creates a <code>LegacyNumericRangeQuery</code>, that queries a <code>int</code>
- * range using the given <a href="#precisionStepDesc"><code>precisionStep</code></a>.
- * You can have half-open ranges (which are in fact </≤ or >/≥ queries)
- * by setting the min or max value to <code>null</code>. By setting inclusive to false, it will
- * match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
- */
- public static LegacyNumericRangeQuery<Integer> newIntRange(final String field, final int precisionStep,
- Integer min, Integer max, final boolean minInclusive, final boolean maxInclusive
- ) {
- return new LegacyNumericRangeQuery<>(field, precisionStep, LegacyNumericType.INT, min, max, minInclusive, maxInclusive);
- }
-
- /**
- * Factory that creates a <code>LegacyNumericRangeQuery</code>, that queries a <code>int</code>
- * range using the default <code>precisionStep</code> {@link org.apache.lucene.legacy.LegacyNumericUtils#PRECISION_STEP_DEFAULT_32} (8).
- * You can have half-open ranges (which are in fact </≤ or >/≥ queries)
- * by setting the min or max value to <code>null</code>. By setting inclusive to false, it will
- * match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
- */
- public static LegacyNumericRangeQuery<Integer> newIntRange(final String field,
- Integer min, Integer max, final boolean minInclusive, final boolean maxInclusive
- ) {
- return new LegacyNumericRangeQuery<>(field, LegacyNumericUtils.PRECISION_STEP_DEFAULT_32, LegacyNumericType.INT, min, max, minInclusive, maxInclusive);
- }
-
- /**
- * Factory that creates a <code>LegacyNumericRangeQuery</code>, that queries a <code>double</code>
- * range using the given <a href="#precisionStepDesc"><code>precisionStep</code></a>.
- * You can have half-open ranges (which are in fact </≤ or >/≥ queries)
- * by setting the min or max value to <code>null</code>.
- * {@link Double#NaN} will never match a half-open range, to hit {@code NaN} use a query
- * with {@code min == max == Double.NaN}. By setting inclusive to false, it will
- * match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
- */
- public static LegacyNumericRangeQuery<Double> newDoubleRange(final String field, final int precisionStep,
- Double min, Double max, final boolean minInclusive, final boolean maxInclusive
- ) {
- return new LegacyNumericRangeQuery<>(field, precisionStep, LegacyNumericType.DOUBLE, min, max, minInclusive, maxInclusive);
- }
-
- /**
- * Factory that creates a <code>LegacyNumericRangeQuery</code>, that queries a <code>double</code>
- * range using the default <code>precisionStep</code> {@link org.apache.lucene.legacy.LegacyNumericUtils#PRECISION_STEP_DEFAULT} (16).
- * You can have half-open ranges (which are in fact </≤ or >/≥ queries)
- * by setting the min or max value to <code>null</code>.
- * {@link Double#NaN} will never match a half-open range, to hit {@code NaN} use a query
- * with {@code min == max == Double.NaN}. By setting inclusive to false, it will
- * match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
- */
- public static LegacyNumericRangeQuery<Double> newDoubleRange(final String field,
- Double min, Double max, final boolean minInclusive, final boolean maxInclusive
- ) {
- return new LegacyNumericRangeQuery<>(field, LegacyNumericUtils.PRECISION_STEP_DEFAULT, LegacyNumericType.DOUBLE, min, max, minInclusive, maxInclusive);
- }
-
- /**
- * Factory that creates a <code>LegacyNumericRangeQuery</code>, that queries a <code>float</code>
- * range using the given <a href="#precisionStepDesc"><code>precisionStep</code></a>.
- * You can have half-open ranges (which are in fact </≤ or >/≥ queries)
- * by setting the min or max value to <code>null</code>.
- * {@link Float#NaN} will never match a half-open range, to hit {@code NaN} use a query
- * with {@code min == max == Float.NaN}. By setting inclusive to false, it will
- * match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
- */
- public static LegacyNumericRangeQuery<Float> newFloatRange(final String field, final int precisionStep,
- Float min, Float max, final boolean minInclusive, final boolean maxInclusive
- ) {
- return new LegacyNumericRangeQuery<>(field, precisionStep, LegacyNumericType.FLOAT, min, max, minInclusive, maxInclusive);
- }
-
- /**
- * Factory that creates a <code>LegacyNumericRangeQuery</code>, that queries a <code>float</code>
- * range using the default <code>precisionStep</code> {@link org.apache.lucene.legacy.LegacyNumericUtils#PRECISION_STEP_DEFAULT_32} (8).
- * You can have half-open ranges (which are in fact </≤ or >/≥ queries)
- * by setting the min or max value to <code>null</code>.
- * {@link Float#NaN} will never match a half-open range, to hit {@code NaN} use a query
- * with {@code min == max == Float.NaN}. By setting inclusive to false, it will
- * match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
- */
- public static LegacyNumericRangeQuery<Float> newFloatRange(final String field,
- Float min, Float max, final boolean minInclusive, final boolean maxInclusive
- ) {
- return new LegacyNumericRangeQuery<>(field, LegacyNumericUtils.PRECISION_STEP_DEFAULT_32, LegacyNumericType.FLOAT, min, max, minInclusive, maxInclusive);
- }
-
- @Override @SuppressWarnings("unchecked")
- protected TermsEnum getTermsEnum(final Terms terms, AttributeSource atts) throws IOException {
- // very strange: java.lang.Number itself is not Comparable, but all subclasses used here are
- if (min != null && max != null && ((Comparable<T>) min).compareTo(max) > 0) {
- return TermsEnum.EMPTY;
- }
- return new NumericRangeTermsEnum(terms.iterator());
- }
-
- /** Returns <code>true</code> if the lower endpoint is inclusive */
- public boolean includesMin() { return minInclusive; }
-
- /** Returns <code>true</code> if the upper endpoint is inclusive */
- public boolean includesMax() { return maxInclusive; }
-
- /** Returns the lower value of this range query */
- public T getMin() { return min; }
-
- /** Returns the upper value of this range query */
- public T getMax() { return max; }
-
- /** Returns the precision step. */
- public int getPrecisionStep() { return precisionStep; }
-
- @Override
- public String toString(final String field) {
- final StringBuilder sb = new StringBuilder();
- if (!getField().equals(field)) sb.append(getField()).append(':');
- return sb.append(minInclusive ? '[' : '{')
- .append((min == null) ? "*" : min.toString())
- .append(" TO ")
- .append((max == null) ? "*" : max.toString())
- .append(maxInclusive ? ']' : '}')
- .toString();
- }
-
- @Override
- @SuppressWarnings({"unchecked","rawtypes"})
- public final boolean equals(final Object o) {
- if (o==this) return true;
- if (!super.equals(o))
- return false;
- if (o instanceof LegacyNumericRangeQuery) {
- final LegacyNumericRangeQuery q=(LegacyNumericRangeQuery)o;
- return (
- (q.min == null ? min == null : q.min.equals(min)) &&
- (q.max == null ? max == null : q.max.equals(max)) &&
- minInclusive == q.minInclusive &&
- maxInclusive == q.maxInclusive &&
- precisionStep == q.precisionStep
- );
- }
- return false;
- }
-
- @Override
- public final int hashCode() {
- int hash = super.hashCode();
- hash = 31 * hash + precisionStep;
- hash = 31 * hash + Objects.hashCode(min);
- hash = 31 * hash + Objects.hashCode(max);
- hash = 31 * hash + Objects.hashCode(minInclusive);
- hash = 31 * hash + Objects.hashCode(maxInclusive);
- return hash;
- }
-
- // members (package private, to be also fast accessible by NumericRangeTermEnum)
- final int precisionStep;
- final LegacyNumericType dataType;
- final T min, max;
- final boolean minInclusive,maxInclusive;
-
- // used to handle float/double infinity correcty
- static final long LONG_NEGATIVE_INFINITY =
- NumericUtils.doubleToSortableLong(Double.NEGATIVE_INFINITY);
- static final long LONG_POSITIVE_INFINITY =
- NumericUtils.doubleToSortableLong(Double.POSITIVE_INFINITY);
- static final int INT_NEGATIVE_INFINITY =
- NumericUtils.floatToSortableInt(Float.NEGATIVE_INFINITY);
- static final int INT_POSITIVE_INFINITY =
- NumericUtils.floatToSortableInt(Float.POSITIVE_INFINITY);
-
- /**
- * Subclass of FilteredTermsEnum for enumerating all terms that match the
- * sub-ranges for trie range queries, using flex API.
- * <p>
- * WARNING: This term enumeration is not guaranteed to be always ordered by
- * {@link Term#compareTo}.
- * The ordering depends on how {@link org.apache.lucene.legacy.LegacyNumericUtils#splitLongRange} and
- * {@link org.apache.lucene.legacy.LegacyNumericUtils#splitIntRange} generates the sub-ranges. For
- * {@link MultiTermQuery} ordering is not relevant.
- */
- private final class NumericRangeTermsEnum extends FilteredTermsEnum {
-
- private BytesRef currentLowerBound, currentUpperBound;
-
- private final LinkedList<BytesRef> rangeBounds = new LinkedList<>();
-
- NumericRangeTermsEnum(final TermsEnum tenum) {
- super(tenum);
- switch (dataType) {
- case LONG:
- case DOUBLE: {
- // lower
- long minBound;
- if (dataType == LegacyNumericType.LONG) {
- minBound = (min == null) ? Long.MIN_VALUE : min.longValue();
- } else {
- assert dataType == LegacyNumericType.DOUBLE;
- minBound = (min == null) ? LONG_NEGATIVE_INFINITY
- : NumericUtils.doubleToSortableLong(min.doubleValue());
- }
- if (!minInclusive && min != null) {
- if (minBound == Long.MAX_VALUE) break;
- minBound++;
- }
-
- // upper
- long maxBound;
- if (dataType == LegacyNumericType.LONG) {
- maxBound = (max == null) ? Long.MAX_VALUE : max.longValue();
- } else {
- assert dataType == LegacyNumericType.DOUBLE;
- maxBound = (max == null) ? LONG_POSITIVE_INFINITY
- : NumericUtils.doubleToSortableLong(max.doubleValue());
- }
- if (!maxInclusive && max != null) {
- if (maxBound == Long.MIN_VALUE) break;
- maxBound--;
- }
-
- LegacyNumericUtils.splitLongRange(new LegacyNumericUtils.LongRangeBuilder() {
- @Override
- public final void addRange(BytesRef minPrefixCoded, BytesRef maxPrefixCoded) {
- rangeBounds.add(minPrefixCoded);
- rangeBounds.add(maxPrefixCoded);
- }
- }, precisionStep, minBound, maxBound);
- break;
- }
-
- case INT:
- case FLOAT: {
- // lower
- int minBound;
- if (dataType == LegacyNumericType.INT) {
- minBound = (min == null) ? Integer.MIN_VALUE : min.intValue();
- } else {
- assert dataType == LegacyNumericType.FLOAT;
- minBound = (min == null) ? INT_NEGATIVE_INFINITY
- : NumericUtils.floatToSortableInt(min.floatValue());
- }
- if (!minInclusive && min != null) {
- if (minBound == Integer.MAX_VALUE) break;
- minBound++;
- }
-
- // upper
- int maxBound;
- if (dataType == LegacyNumericType.INT) {
- maxBound = (max == null) ? Integer.MAX_VALUE : max.intValue();
- } else {
- assert dataType == LegacyNumericType.FLOAT;
- maxBound = (max == null) ? INT_POSITIVE_INFINITY
- : NumericUtils.floatToSortableInt(max.floatValue());
- }
- if (!maxInclusive && max != null) {
- if (maxBound == Integer.MIN_VALUE) break;
- maxBound--;
- }
-
- LegacyNumericUtils.splitIntRange(new LegacyNumericUtils.IntRangeBuilder() {
- @Override
- public final void addRange(BytesRef minPrefixCoded, BytesRef maxPrefixCoded) {
- rangeBounds.add(minPrefixCoded);
- rangeBounds.add(maxPrefixCoded);
- }
- }, precisionStep, minBound, maxBound);
- break;
- }
-
- default:
- // should never happen
- throw new IllegalArgumentException("Invalid LegacyNumericType");
- }
- }
-
- private void nextRange() {
- assert rangeBounds.size() % 2 == 0;
-
- currentLowerBound = rangeBounds.removeFirst();
- assert currentUpperBound == null || currentUpperBound.compareTo(currentLowerBound) <= 0 :
- "The current upper bound must be <= the new lower bound";
-
- currentUpperBound = rangeBounds.removeFirst();
- }
-
- @Override
- protected final BytesRef nextSeekTerm(BytesRef term) {
- while (rangeBounds.size() >= 2) {
- nextRange();
-
- // if the new upper bound is before the term parameter, the sub-range is never a hit
- if (term != null && term.compareTo(currentUpperBound) > 0)
- continue;
- // never seek backwards, so use current term if lower bound is smaller
- return (term != null && term.compareTo(currentLowerBound) > 0) ?
- term : currentLowerBound;
- }
-
- // no more sub-range enums available
- assert rangeBounds.isEmpty();
- currentLowerBound = currentUpperBound = null;
- return null;
- }
-
- @Override
- protected final AcceptStatus accept(BytesRef term) {
- while (currentUpperBound == null || term.compareTo(currentUpperBound) > 0) {
- if (rangeBounds.isEmpty())
- return AcceptStatus.END;
- // peek next sub-range, only seek if the current term is smaller than next lower bound
- if (term.compareTo(rangeBounds.getFirst()) < 0)
- return AcceptStatus.NO_AND_SEEK;
- // step forward to next range without seeking, as next lower range bound is less or equal current term
- nextRange();
- }
- return AcceptStatus.YES;
- }
-
- }
-
-}