From 105c7eae87896762cbcb295c73c8e8b1fd8f71f8 Mon Sep 17 00:00:00 2001 From: Robert Muir Date: Wed, 17 Aug 2016 09:28:45 -0400 Subject: [PATCH] LUCENE-7413: move legacy numeric support to backwards module --- .../lucene/legacy}/LegacyDoubleField.java | 42 ++-- .../org/apache/lucene/legacy/LegacyField.java | 90 ++++++++ .../apache/lucene/legacy/LegacyFieldType.java | 149 +++++++++++++ .../lucene/legacy}/LegacyFloatField.java | 44 ++-- .../apache/lucene/legacy}/LegacyIntField.java | 43 ++-- .../lucene/legacy}/LegacyLongField.java | 42 ++-- .../legacy}/LegacyNumericRangeQuery.java | 67 +++--- .../legacy}/LegacyNumericTokenStream.java | 18 +- .../lucene/legacy/LegacyNumericType.java | 34 +++ .../lucene/legacy}/LegacyNumericUtils.java | 26 +-- .../apache/lucene/legacy/package-info.java | 21 ++ .../index/TestBackwardsCompatibility.java | 8 +- .../apache/lucene/legacy/TestLegacyField.java | 196 ++++++++++++++++++ .../lucene/legacy/TestLegacyFieldReuse.java | 81 ++++++++ .../legacy}/TestLegacyNumericUtils.java | 9 +- .../apache/lucene/legacy/TestLegacyTerms.java | 164 +++++++++++++++ .../TestMultiValuedNumericRangeQuery.java | 8 +- .../legacy}/TestNumericRangeQuery32.java | 164 ++------------- .../legacy}/TestNumericRangeQuery64.java | 173 ++-------------- .../legacy}/TestNumericTokenStream.java | 35 +++- .../org/apache/lucene/document/Field.java | 33 --- .../org/apache/lucene/document/FieldType.java | 98 +-------- .../org/apache/lucene/document/TestField.java | 94 --------- .../apache/lucene/document/TestFieldType.java | 9 - .../apache/lucene/index/TestFieldReuse.java | 53 +---- .../org/apache/lucene/index/TestTerms.java | 134 ------------ lucene/join/build.xml | 6 +- .../search/join/DocValuesTermsCollector.java | 9 +- .../apache/lucene/search/join/JoinUtil.java | 6 +- .../search/join/TermsIncludingScoreQuery.java | 2 +- .../lucene/search/join/TestJoinUtil.java | 6 +- .../memory/TestMemoryIndexAgainstRAMDir.java | 7 - .../TestDiversifiedTopDocsCollector.java | 5 +- lucene/queryparser/build.xml | 6 +- .../LegacyNumericRangeQueryNodeBuilder.java | 10 +- .../standard/config/LegacyNumericConfig.java | 15 +- .../nodes/LegacyNumericRangeQueryNode.java | 9 +- .../LegacyNumericRangeQueryBuilder.java | 8 +- .../TestLegacyNumericQueryParser.java | 34 +-- .../xml/CoreParserTestIndexData.java | 2 +- .../TestNumericRangeQueryBuilder.java | 2 +- lucene/spatial-extras/build.xml | 8 +- .../lucene/spatial/bbox/BBoxStrategy.java | 39 ++-- .../prefix/BytesRefIteratorTokenStream.java | 2 +- .../spatial/vector/PointVectorStrategy.java | 37 ++-- .../lucene/spatial/bbox/TestBBoxStrategy.java | 8 +- .../solr/analytics/util/AnalyticsParsers.java | 2 +- .../util/valuesource/DateFieldSource.java | 2 +- .../solr/handler/component/StatsField.java | 17 +- .../apache/solr/request/IntervalFacets.java | 2 +- .../apache/solr/request/NumericFacets.java | 3 +- .../org/apache/solr/schema/BBoxField.java | 7 +- .../org/apache/solr/schema/EnumField.java | 17 +- .../org/apache/solr/schema/FieldType.java | 3 +- .../schema/SpatialPointVectorFieldType.java | 9 +- .../apache/solr/schema/TrieDoubleField.java | 2 +- .../org/apache/solr/schema/TrieField.java | 44 ++-- .../apache/solr/schema/TrieFloatField.java | 2 +- .../org/apache/solr/schema/TrieIntField.java | 2 +- .../org/apache/solr/schema/TrieLongField.java | 2 +- .../org/apache/solr/search/QueryParsing.java | 2 +- .../solr/search/QueryWrapperFilter.java | 2 +- .../apache/solr/search/facet/FacetField.java | 3 +- .../solr/search/mlt/CloudMLTQParser.java | 2 +- .../solr/search/mlt/SimpleMLTQParser.java | 2 +- .../apache/solr/uninverting/FieldCache.java | 20 +- .../solr/uninverting/UninvertingReader.java | 16 +- .../org/apache/solr/update/VersionInfo.java | 2 +- .../solr/search/TestMaxScoreQueryParser.java | 1 + .../solr/search/function/TestOrdValues.java | 4 +- .../solr/uninverting/TestDocTermOrds.java | 6 +- .../TestFieldCacheSanityChecker.java | 8 +- .../solr/uninverting/TestFieldCacheSort.java | 8 +- .../uninverting/TestLegacyFieldCache.java | 10 +- .../solr/uninverting/TestNumericTerms32.java | 14 +- .../solr/uninverting/TestNumericTerms64.java | 16 +- .../uninverting/TestUninvertingReader.java | 10 +- 77 files changed, 1204 insertions(+), 1092 deletions(-) rename lucene/{core/src/java/org/apache/lucene/document => backward-codecs/src/java/org/apache/lucene/legacy}/LegacyDoubleField.java (81%) create mode 100644 lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyField.java create mode 100644 lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyFieldType.java rename lucene/{core/src/java/org/apache/lucene/document => backward-codecs/src/java/org/apache/lucene/legacy}/LegacyFloatField.java (80%) rename lucene/{core/src/java/org/apache/lucene/document => backward-codecs/src/java/org/apache/lucene/legacy}/LegacyIntField.java (80%) rename lucene/{core/src/java/org/apache/lucene/document => backward-codecs/src/java/org/apache/lucene/legacy}/LegacyLongField.java (81%) rename lucene/{core/src/java/org/apache/lucene/search => backward-codecs/src/java/org/apache/lucene/legacy}/LegacyNumericRangeQuery.java (89%) rename lucene/{core/src/java/org/apache/lucene/analysis => backward-codecs/src/java/org/apache/lucene/legacy}/LegacyNumericTokenStream.java (94%) create mode 100644 lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericType.java rename lucene/{core/src/java/org/apache/lucene/util => backward-codecs/src/java/org/apache/lucene/legacy}/LegacyNumericUtils.java (95%) create mode 100644 lucene/backward-codecs/src/java/org/apache/lucene/legacy/package-info.java create mode 100644 lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestLegacyField.java create mode 100644 lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestLegacyFieldReuse.java rename lucene/{core/src/test/org/apache/lucene/util => backward-codecs/src/test/org/apache/lucene/legacy}/TestLegacyNumericUtils.java (98%) create mode 100644 lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestLegacyTerms.java rename lucene/{core/src/test/org/apache/lucene/search => backward-codecs/src/test/org/apache/lucene/legacy}/TestMultiValuedNumericRangeQuery.java (92%) rename lucene/{core/src/test/org/apache/lucene/search => backward-codecs/src/test/org/apache/lucene/legacy}/TestNumericRangeQuery32.java (72%) rename lucene/{core/src/test/org/apache/lucene/search => backward-codecs/src/test/org/apache/lucene/legacy}/TestNumericRangeQuery64.java (72%) rename lucene/{core/src/test/org/apache/lucene/analysis => backward-codecs/src/test/org/apache/lucene/legacy}/TestNumericTokenStream.java (85%) diff --git a/lucene/core/src/java/org/apache/lucene/document/LegacyDoubleField.java b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyDoubleField.java similarity index 81% rename from lucene/core/src/java/org/apache/lucene/document/LegacyDoubleField.java rename to lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyDoubleField.java index 55ba81cb120..e98a4f0f567 100644 --- a/lucene/core/src/java/org/apache/lucene/document/LegacyDoubleField.java +++ b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyDoubleField.java @@ -14,9 +14,11 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.apache.lucene.document; +package org.apache.lucene.legacy; +import org.apache.lucene.document.Document; +import org.apache.lucene.document.DoublePoint; import org.apache.lucene.index.IndexOptions; @@ -49,7 +51,7 @@ import org.apache.lucene.index.IndexOptions; * LegacyFloatField}. * *

To perform range querying or filtering against a - * LegacyDoubleField, use {@link org.apache.lucene.search.LegacyNumericRangeQuery}. + * LegacyDoubleField, use {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}. * To sort according to a * LegacyDoubleField, use the normal numeric sort types, eg * {@link org.apache.lucene.search.SortField.Type#DOUBLE}. LegacyDoubleField @@ -79,11 +81,11 @@ import org.apache.lucene.index.IndexOptions; * 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 FieldType} and invoke the {@link - * FieldType#setNumericPrecisionStep} method if you'd + * 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.search.LegacyNumericRangeQuery}. + * 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 @@ -91,9 +93,9 @@ import org.apache.lucene.index.IndexOptions; * *

For more information on the internals of numeric trie * indexing, including the precisionStep - * configuration, see {@link org.apache.lucene.search.LegacyNumericRangeQuery}. The format of - * indexed values is described in {@link org.apache.lucene.util.LegacyNumericUtils}. + * href="LegacyNumericRangeQuery.html#precisionStepDesc">precisionStep + * configuration, see {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}. The format of + * indexed values is described in {@link org.apache.lucene.legacy.LegacyNumericUtils}. * *

If you only need to sort by numeric value, and never * run range querying/filtering, you can index using a @@ -101,7 +103,7 @@ import org.apache.lucene.index.IndexOptions; * This will minimize disk space consumed.

* *

More advanced users can instead use {@link - * org.apache.lucene.analysis.LegacyNumericTokenStream} directly, when indexing numbers. This + * org.apache.lucene.legacy.LegacyNumericTokenStream} directly, when indexing numbers. This * class is a wrapper around this token stream type for * easier, more intuitive usage.

* @@ -111,18 +113,18 @@ import org.apache.lucene.index.IndexOptions; */ @Deprecated -public final class LegacyDoubleField extends Field { +public final class LegacyDoubleField extends LegacyField { /** * Type for a LegacyDoubleField that is not stored: * normalization factors, frequencies, and positions are omitted. */ - public static final FieldType TYPE_NOT_STORED = new FieldType(); + 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(FieldType.LegacyNumericType.DOUBLE); + TYPE_NOT_STORED.setNumericType(LegacyNumericType.DOUBLE); TYPE_NOT_STORED.freeze(); } @@ -130,19 +132,19 @@ public final class LegacyDoubleField extends Field { * Type for a stored LegacyDoubleField: * normalization factors, frequencies, and positions are omitted. */ - public static final FieldType TYPE_STORED = new FieldType(); + 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(FieldType.LegacyNumericType.DOUBLE); + 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 precisionStep {@link - * org.apache.lucene.util.LegacyNumericUtils#PRECISION_STEP_DEFAULT} (16). + * 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 @@ -154,17 +156,17 @@ public final class LegacyDoubleField extends Field { } /** Expert: allows you to customize the {@link - * FieldType}. + * LegacyFieldType}. * @param name field name * @param value 64-bit double value - * @param type customized field type: must have {@link FieldType#numericType()} - * of {@link org.apache.lucene.document.FieldType.LegacyNumericType#DOUBLE}. + * @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, FieldType type) { + public LegacyDoubleField(String name, double value, LegacyFieldType type) { super(name, type); - if (type.numericType() != FieldType.LegacyNumericType.DOUBLE) { + if (type.numericType() != LegacyNumericType.DOUBLE) { throw new IllegalArgumentException("type.numericType() must be DOUBLE but got " + type.numericType()); } fieldsData = Double.valueOf(value); 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 new file mode 100644 index 00000000000..87ac0e566cf --- /dev/null +++ b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyField.java @@ -0,0 +1,90 @@ +/* + * 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); + } + +} 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 new file mode 100644 index 00000000000..1f4b0af4768 --- /dev/null +++ b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyFieldType.java @@ -0,0 +1,149 @@ +/* + * 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 ref + */ + 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. + *

+ * The default is null (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. + *

+ * This has no effect if {@link #numericType()} returns null. + *

+ * 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(); + } +} diff --git a/lucene/core/src/java/org/apache/lucene/document/LegacyFloatField.java b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyFloatField.java similarity index 80% rename from lucene/core/src/java/org/apache/lucene/document/LegacyFloatField.java rename to lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyFloatField.java index e24bf30fa54..ea3b84ab65f 100644 --- a/lucene/core/src/java/org/apache/lucene/document/LegacyFloatField.java +++ b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyFloatField.java @@ -14,11 +14,11 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.apache.lucene.document; - +package org.apache.lucene.legacy; +import org.apache.lucene.document.Document; +import org.apache.lucene.document.FloatPoint; import org.apache.lucene.index.IndexOptions; -import org.apache.lucene.util.LegacyNumericUtils; /** *

@@ -49,7 +49,7 @@ import org.apache.lucene.util.LegacyNumericUtils; * LegacyDoubleField}. * *

To perform range querying or filtering against a - * LegacyFloatField, use {@link org.apache.lucene.search.LegacyNumericRangeQuery}. + * LegacyFloatField, use {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}. * To sort according to a * LegacyFloatField, use the normal numeric sort types, eg * {@link org.apache.lucene.search.SortField.Type#FLOAT}. LegacyFloatField @@ -79,11 +79,11 @@ import org.apache.lucene.util.LegacyNumericUtils; * 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 FieldType} and invoke the {@link - * FieldType#setNumericPrecisionStep} method if you'd + * 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.search.LegacyNumericRangeQuery}. + * 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 @@ -91,9 +91,9 @@ import org.apache.lucene.util.LegacyNumericUtils; * *

For more information on the internals of numeric trie * indexing, including the precisionStep - * configuration, see {@link org.apache.lucene.search.LegacyNumericRangeQuery}. The format of - * indexed values is described in {@link org.apache.lucene.util.LegacyNumericUtils}. + * href="LegacyNumericRangeQuery.html#precisionStepDesc">precisionStep + * configuration, see {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}. The format of + * indexed values is described in {@link org.apache.lucene.legacy.LegacyNumericUtils}. * *

If you only need to sort by numeric value, and never * run range querying/filtering, you can index using a @@ -101,7 +101,7 @@ import org.apache.lucene.util.LegacyNumericUtils; * This will minimize disk space consumed.

* *

More advanced users can instead use {@link - * org.apache.lucene.analysis.LegacyNumericTokenStream} directly, when indexing numbers. This + * org.apache.lucene.legacy.LegacyNumericTokenStream} directly, when indexing numbers. This * class is a wrapper around this token stream type for * easier, more intuitive usage.

* @@ -111,18 +111,18 @@ import org.apache.lucene.util.LegacyNumericUtils; */ @Deprecated -public final class LegacyFloatField extends Field { +public final class LegacyFloatField extends LegacyField { /** * Type for a LegacyFloatField that is not stored: * normalization factors, frequencies, and positions are omitted. */ - public static final FieldType TYPE_NOT_STORED = new FieldType(); + 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(FieldType.LegacyNumericType.FLOAT); + TYPE_NOT_STORED.setNumericType(LegacyNumericType.FLOAT); TYPE_NOT_STORED.setNumericPrecisionStep(LegacyNumericUtils.PRECISION_STEP_DEFAULT_32); TYPE_NOT_STORED.freeze(); } @@ -131,12 +131,12 @@ public final class LegacyFloatField extends Field { * Type for a stored LegacyFloatField: * normalization factors, frequencies, and positions are omitted. */ - public static final FieldType TYPE_STORED = new FieldType(); + 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(FieldType.LegacyNumericType.FLOAT); + TYPE_STORED.setNumericType(LegacyNumericType.FLOAT); TYPE_STORED.setNumericPrecisionStep(LegacyNumericUtils.PRECISION_STEP_DEFAULT_32); TYPE_STORED.setStored(true); TYPE_STORED.freeze(); @@ -144,7 +144,7 @@ public final class LegacyFloatField extends Field { /** Creates a stored or un-stored LegacyFloatField with the provided value * and default precisionStep {@link - * org.apache.lucene.util.LegacyNumericUtils#PRECISION_STEP_DEFAULT_32} (8). + * 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 @@ -156,17 +156,17 @@ public final class LegacyFloatField extends Field { } /** Expert: allows you to customize the {@link - * FieldType}. + * LegacyFieldType}. * @param name field name * @param value 32-bit float value - * @param type customized field type: must have {@link FieldType#numericType()} - * of {@link org.apache.lucene.document.FieldType.LegacyNumericType#FLOAT}. + * @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, FieldType type) { + public LegacyFloatField(String name, float value, LegacyFieldType type) { super(name, type); - if (type.numericType() != FieldType.LegacyNumericType.FLOAT) { + if (type.numericType() != LegacyNumericType.FLOAT) { throw new IllegalArgumentException("type.numericType() must be FLOAT but got " + type.numericType()); } fieldsData = Float.valueOf(value); diff --git a/lucene/core/src/java/org/apache/lucene/document/LegacyIntField.java b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyIntField.java similarity index 80% rename from lucene/core/src/java/org/apache/lucene/document/LegacyIntField.java rename to lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyIntField.java index 6eb0376ee64..e3ae9658b1d 100644 --- a/lucene/core/src/java/org/apache/lucene/document/LegacyIntField.java +++ b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyIntField.java @@ -14,11 +14,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.apache.lucene.document; +package org.apache.lucene.legacy; +import org.apache.lucene.document.Document; +import org.apache.lucene.document.IntPoint; import org.apache.lucene.index.IndexOptions; -import org.apache.lucene.util.LegacyNumericUtils; /** *

@@ -49,7 +50,7 @@ import org.apache.lucene.util.LegacyNumericUtils; * LegacyDoubleField}. * *

To perform range querying or filtering against a - * LegacyIntField, use {@link org.apache.lucene.search.LegacyNumericRangeQuery}. + * LegacyIntField, use {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}. * To sort according to a * LegacyIntField, use the normal numeric sort types, eg * {@link org.apache.lucene.search.SortField.Type#INT}. LegacyIntField @@ -79,11 +80,11 @@ import org.apache.lucene.util.LegacyNumericUtils; * 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 FieldType} and invoke the {@link - * FieldType#setNumericPrecisionStep} method if you'd + * 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.search.LegacyNumericRangeQuery}. + * 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 @@ -91,9 +92,9 @@ import org.apache.lucene.util.LegacyNumericUtils; * *

For more information on the internals of numeric trie * indexing, including the precisionStep - * configuration, see {@link org.apache.lucene.search.LegacyNumericRangeQuery}. The format of - * indexed values is described in {@link org.apache.lucene.util.LegacyNumericUtils}. + * href="LegacyNumericRangeQuery.html#precisionStepDesc">precisionStep + * configuration, see {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}. The format of + * indexed values is described in {@link org.apache.lucene.legacy.LegacyNumericUtils}. * *

If you only need to sort by numeric value, and never * run range querying/filtering, you can index using a @@ -101,7 +102,7 @@ import org.apache.lucene.util.LegacyNumericUtils; * This will minimize disk space consumed.

* *

More advanced users can instead use {@link - * org.apache.lucene.analysis.LegacyNumericTokenStream} directly, when indexing numbers. This + * org.apache.lucene.legacy.LegacyNumericTokenStream} directly, when indexing numbers. This * class is a wrapper around this token stream type for * easier, more intuitive usage.

* @@ -111,18 +112,18 @@ import org.apache.lucene.util.LegacyNumericUtils; */ @Deprecated -public final class LegacyIntField extends Field { +public final class LegacyIntField extends LegacyField { /** * Type for an LegacyIntField that is not stored: * normalization factors, frequencies, and positions are omitted. */ - public static final FieldType TYPE_NOT_STORED = new FieldType(); + 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(FieldType.LegacyNumericType.INT); + TYPE_NOT_STORED.setNumericType(LegacyNumericType.INT); TYPE_NOT_STORED.setNumericPrecisionStep(LegacyNumericUtils.PRECISION_STEP_DEFAULT_32); TYPE_NOT_STORED.freeze(); } @@ -131,12 +132,12 @@ public final class LegacyIntField extends Field { * Type for a stored LegacyIntField: * normalization factors, frequencies, and positions are omitted. */ - public static final FieldType TYPE_STORED = new FieldType(); + 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(FieldType.LegacyNumericType.INT); + TYPE_STORED.setNumericType(LegacyNumericType.INT); TYPE_STORED.setNumericPrecisionStep(LegacyNumericUtils.PRECISION_STEP_DEFAULT_32); TYPE_STORED.setStored(true); TYPE_STORED.freeze(); @@ -144,7 +145,7 @@ public final class LegacyIntField extends Field { /** Creates a stored or un-stored LegacyIntField with the provided value * and default precisionStep {@link - * org.apache.lucene.util.LegacyNumericUtils#PRECISION_STEP_DEFAULT_32} (8). + * 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 @@ -156,17 +157,17 @@ public final class LegacyIntField extends Field { } /** Expert: allows you to customize the {@link - * FieldType}. + * LegacyFieldType}. * @param name field name * @param value 32-bit integer value - * @param type customized field type: must have {@link FieldType#numericType()} - * of {@link org.apache.lucene.document.FieldType.LegacyNumericType#INT}. + * @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, FieldType type) { + public LegacyIntField(String name, int value, LegacyFieldType type) { super(name, type); - if (type.numericType() != FieldType.LegacyNumericType.INT) { + if (type.numericType() != LegacyNumericType.INT) { throw new IllegalArgumentException("type.numericType() must be INT but got " + type.numericType()); } fieldsData = Integer.valueOf(value); diff --git a/lucene/core/src/java/org/apache/lucene/document/LegacyLongField.java b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyLongField.java similarity index 81% rename from lucene/core/src/java/org/apache/lucene/document/LegacyLongField.java rename to lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyLongField.java index fa1851fe7e6..3e20b448b96 100644 --- a/lucene/core/src/java/org/apache/lucene/document/LegacyLongField.java +++ b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyLongField.java @@ -14,9 +14,11 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.apache.lucene.document; +package org.apache.lucene.legacy; +import org.apache.lucene.document.Document; +import org.apache.lucene.document.LongPoint; import org.apache.lucene.index.IndexOptions; @@ -59,7 +61,7 @@ import org.apache.lucene.index.IndexOptions; * long value. * *

To perform range querying or filtering against a - * LegacyLongField, use {@link org.apache.lucene.search.LegacyNumericRangeQuery}. + * LegacyLongField, use {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}. * To sort according to a * LegacyLongField, use the normal numeric sort types, eg * {@link org.apache.lucene.search.SortField.Type#LONG}. LegacyLongField @@ -89,11 +91,11 @@ import org.apache.lucene.index.IndexOptions; * 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 FieldType} and invoke the {@link - * FieldType#setNumericPrecisionStep} method if you'd + * 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.search.LegacyNumericRangeQuery}. + * 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 @@ -101,9 +103,9 @@ import org.apache.lucene.index.IndexOptions; * *

For more information on the internals of numeric trie * indexing, including the precisionStep - * configuration, see {@link org.apache.lucene.search.LegacyNumericRangeQuery}. The format of - * indexed values is described in {@link org.apache.lucene.util.LegacyNumericUtils}. + * href="LegacyNumericRangeQuery.html#precisionStepDesc">precisionStep + * configuration, see {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}. The format of + * indexed values is described in {@link org.apache.lucene.legacy.LegacyNumericUtils}. * *

If you only need to sort by numeric value, and never * run range querying/filtering, you can index using a @@ -111,7 +113,7 @@ import org.apache.lucene.index.IndexOptions; * This will minimize disk space consumed. * *

More advanced users can instead use {@link - * org.apache.lucene.analysis.LegacyNumericTokenStream} directly, when indexing numbers. This + * org.apache.lucene.legacy.LegacyNumericTokenStream} directly, when indexing numbers. This * class is a wrapper around this token stream type for * easier, more intuitive usage.

* @@ -121,18 +123,18 @@ import org.apache.lucene.index.IndexOptions; */ @Deprecated -public final class LegacyLongField extends Field { +public final class LegacyLongField extends LegacyField { /** * Type for a LegacyLongField that is not stored: * normalization factors, frequencies, and positions are omitted. */ - public static final FieldType TYPE_NOT_STORED = new FieldType(); + 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(FieldType.LegacyNumericType.LONG); + TYPE_NOT_STORED.setNumericType(LegacyNumericType.LONG); TYPE_NOT_STORED.freeze(); } @@ -140,19 +142,19 @@ public final class LegacyLongField extends Field { * Type for a stored LegacyLongField: * normalization factors, frequencies, and positions are omitted. */ - public static final FieldType TYPE_STORED = new FieldType(); + 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(FieldType.LegacyNumericType.LONG); + 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 precisionStep {@link - * org.apache.lucene.util.LegacyNumericUtils#PRECISION_STEP_DEFAULT} (16). + * 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 @@ -164,17 +166,17 @@ public final class LegacyLongField extends Field { } /** Expert: allows you to customize the {@link - * FieldType}. + * LegacyFieldType}. * @param name field name * @param value 64-bit long value - * @param type customized field type: must have {@link FieldType#numericType()} - * of {@link org.apache.lucene.document.FieldType.LegacyNumericType#LONG}. + * @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, FieldType type) { + public LegacyLongField(String name, long value, LegacyFieldType type) { super(name, type); - if (type.numericType() != FieldType.LegacyNumericType.LONG) { + if (type.numericType() != LegacyNumericType.LONG) { throw new IllegalArgumentException("type.numericType() must be LONG but got " + type.numericType()); } fieldsData = Long.valueOf(value); diff --git a/lucene/core/src/java/org/apache/lucene/search/LegacyNumericRangeQuery.java b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericRangeQuery.java similarity index 89% rename from lucene/core/src/java/org/apache/lucene/search/LegacyNumericRangeQuery.java rename to lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericRangeQuery.java index fe6c9e24864..f172a200779 100644 --- a/lucene/core/src/java/org/apache/lucene/search/LegacyNumericRangeQuery.java +++ b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericRangeQuery.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.apache.lucene.search; +package org.apache.lucene.legacy; import java.io.IOException; @@ -22,8 +22,6 @@ import java.util.LinkedList; import java.util.Objects; import org.apache.lucene.document.DoublePoint; -import org.apache.lucene.document.FieldType; -import org.apache.lucene.document.FieldType.LegacyNumericType; import org.apache.lucene.document.FloatPoint; import org.apache.lucene.document.IntPoint; import org.apache.lucene.document.LongPoint; @@ -31,18 +29,21 @@ 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.LegacyNumericUtils; import org.apache.lucene.util.NumericUtils; import org.apache.lucene.index.Term; // for javadocs /** *

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.document.LegacyIntField}, {@link - * org.apache.lucene.document.LegacyFloatField}, {@link org.apache.lucene.document.LegacyLongField} or {@link org.apache.lucene.document.LegacyDoubleField} (expert: {@link - * org.apache.lucene.analysis.LegacyNumericTokenStream}). If your terms are instead textual, + * 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}.

* *

You create a new LegacyNumericRangeQuery with the static @@ -96,7 +97,7 @@ import org.apache.lucene.index.Term; // for javadocs * (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.util.LegacyNumericUtils}). A range is then divided recursively into multiple intervals for searching: + * 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 trie, * while the boundaries are matched more exactly. This reduces the number of terms dramatically.

* @@ -112,7 +113,7 @@ import org.apache.lucene.index.Term; // for javadocs *

Precision Step

*

You can choose any precisionStep 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.analysis.LegacyNumericTokenStream}): + * of indexed terms per value is (those are generated by {@link org.apache.lucene.legacy.LegacyNumericTokenStream}): *

*   indexedTermsPerValue = ceil(bitsPerValue / precisionStep) *

@@ -148,8 +149,8 @@ import org.apache.lucene.index.Term; // for javadocs *
  • Steps ≥64 for long/double and ≥32 for int/float 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 - * precisionStep). Using {@link org.apache.lucene.document.LegacyIntField}, - * {@link org.apache.lucene.document.LegacyLongField}, {@link org.apache.lucene.document.LegacyFloatField} or {@link org.apache.lucene.document.LegacyDoubleField} for sorting + * precisionStep). 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). @@ -199,12 +200,12 @@ public final class LegacyNumericRangeQuery extends MultiTermQu public static LegacyNumericRangeQuery newLongRange(final String field, final int precisionStep, Long min, Long max, final boolean minInclusive, final boolean maxInclusive ) { - return new LegacyNumericRangeQuery<>(field, precisionStep, FieldType.LegacyNumericType.LONG, min, max, minInclusive, maxInclusive); + return new LegacyNumericRangeQuery<>(field, precisionStep, LegacyNumericType.LONG, min, max, minInclusive, maxInclusive); } /** * Factory that creates a LegacyNumericRangeQuery, that queries a long - * range using the default precisionStep {@link org.apache.lucene.util.LegacyNumericUtils#PRECISION_STEP_DEFAULT} (16). + * range using the default precisionStep {@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 null. By setting inclusive to false, it will * match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. @@ -212,7 +213,7 @@ public final class LegacyNumericRangeQuery extends MultiTermQu public static LegacyNumericRangeQuery newLongRange(final String field, Long min, Long max, final boolean minInclusive, final boolean maxInclusive ) { - return new LegacyNumericRangeQuery<>(field, LegacyNumericUtils.PRECISION_STEP_DEFAULT, FieldType.LegacyNumericType.LONG, min, max, minInclusive, maxInclusive); + return new LegacyNumericRangeQuery<>(field, LegacyNumericUtils.PRECISION_STEP_DEFAULT, LegacyNumericType.LONG, min, max, minInclusive, maxInclusive); } /** @@ -225,12 +226,12 @@ public final class LegacyNumericRangeQuery extends MultiTermQu public static LegacyNumericRangeQuery newIntRange(final String field, final int precisionStep, Integer min, Integer max, final boolean minInclusive, final boolean maxInclusive ) { - return new LegacyNumericRangeQuery<>(field, precisionStep, FieldType.LegacyNumericType.INT, min, max, minInclusive, maxInclusive); + return new LegacyNumericRangeQuery<>(field, precisionStep, LegacyNumericType.INT, min, max, minInclusive, maxInclusive); } /** * Factory that creates a LegacyNumericRangeQuery, that queries a int - * range using the default precisionStep {@link org.apache.lucene.util.LegacyNumericUtils#PRECISION_STEP_DEFAULT_32} (8). + * range using the default precisionStep {@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 null. By setting inclusive to false, it will * match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. @@ -238,7 +239,7 @@ public final class LegacyNumericRangeQuery extends MultiTermQu public static LegacyNumericRangeQuery newIntRange(final String field, Integer min, Integer max, final boolean minInclusive, final boolean maxInclusive ) { - return new LegacyNumericRangeQuery<>(field, LegacyNumericUtils.PRECISION_STEP_DEFAULT_32, FieldType.LegacyNumericType.INT, min, max, minInclusive, maxInclusive); + return new LegacyNumericRangeQuery<>(field, LegacyNumericUtils.PRECISION_STEP_DEFAULT_32, LegacyNumericType.INT, min, max, minInclusive, maxInclusive); } /** @@ -253,12 +254,12 @@ public final class LegacyNumericRangeQuery extends MultiTermQu public static LegacyNumericRangeQuery newDoubleRange(final String field, final int precisionStep, Double min, Double max, final boolean minInclusive, final boolean maxInclusive ) { - return new LegacyNumericRangeQuery<>(field, precisionStep, FieldType.LegacyNumericType.DOUBLE, min, max, minInclusive, maxInclusive); + return new LegacyNumericRangeQuery<>(field, precisionStep, LegacyNumericType.DOUBLE, min, max, minInclusive, maxInclusive); } /** * Factory that creates a LegacyNumericRangeQuery, that queries a double - * range using the default precisionStep {@link org.apache.lucene.util.LegacyNumericUtils#PRECISION_STEP_DEFAULT} (16). + * range using the default precisionStep {@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 null. * {@link Double#NaN} will never match a half-open range, to hit {@code NaN} use a query @@ -268,7 +269,7 @@ public final class LegacyNumericRangeQuery extends MultiTermQu public static LegacyNumericRangeQuery newDoubleRange(final String field, Double min, Double max, final boolean minInclusive, final boolean maxInclusive ) { - return new LegacyNumericRangeQuery<>(field, LegacyNumericUtils.PRECISION_STEP_DEFAULT, FieldType.LegacyNumericType.DOUBLE, min, max, minInclusive, maxInclusive); + return new LegacyNumericRangeQuery<>(field, LegacyNumericUtils.PRECISION_STEP_DEFAULT, LegacyNumericType.DOUBLE, min, max, minInclusive, maxInclusive); } /** @@ -283,12 +284,12 @@ public final class LegacyNumericRangeQuery extends MultiTermQu public static LegacyNumericRangeQuery newFloatRange(final String field, final int precisionStep, Float min, Float max, final boolean minInclusive, final boolean maxInclusive ) { - return new LegacyNumericRangeQuery<>(field, precisionStep, FieldType.LegacyNumericType.FLOAT, min, max, minInclusive, maxInclusive); + return new LegacyNumericRangeQuery<>(field, precisionStep, LegacyNumericType.FLOAT, min, max, minInclusive, maxInclusive); } /** * Factory that creates a LegacyNumericRangeQuery, that queries a float - * range using the default precisionStep {@link org.apache.lucene.util.LegacyNumericUtils#PRECISION_STEP_DEFAULT_32} (8). + * range using the default precisionStep {@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 null. * {@link Float#NaN} will never match a half-open range, to hit {@code NaN} use a query @@ -298,7 +299,7 @@ public final class LegacyNumericRangeQuery extends MultiTermQu public static LegacyNumericRangeQuery newFloatRange(final String field, Float min, Float max, final boolean minInclusive, final boolean maxInclusive ) { - return new LegacyNumericRangeQuery<>(field, LegacyNumericUtils.PRECISION_STEP_DEFAULT_32, FieldType.LegacyNumericType.FLOAT, min, max, minInclusive, maxInclusive); + return new LegacyNumericRangeQuery<>(field, LegacyNumericUtils.PRECISION_STEP_DEFAULT_32, LegacyNumericType.FLOAT, min, max, minInclusive, maxInclusive); } @Override @SuppressWarnings("unchecked") @@ -369,7 +370,7 @@ public final class LegacyNumericRangeQuery extends MultiTermQu // members (package private, to be also fast accessible by NumericRangeTermEnum) final int precisionStep; - final FieldType.LegacyNumericType dataType; + final LegacyNumericType dataType; final T min, max; final boolean minInclusive,maxInclusive; @@ -389,8 +390,8 @@ public final class LegacyNumericRangeQuery extends MultiTermQu *

    * WARNING: This term enumeration is not guaranteed to be always ordered by * {@link Term#compareTo}. - * The ordering depends on how {@link org.apache.lucene.util.LegacyNumericUtils#splitLongRange} and - * {@link org.apache.lucene.util.LegacyNumericUtils#splitIntRange} generates the sub-ranges. For + * 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 { @@ -406,10 +407,10 @@ public final class LegacyNumericRangeQuery extends MultiTermQu case DOUBLE: { // lower long minBound; - if (dataType == FieldType.LegacyNumericType.LONG) { + if (dataType == LegacyNumericType.LONG) { minBound = (min == null) ? Long.MIN_VALUE : min.longValue(); } else { - assert dataType == FieldType.LegacyNumericType.DOUBLE; + assert dataType == LegacyNumericType.DOUBLE; minBound = (min == null) ? LONG_NEGATIVE_INFINITY : NumericUtils.doubleToSortableLong(min.doubleValue()); } @@ -420,10 +421,10 @@ public final class LegacyNumericRangeQuery extends MultiTermQu // upper long maxBound; - if (dataType == FieldType.LegacyNumericType.LONG) { + if (dataType == LegacyNumericType.LONG) { maxBound = (max == null) ? Long.MAX_VALUE : max.longValue(); } else { - assert dataType == FieldType.LegacyNumericType.DOUBLE; + assert dataType == LegacyNumericType.DOUBLE; maxBound = (max == null) ? LONG_POSITIVE_INFINITY : NumericUtils.doubleToSortableLong(max.doubleValue()); } @@ -446,10 +447,10 @@ public final class LegacyNumericRangeQuery extends MultiTermQu case FLOAT: { // lower int minBound; - if (dataType == FieldType.LegacyNumericType.INT) { + if (dataType == LegacyNumericType.INT) { minBound = (min == null) ? Integer.MIN_VALUE : min.intValue(); } else { - assert dataType == FieldType.LegacyNumericType.FLOAT; + assert dataType == LegacyNumericType.FLOAT; minBound = (min == null) ? INT_NEGATIVE_INFINITY : NumericUtils.floatToSortableInt(min.floatValue()); } @@ -463,7 +464,7 @@ public final class LegacyNumericRangeQuery extends MultiTermQu if (dataType == LegacyNumericType.INT) { maxBound = (max == null) ? Integer.MAX_VALUE : max.intValue(); } else { - assert dataType == FieldType.LegacyNumericType.FLOAT; + assert dataType == LegacyNumericType.FLOAT; maxBound = (max == null) ? INT_POSITIVE_INFINITY : NumericUtils.floatToSortableInt(max.floatValue()); } diff --git a/lucene/core/src/java/org/apache/lucene/analysis/LegacyNumericTokenStream.java b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericTokenStream.java similarity index 94% rename from lucene/core/src/java/org/apache/lucene/analysis/LegacyNumericTokenStream.java rename to lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericTokenStream.java index 19f7d37e31f..a2aba19e2ac 100644 --- a/lucene/core/src/java/org/apache/lucene/analysis/LegacyNumericTokenStream.java +++ b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericTokenStream.java @@ -14,11 +14,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.apache.lucene.analysis; +package org.apache.lucene.legacy; import java.util.Objects; +import org.apache.lucene.analysis.TokenStream; import org.apache.lucene.analysis.tokenattributes.CharTermAttribute; import org.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute; import org.apache.lucene.analysis.tokenattributes.TermToBytesRefAttribute; @@ -29,16 +30,15 @@ import org.apache.lucene.util.AttributeImpl; import org.apache.lucene.util.AttributeReflector; import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.BytesRefBuilder; -import org.apache.lucene.util.LegacyNumericUtils; import org.apache.lucene.util.NumericUtils; /** * Expert: This class provides a {@link TokenStream} * for indexing numeric values that can be used by {@link - * org.apache.lucene.search.LegacyNumericRangeQuery}. + * org.apache.lucene.legacy.LegacyNumericRangeQuery}. * - *

    Note that for simple usage, {@link org.apache.lucene.document.LegacyIntField}, {@link - * org.apache.lucene.document.LegacyLongField}, {@link org.apache.lucene.document.LegacyFloatField} or {@link org.apache.lucene.document.LegacyDoubleField} is + *

    Note that for simple usage, {@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} 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 @@ -81,9 +81,9 @@ import org.apache.lucene.util.NumericUtils; * than one numeric field, use a separate LegacyNumericTokenStream * instance for each.

    * - *

    See {@link org.apache.lucene.search.LegacyNumericRangeQuery} for more details on the + *

    See {@link org.apache.lucene.legacy.LegacyNumericRangeQuery} for more details on the * precisionStep + * href="LegacyNumericRangeQuery.html#precisionStepDesc">precisionStep * parameter as well as how numeric fields work under the hood.

    * * @deprecated Please switch to {@link org.apache.lucene.index.PointValues} instead @@ -140,7 +140,7 @@ public final class LegacyNumericTokenStream extends TokenStream { } } - /** Implementation of {@link org.apache.lucene.analysis.LegacyNumericTokenStream.LegacyNumericTermAttribute}. + /** Implementation of {@link org.apache.lucene.legacy.LegacyNumericTokenStream.LegacyNumericTermAttribute}. * @lucene.internal * @since 4.0 */ @@ -240,7 +240,7 @@ public final class LegacyNumericTokenStream extends TokenStream { /** * Creates a token stream for numeric values using the default precisionStep - * {@link org.apache.lucene.util.LegacyNumericUtils#PRECISION_STEP_DEFAULT} (16). The stream is not yet initialized, + * {@link org.apache.lucene.legacy.LegacyNumericUtils#PRECISION_STEP_DEFAULT} (16). The stream is not yet initialized, * before using set a value using the various set???Value() methods. */ public LegacyNumericTokenStream() { diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericType.java b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericType.java new file mode 100644 index 00000000000..345b4974b02 --- /dev/null +++ b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericType.java @@ -0,0 +1,34 @@ +/* + * 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; + +/** Data type of the numeric value + * @since 3.2 + * + * @deprecated Please switch to {@link org.apache.lucene.index.PointValues} instead + */ +@Deprecated +public enum LegacyNumericType { + /** 32-bit integer numeric type */ + INT, + /** 64-bit long numeric type */ + LONG, + /** 32-bit float numeric type */ + FLOAT, + /** 64-bit double numeric type */ + DOUBLE +} diff --git a/lucene/core/src/java/org/apache/lucene/util/LegacyNumericUtils.java b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericUtils.java similarity index 95% rename from lucene/core/src/java/org/apache/lucene/util/LegacyNumericUtils.java rename to lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericUtils.java index 9a26bfa3f2b..e6659d7e102 100644 --- a/lucene/core/src/java/org/apache/lucene/util/LegacyNumericUtils.java +++ b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/LegacyNumericUtils.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.apache.lucene.util; +package org.apache.lucene.legacy; import java.io.IOException; @@ -23,6 +23,8 @@ import org.apache.lucene.index.FilterLeafReader; import org.apache.lucene.index.FilteredTermsEnum; import org.apache.lucene.index.Terms; import org.apache.lucene.index.TermsEnum; +import org.apache.lucene.util.BytesRef; +import org.apache.lucene.util.BytesRefBuilder; /** * This is a helper class to generate prefix-encoded representations for numerical values @@ -41,9 +43,9 @@ import org.apache.lucene.index.TermsEnum; * during encoding. * *

    For easy usage, the trie algorithm is implemented for indexing inside - * {@link org.apache.lucene.analysis.LegacyNumericTokenStream} that can index int, long, + * {@link org.apache.lucene.legacy.LegacyNumericTokenStream} that can index int, long, * float, and double. For querying, - * {@link org.apache.lucene.search.LegacyNumericRangeQuery} implements the query part + * {@link org.apache.lucene.legacy.LegacyNumericRangeQuery} implements the query part * for the same data types. * * @lucene.internal @@ -59,15 +61,15 @@ public final class LegacyNumericUtils { private LegacyNumericUtils() {} // no instance! /** - * The default precision step used by {@link org.apache.lucene.document.LegacyLongField}, - * {@link org.apache.lucene.document.LegacyDoubleField}, {@link org.apache.lucene.analysis.LegacyNumericTokenStream}, {@link - * org.apache.lucene.search.LegacyNumericRangeQuery}. + * The default precision step used by {@link org.apache.lucene.legacy.LegacyLongField}, + * {@link org.apache.lucene.legacy.LegacyDoubleField}, {@link org.apache.lucene.legacy.LegacyNumericTokenStream}, {@link + * org.apache.lucene.legacy.LegacyNumericRangeQuery}. */ public static final int PRECISION_STEP_DEFAULT = 16; /** - * The default precision step used by {@link org.apache.lucene.document.LegacyIntField} and - * {@link org.apache.lucene.document.LegacyFloatField}. + * The default precision step used by {@link org.apache.lucene.legacy.LegacyIntField} and + * {@link org.apache.lucene.legacy.LegacyFloatField}. */ public static final int PRECISION_STEP_DEFAULT_32 = 8; @@ -99,7 +101,7 @@ public final class LegacyNumericUtils { /** * Returns prefix coded bits after reducing the precision by shift bits. - * This is method is used by {@link org.apache.lucene.analysis.LegacyNumericTokenStream}. + * This is method is used by {@link org.apache.lucene.legacy.LegacyNumericTokenStream}. * After encoding, {@code bytes.offset} will always be 0. * @param val the numeric value * @param shift how many bits to strip from the right @@ -126,7 +128,7 @@ public final class LegacyNumericUtils { /** * Returns prefix coded bits after reducing the precision by shift bits. - * This is method is used by {@link org.apache.lucene.analysis.LegacyNumericTokenStream}. + * This is method is used by {@link org.apache.lucene.legacy.LegacyNumericTokenStream}. * After encoding, {@code bytes.offset} will always be 0. * @param val the numeric value * @param shift how many bits to strip from the right @@ -230,7 +232,7 @@ public final class LegacyNumericUtils { * {@link org.apache.lucene.search.BooleanQuery} for each call to its * {@link LongRangeBuilder#addRange(BytesRef,BytesRef)} * method. - *

    This method is used by {@link org.apache.lucene.search.LegacyNumericRangeQuery}. + *

    This method is used by {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}. */ public static void splitLongRange(final LongRangeBuilder builder, final int precisionStep, final long minBound, final long maxBound @@ -244,7 +246,7 @@ public final class LegacyNumericUtils { * {@link org.apache.lucene.search.BooleanQuery} for each call to its * {@link IntRangeBuilder#addRange(BytesRef,BytesRef)} * method. - *

    This method is used by {@link org.apache.lucene.search.LegacyNumericRangeQuery}. + *

    This method is used by {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}. */ public static void splitIntRange(final IntRangeBuilder builder, final int precisionStep, final int minBound, final int maxBound diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/legacy/package-info.java b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/package-info.java new file mode 100644 index 00000000000..d0167f80023 --- /dev/null +++ b/lucene/backward-codecs/src/java/org/apache/lucene/legacy/package-info.java @@ -0,0 +1,21 @@ +/* + * 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. + */ + +/** + * Deprecated stuff! + */ +package org.apache.lucene.legacy; diff --git a/lucene/backward-codecs/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java b/lucene/backward-codecs/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java index 8226022e6d8..03480d779ed 100644 --- a/lucene/backward-codecs/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java +++ b/lucene/backward-codecs/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java @@ -47,8 +47,6 @@ import org.apache.lucene.document.FieldType; import org.apache.lucene.document.FloatDocValuesField; import org.apache.lucene.document.FloatPoint; import org.apache.lucene.document.IntPoint; -import org.apache.lucene.document.LegacyIntField; -import org.apache.lucene.document.LegacyLongField; import org.apache.lucene.document.LongPoint; import org.apache.lucene.document.NumericDocValuesField; import org.apache.lucene.document.SortedDocValuesField; @@ -57,9 +55,12 @@ import org.apache.lucene.document.SortedSetDocValuesField; import org.apache.lucene.document.StringField; import org.apache.lucene.document.TextField; import org.apache.lucene.index.IndexWriterConfig.OpenMode; +import org.apache.lucene.legacy.LegacyIntField; +import org.apache.lucene.legacy.LegacyLongField; +import org.apache.lucene.legacy.LegacyNumericRangeQuery; +import org.apache.lucene.legacy.LegacyNumericUtils; import org.apache.lucene.search.DocIdSetIterator; import org.apache.lucene.search.IndexSearcher; -import org.apache.lucene.search.LegacyNumericRangeQuery; import org.apache.lucene.search.ScoreDoc; import org.apache.lucene.search.TermQuery; import org.apache.lucene.store.BaseDirectoryWrapper; @@ -72,7 +73,6 @@ import org.apache.lucene.util.Bits; import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.IOUtils; import org.apache.lucene.util.InfoStream; -import org.apache.lucene.util.LegacyNumericUtils; import org.apache.lucene.util.LineFileDocs; import org.apache.lucene.util.LuceneTestCase; import org.apache.lucene.util.TestUtil; diff --git a/lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestLegacyField.java b/lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestLegacyField.java new file mode 100644 index 00000000000..65ff0969d9d --- /dev/null +++ b/lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestLegacyField.java @@ -0,0 +1,196 @@ +/* + * 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.StringReader; + +import org.apache.lucene.analysis.CannedTokenStream; +import org.apache.lucene.analysis.Token; +import org.apache.lucene.document.Field; +import org.apache.lucene.util.BytesRef; +import org.apache.lucene.util.LuceneTestCase; + +public class TestLegacyField extends LuceneTestCase { + + public void testLegacyDoubleField() throws Exception { + Field fields[] = new Field[] { + new LegacyDoubleField("foo", 5d, Field.Store.NO), + new LegacyDoubleField("foo", 5d, Field.Store.YES) + }; + + for (Field field : fields) { + trySetBoost(field); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + field.setDoubleValue(6d); // ok + trySetIntValue(field); + trySetFloatValue(field); + trySetLongValue(field); + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(6d, field.numericValue().doubleValue(), 0.0d); + } + } + + public void testLegacyFloatField() throws Exception { + Field fields[] = new Field[] { + new LegacyFloatField("foo", 5f, Field.Store.NO), + new LegacyFloatField("foo", 5f, Field.Store.YES) + }; + + for (Field field : fields) { + trySetBoost(field); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + trySetDoubleValue(field); + trySetIntValue(field); + field.setFloatValue(6f); // ok + trySetLongValue(field); + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(6f, field.numericValue().floatValue(), 0.0f); + } + } + + public void testLegacyIntField() throws Exception { + Field fields[] = new Field[] { + new LegacyIntField("foo", 5, Field.Store.NO), + new LegacyIntField("foo", 5, Field.Store.YES) + }; + + for (Field field : fields) { + trySetBoost(field); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + trySetDoubleValue(field); + field.setIntValue(6); // ok + trySetFloatValue(field); + trySetLongValue(field); + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(6, field.numericValue().intValue()); + } + } + + public void testLegacyLongField() throws Exception { + Field fields[] = new Field[] { + new LegacyLongField("foo", 5L, Field.Store.NO), + new LegacyLongField("foo", 5L, Field.Store.YES) + }; + + for (Field field : fields) { + trySetBoost(field); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + trySetDoubleValue(field); + trySetIntValue(field); + trySetFloatValue(field); + field.setLongValue(6); // ok + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(6L, field.numericValue().longValue()); + } + } + + private void trySetByteValue(Field f) { + expectThrows(IllegalArgumentException.class, () -> { + f.setByteValue((byte) 10); + }); + } + + private void trySetBytesValue(Field f) { + expectThrows(IllegalArgumentException.class, () -> { + f.setBytesValue(new byte[] { 5, 5 }); + }); + } + + private void trySetBytesRefValue(Field f) { + expectThrows(IllegalArgumentException.class, () -> { + f.setBytesValue(new BytesRef("bogus")); + }); + } + + private void trySetDoubleValue(Field f) { + expectThrows(IllegalArgumentException.class, () -> { + f.setDoubleValue(Double.MAX_VALUE); + }); + } + + private void trySetIntValue(Field f) { + expectThrows(IllegalArgumentException.class, () -> { + f.setIntValue(Integer.MAX_VALUE); + }); + } + + private void trySetLongValue(Field f) { + expectThrows(IllegalArgumentException.class, () -> { + f.setLongValue(Long.MAX_VALUE); + }); + } + + private void trySetFloatValue(Field f) { + expectThrows(IllegalArgumentException.class, () -> { + f.setFloatValue(Float.MAX_VALUE); + }); + } + + private void trySetReaderValue(Field f) { + expectThrows(IllegalArgumentException.class, () -> { + f.setReaderValue(new StringReader("BOO!")); + }); + } + + private void trySetShortValue(Field f) { + expectThrows(IllegalArgumentException.class, () -> { + f.setShortValue(Short.MAX_VALUE); + }); + } + + private void trySetStringValue(Field f) { + expectThrows(IllegalArgumentException.class, () -> { + f.setStringValue("BOO!"); + }); + } + + private void trySetTokenStreamValue(Field f) { + expectThrows(IllegalArgumentException.class, () -> { + f.setTokenStream(new CannedTokenStream(new Token("foo", 0, 3))); + }); + } + + private void trySetBoost(Field f) { + expectThrows(IllegalArgumentException.class, () -> { + f.setBoost(5.0f); + }); + } +} diff --git a/lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestLegacyFieldReuse.java b/lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestLegacyFieldReuse.java new file mode 100644 index 00000000000..9335290247d --- /dev/null +++ b/lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestLegacyFieldReuse.java @@ -0,0 +1,81 @@ +/* + * 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 org.apache.lucene.analysis.BaseTokenStreamTestCase; +import org.apache.lucene.analysis.CannedTokenStream; +import org.apache.lucene.analysis.Token; +import org.apache.lucene.analysis.TokenStream; +import org.apache.lucene.document.Field; +import org.apache.lucene.legacy.LegacyIntField; +import org.apache.lucene.legacy.LegacyNumericTokenStream; +import org.apache.lucene.legacy.LegacyNumericUtils; +import org.apache.lucene.legacy.LegacyNumericTokenStream.LegacyNumericTermAttribute; + +/** test tokenstream reuse by DefaultIndexingChain */ +public class TestLegacyFieldReuse extends BaseTokenStreamTestCase { + + public void testNumericReuse() throws IOException { + LegacyIntField legacyIntField = new LegacyIntField("foo", 5, Field.Store.NO); + + // passing null + TokenStream ts = legacyIntField.tokenStream(null, null); + assertTrue(ts instanceof LegacyNumericTokenStream); + assertEquals(LegacyNumericUtils.PRECISION_STEP_DEFAULT_32, ((LegacyNumericTokenStream)ts).getPrecisionStep()); + assertNumericContents(5, ts); + + // now reuse previous stream + legacyIntField = new LegacyIntField("foo", 20, Field.Store.NO); + TokenStream ts2 = legacyIntField.tokenStream(null, ts); + assertSame(ts, ts2); + assertNumericContents(20, ts); + + // pass a bogus stream and ensure it's still ok + legacyIntField = new LegacyIntField("foo", 2343, Field.Store.NO); + TokenStream bogus = new CannedTokenStream(new Token("bogus", 0, 5)); + ts = legacyIntField.tokenStream(null, bogus); + assertNotSame(bogus, ts); + assertNumericContents(2343, ts); + + // pass another bogus stream (numeric, but different precision step!) + legacyIntField = new LegacyIntField("foo", 42, Field.Store.NO); + assert 3 != LegacyNumericUtils.PRECISION_STEP_DEFAULT; + bogus = new LegacyNumericTokenStream(3); + ts = legacyIntField.tokenStream(null, bogus); + assertNotSame(bogus, ts); + assertNumericContents(42, ts); + } + + private void assertNumericContents(int value, TokenStream ts) throws IOException { + assertTrue(ts instanceof LegacyNumericTokenStream); + LegacyNumericTermAttribute numericAtt = ts.getAttribute(LegacyNumericTermAttribute.class); + ts.reset(); + boolean seen = false; + while (ts.incrementToken()) { + if (numericAtt.getShift() == 0) { + assertEquals(value, numericAtt.getRawValue()); + seen = true; + } + } + ts.end(); + ts.close(); + assertTrue(seen); + } +} diff --git a/lucene/core/src/test/org/apache/lucene/util/TestLegacyNumericUtils.java b/lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestLegacyNumericUtils.java similarity index 98% rename from lucene/core/src/test/org/apache/lucene/util/TestLegacyNumericUtils.java rename to lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestLegacyNumericUtils.java index 2fb20d11db7..8607efdc893 100644 --- a/lucene/core/src/test/org/apache/lucene/util/TestLegacyNumericUtils.java +++ b/lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestLegacyNumericUtils.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.apache.lucene.util; +package org.apache.lucene.legacy; import java.util.Arrays; @@ -22,6 +22,13 @@ import java.util.Collections; import java.util.Iterator; import java.util.Random; +import org.apache.lucene.legacy.LegacyNumericUtils; +import org.apache.lucene.util.BytesRefBuilder; +import org.apache.lucene.util.FixedBitSet; +import org.apache.lucene.util.LongBitSet; +import org.apache.lucene.util.LuceneTestCase; +import org.apache.lucene.util.NumericUtils; + public class TestLegacyNumericUtils extends LuceneTestCase { public void testLongConversionAndOrdering() throws Exception { diff --git a/lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestLegacyTerms.java b/lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestLegacyTerms.java new file mode 100644 index 00000000000..27fae15e916 --- /dev/null +++ b/lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestLegacyTerms.java @@ -0,0 +1,164 @@ +/* + * 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.Field; +import org.apache.lucene.index.IndexReader; +import org.apache.lucene.index.MultiFields; +import org.apache.lucene.index.RandomIndexWriter; +import org.apache.lucene.index.Terms; +import org.apache.lucene.index.TermsEnum; +import org.apache.lucene.legacy.LegacyDoubleField; +import org.apache.lucene.legacy.LegacyFloatField; +import org.apache.lucene.legacy.LegacyIntField; +import org.apache.lucene.legacy.LegacyLongField; +import org.apache.lucene.legacy.LegacyNumericUtils; +import org.apache.lucene.store.Directory; +import org.apache.lucene.util.LuceneTestCase; +import org.apache.lucene.util.NumericUtils; + +public class TestLegacyTerms extends LuceneTestCase { + + public void testEmptyIntFieldMinMax() throws Exception { + assertNull(LegacyNumericUtils.getMinInt(EMPTY_TERMS)); + assertNull(LegacyNumericUtils.getMaxInt(EMPTY_TERMS)); + } + + public void testIntFieldMinMax() throws Exception { + Directory dir = newDirectory(); + RandomIndexWriter w = new RandomIndexWriter(random(), dir); + int numDocs = atLeast(100); + int minValue = Integer.MAX_VALUE; + int maxValue = Integer.MIN_VALUE; + for(int i=0;iupper) { - int a=lower; lower=upper; upper=a; - } - final BytesRef lowerBytes, upperBytes; - BytesRefBuilder b = new BytesRefBuilder(); - LegacyNumericUtils.intToPrefixCoded(lower, 0, b); - lowerBytes = b.toBytesRef(); - LegacyNumericUtils.intToPrefixCoded(upper, 0, b); - upperBytes = b.toBytesRef(); - - // test inclusive range - LegacyNumericRangeQuery tq= LegacyNumericRangeQuery.newIntRange(field, precisionStep, lower, upper, true, true); - TermRangeQuery cq=new TermRangeQuery(field, lowerBytes, upperBytes, true, true); - TopDocs tTopDocs = searcher.search(tq, 1); - TopDocs cTopDocs = searcher.search(cq, 1); - assertEquals("Returned count for LegacyNumericRangeQuery and TermRangeQuery must be equal", cTopDocs.totalHits, tTopDocs.totalHits ); - totalTermCountT += termCountT = countTerms(tq); - totalTermCountC += termCountC = countTerms(cq); - checkTermCounts(precisionStep, termCountT, termCountC); - // test exclusive range - tq= LegacyNumericRangeQuery.newIntRange(field, precisionStep, lower, upper, false, false); - cq=new TermRangeQuery(field, lowerBytes, upperBytes, false, false); - tTopDocs = searcher.search(tq, 1); - cTopDocs = searcher.search(cq, 1); - assertEquals("Returned count for LegacyNumericRangeQuery and TermRangeQuery must be equal", cTopDocs.totalHits, tTopDocs.totalHits ); - totalTermCountT += termCountT = countTerms(tq); - totalTermCountC += termCountC = countTerms(cq); - checkTermCounts(precisionStep, termCountT, termCountC); - // test left exclusive range - tq= LegacyNumericRangeQuery.newIntRange(field, precisionStep, lower, upper, false, true); - cq=new TermRangeQuery(field, lowerBytes, upperBytes, false, true); - tTopDocs = searcher.search(tq, 1); - cTopDocs = searcher.search(cq, 1); - assertEquals("Returned count for LegacyNumericRangeQuery and TermRangeQuery must be equal", cTopDocs.totalHits, tTopDocs.totalHits ); - totalTermCountT += termCountT = countTerms(tq); - totalTermCountC += termCountC = countTerms(cq); - checkTermCounts(precisionStep, termCountT, termCountC); - // test right exclusive range - tq= LegacyNumericRangeQuery.newIntRange(field, precisionStep, lower, upper, true, false); - cq=new TermRangeQuery(field, lowerBytes, upperBytes, true, false); - tTopDocs = searcher.search(tq, 1); - cTopDocs = searcher.search(cq, 1); - assertEquals("Returned count for LegacyNumericRangeQuery and TermRangeQuery must be equal", cTopDocs.totalHits, tTopDocs.totalHits ); - totalTermCountT += termCountT = countTerms(tq); - totalTermCountC += termCountC = countTerms(cq); - checkTermCounts(precisionStep, termCountT, termCountC); - } - - checkTermCounts(precisionStep, totalTermCountT, totalTermCountC); - if (VERBOSE && precisionStep != Integer.MAX_VALUE) { - System.out.println("Average number of terms during random search on '" + field + "':"); - System.out.println(" Numeric query: " + (((double)totalTermCountT)/(num * 4))); - System.out.println(" Classical query: " + (((double)totalTermCountC)/(num * 4))); - } - } - - @Test - public void testEmptyEnums() throws Exception { - int count=3000; - int lower=(distance*3/2)+startOffset, upper=lower + count*distance + (distance/3); - // test empty enum - assert lower < upper; - assertTrue(0 < countTerms(LegacyNumericRangeQuery.newIntRange("field4", 4, lower, upper, true, true))); - assertEquals(0, countTerms(LegacyNumericRangeQuery.newIntRange("field4", 4, upper, lower, true, true))); - // test empty enum outside of bounds - lower = distance*noDocs+startOffset; - upper = 2 * lower; - assert lower < upper; - assertEquals(0, countTerms(LegacyNumericRangeQuery.newIntRange("field4", 4, lower, upper, true, true))); - } - - private int countTerms(MultiTermQuery q) throws Exception { - final Terms terms = MultiFields.getTerms(reader, q.getField()); - if (terms == null) - return 0; - final TermsEnum termEnum = q.getTermsEnum(terms); - assertNotNull(termEnum); - int count = 0; - BytesRef cur, last = null; - while ((cur = termEnum.next()) != null) { - count++; - if (last != null) { - assertTrue(last.compareTo(cur) < 0); - } - last = BytesRef.deepCopyOf(cur); - } - // LUCENE-3314: the results after next() already returned null are undefined, - // assertNull(termEnum.next()); - return count; - } - - private void checkTermCounts(int precisionStep, int termCountT, int termCountC) { - if (precisionStep == Integer.MAX_VALUE) { - assertEquals("Number of terms should be equal for unlimited precStep", termCountC, termCountT); - } else { - assertTrue("Number of terms for NRQ should be <= compared to classical TRQ", termCountT <= termCountC); - } - } - - @Test - public void testRandomTrieAndClassicRangeQuery_8bit() throws Exception { - testRandomTrieAndClassicRangeQuery(8); - } - - @Test - public void testRandomTrieAndClassicRangeQuery_4bit() throws Exception { - testRandomTrieAndClassicRangeQuery(4); - } - - @Test - public void testRandomTrieAndClassicRangeQuery_2bit() throws Exception { - testRandomTrieAndClassicRangeQuery(2); - } - - @Test - public void testRandomTrieAndClassicRangeQuery_NoTrie() throws Exception { - testRandomTrieAndClassicRangeQuery(Integer.MAX_VALUE); - } - private void testRangeSplit(int precisionStep) throws Exception { String field="ascfield"+precisionStep; // 10 random tests diff --git a/lucene/core/src/test/org/apache/lucene/search/TestNumericRangeQuery64.java b/lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestNumericRangeQuery64.java similarity index 72% rename from lucene/core/src/test/org/apache/lucene/search/TestNumericRangeQuery64.java rename to lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestNumericRangeQuery64.java index 7f63fbc0136..b3ce55aa66d 100644 --- a/lucene/core/src/test/org/apache/lucene/search/TestNumericRangeQuery64.java +++ b/lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestNumericRangeQuery64.java @@ -14,28 +14,26 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.apache.lucene.search; +package org.apache.lucene.legacy; import org.apache.lucene.analysis.MockAnalyzer; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; -import org.apache.lucene.document.FieldType; -import org.apache.lucene.document.LegacyDoubleField; -import org.apache.lucene.document.LegacyLongField; import org.apache.lucene.index.DirectoryReader; import org.apache.lucene.index.IndexReader; -import org.apache.lucene.index.MultiFields; import org.apache.lucene.index.RandomIndexWriter; -import org.apache.lucene.index.Terms; -import org.apache.lucene.index.TermsEnum; +import org.apache.lucene.search.BooleanQuery; +import org.apache.lucene.search.IndexSearcher; +import org.apache.lucene.search.MultiTermQuery; +import org.apache.lucene.search.Query; +import org.apache.lucene.search.QueryUtils; +import org.apache.lucene.search.ScoreDoc; +import org.apache.lucene.search.Sort; +import org.apache.lucene.search.TopDocs; import org.apache.lucene.store.Directory; -import org.apache.lucene.util.BytesRef; -import org.apache.lucene.util.BytesRefBuilder; -import org.apache.lucene.util.LegacyNumericUtils; import org.apache.lucene.util.LuceneTestCase; import org.apache.lucene.util.NumericUtils; -import org.apache.lucene.util.TestLegacyNumericUtils; import org.apache.lucene.util.TestUtil; import org.junit.AfterClass; import org.junit.BeforeClass; @@ -63,37 +61,37 @@ public class TestNumericRangeQuery64 extends LuceneTestCase { .setMaxBufferedDocs(TestUtil.nextInt(random(), 100, 1000)) .setMergePolicy(newLogMergePolicy())); - final FieldType storedLong = new FieldType(LegacyLongField.TYPE_NOT_STORED); + final LegacyFieldType storedLong = new LegacyFieldType(LegacyLongField.TYPE_NOT_STORED); storedLong.setStored(true); storedLong.freeze(); - final FieldType storedLong8 = new FieldType(storedLong); + final LegacyFieldType storedLong8 = new LegacyFieldType(storedLong); storedLong8.setNumericPrecisionStep(8); - final FieldType storedLong4 = new FieldType(storedLong); + final LegacyFieldType storedLong4 = new LegacyFieldType(storedLong); storedLong4.setNumericPrecisionStep(4); - final FieldType storedLong6 = new FieldType(storedLong); + final LegacyFieldType storedLong6 = new LegacyFieldType(storedLong); storedLong6.setNumericPrecisionStep(6); - final FieldType storedLong2 = new FieldType(storedLong); + final LegacyFieldType storedLong2 = new LegacyFieldType(storedLong); storedLong2.setNumericPrecisionStep(2); - final FieldType storedLongNone = new FieldType(storedLong); + final LegacyFieldType storedLongNone = new LegacyFieldType(storedLong); storedLongNone.setNumericPrecisionStep(Integer.MAX_VALUE); - final FieldType unstoredLong = LegacyLongField.TYPE_NOT_STORED; + final LegacyFieldType unstoredLong = LegacyLongField.TYPE_NOT_STORED; - final FieldType unstoredLong8 = new FieldType(unstoredLong); + final LegacyFieldType unstoredLong8 = new LegacyFieldType(unstoredLong); unstoredLong8.setNumericPrecisionStep(8); - final FieldType unstoredLong6 = new FieldType(unstoredLong); + final LegacyFieldType unstoredLong6 = new LegacyFieldType(unstoredLong); unstoredLong6.setNumericPrecisionStep(6); - final FieldType unstoredLong4 = new FieldType(unstoredLong); + final LegacyFieldType unstoredLong4 = new LegacyFieldType(unstoredLong); unstoredLong4.setNumericPrecisionStep(4); - final FieldType unstoredLong2 = new FieldType(unstoredLong); + final LegacyFieldType unstoredLong2 = new LegacyFieldType(unstoredLong); unstoredLong2.setNumericPrecisionStep(2); LegacyLongField @@ -374,137 +372,6 @@ public class TestNumericRangeQuery64 extends LuceneTestCase { dir.close(); } - private void testRandomTrieAndClassicRangeQuery(int precisionStep) throws Exception { - String field="field"+precisionStep; - int totalTermCountT=0,totalTermCountC=0,termCountT,termCountC; - int num = TestUtil.nextInt(random(), 10, 20); - for (int i = 0; i < num; i++) { - long lower=(long)(random().nextDouble()*noDocs*distance)+startOffset; - long upper=(long)(random().nextDouble()*noDocs*distance)+startOffset; - if (lower>upper) { - long a=lower; lower=upper; upper=a; - } - final BytesRef lowerBytes, upperBytes; - BytesRefBuilder b = new BytesRefBuilder(); - LegacyNumericUtils.longToPrefixCoded(lower, 0, b); - lowerBytes = b.toBytesRef(); - LegacyNumericUtils.longToPrefixCoded(upper, 0, b); - upperBytes = b.toBytesRef(); - - // test inclusive range - LegacyNumericRangeQuery tq= LegacyNumericRangeQuery.newLongRange(field, precisionStep, lower, upper, true, true); - TermRangeQuery cq=new TermRangeQuery(field, lowerBytes, upperBytes, true, true); - TopDocs tTopDocs = searcher.search(tq, 1); - TopDocs cTopDocs = searcher.search(cq, 1); - assertEquals("Returned count for LegacyNumericRangeQuery and TermRangeQuery must be equal", cTopDocs.totalHits, tTopDocs.totalHits ); - totalTermCountT += termCountT = countTerms(tq); - totalTermCountC += termCountC = countTerms(cq); - checkTermCounts(precisionStep, termCountT, termCountC); - // test exclusive range - tq= LegacyNumericRangeQuery.newLongRange(field, precisionStep, lower, upper, false, false); - cq=new TermRangeQuery(field, lowerBytes, upperBytes, false, false); - tTopDocs = searcher.search(tq, 1); - cTopDocs = searcher.search(cq, 1); - assertEquals("Returned count for LegacyNumericRangeQuery and TermRangeQuery must be equal", cTopDocs.totalHits, tTopDocs.totalHits ); - totalTermCountT += termCountT = countTerms(tq); - totalTermCountC += termCountC = countTerms(cq); - checkTermCounts(precisionStep, termCountT, termCountC); - // test left exclusive range - tq= LegacyNumericRangeQuery.newLongRange(field, precisionStep, lower, upper, false, true); - cq=new TermRangeQuery(field, lowerBytes, upperBytes, false, true); - tTopDocs = searcher.search(tq, 1); - cTopDocs = searcher.search(cq, 1); - assertEquals("Returned count for LegacyNumericRangeQuery and TermRangeQuery must be equal", cTopDocs.totalHits, tTopDocs.totalHits ); - totalTermCountT += termCountT = countTerms(tq); - totalTermCountC += termCountC = countTerms(cq); - checkTermCounts(precisionStep, termCountT, termCountC); - // test right exclusive range - tq= LegacyNumericRangeQuery.newLongRange(field, precisionStep, lower, upper, true, false); - cq=new TermRangeQuery(field, lowerBytes, upperBytes, true, false); - tTopDocs = searcher.search(tq, 1); - cTopDocs = searcher.search(cq, 1); - assertEquals("Returned count for LegacyNumericRangeQuery and TermRangeQuery must be equal", cTopDocs.totalHits, tTopDocs.totalHits ); - totalTermCountT += termCountT = countTerms(tq); - totalTermCountC += termCountC = countTerms(cq); - checkTermCounts(precisionStep, termCountT, termCountC); - } - - checkTermCounts(precisionStep, totalTermCountT, totalTermCountC); - if (VERBOSE && precisionStep != Integer.MAX_VALUE) { - System.out.println("Average number of terms during random search on '" + field + "':"); - System.out.println(" Numeric query: " + (((double)totalTermCountT)/(num * 4))); - System.out.println(" Classical query: " + (((double)totalTermCountC)/(num * 4))); - } - } - - @Test - public void testEmptyEnums() throws Exception { - int count=3000; - long lower=(distance*3/2)+startOffset, upper=lower + count*distance + (distance/3); - // test empty enum - assert lower < upper; - assertTrue(0 < countTerms(LegacyNumericRangeQuery.newLongRange("field4", 4, lower, upper, true, true))); - assertEquals(0, countTerms(LegacyNumericRangeQuery.newLongRange("field4", 4, upper, lower, true, true))); - // test empty enum outside of bounds - lower = distance*noDocs+startOffset; - upper = 2L * lower; - assert lower < upper; - assertEquals(0, countTerms(LegacyNumericRangeQuery.newLongRange("field4", 4, lower, upper, true, true))); - } - - private int countTerms(MultiTermQuery q) throws Exception { - final Terms terms = MultiFields.getTerms(reader, q.getField()); - if (terms == null) - return 0; - final TermsEnum termEnum = q.getTermsEnum(terms); - assertNotNull(termEnum); - int count = 0; - BytesRef cur, last = null; - while ((cur = termEnum.next()) != null) { - count++; - if (last != null) { - assertTrue(last.compareTo(cur) < 0); - } - last = BytesRef.deepCopyOf(cur); - } - // LUCENE-3314: the results after next() already returned null are undefined, - // assertNull(termEnum.next()); - return count; - } - - private void checkTermCounts(int precisionStep, int termCountT, int termCountC) { - if (precisionStep == Integer.MAX_VALUE) { - assertEquals("Number of terms should be equal for unlimited precStep", termCountC, termCountT); - } else { - assertTrue("Number of terms for NRQ should be <= compared to classical TRQ", termCountT <= termCountC); - } - } - - @Test - public void testRandomTrieAndClassicRangeQuery_8bit() throws Exception { - testRandomTrieAndClassicRangeQuery(8); - } - - @Test - public void testRandomTrieAndClassicRangeQuery_6bit() throws Exception { - testRandomTrieAndClassicRangeQuery(6); - } - - @Test - public void testRandomTrieAndClassicRangeQuery_4bit() throws Exception { - testRandomTrieAndClassicRangeQuery(4); - } - - @Test - public void testRandomTrieAndClassicRangeQuery_2bit() throws Exception { - testRandomTrieAndClassicRangeQuery(2); - } - - @Test - public void testRandomTrieAndClassicRangeQuery_NoTrie() throws Exception { - testRandomTrieAndClassicRangeQuery(Integer.MAX_VALUE); - } - private void testRangeSplit(int precisionStep) throws Exception { String field="ascfield"+precisionStep; // 10 random tests diff --git a/lucene/core/src/test/org/apache/lucene/analysis/TestNumericTokenStream.java b/lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestNumericTokenStream.java similarity index 85% rename from lucene/core/src/test/org/apache/lucene/analysis/TestNumericTokenStream.java rename to lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestNumericTokenStream.java index dfaa20e5a2e..a507af09e0d 100644 --- a/lucene/core/src/test/org/apache/lucene/analysis/TestNumericTokenStream.java +++ b/lucene/backward-codecs/src/test/org/apache/lucene/legacy/TestNumericTokenStream.java @@ -14,15 +14,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.apache.lucene.analysis; +package org.apache.lucene.legacy; +import org.apache.lucene.util.AttributeImpl; import org.apache.lucene.util.BytesRef; -import org.apache.lucene.util.LegacyNumericUtils; -import org.apache.lucene.analysis.LegacyNumericTokenStream.LegacyNumericTermAttributeImpl; import org.apache.lucene.analysis.tokenattributes.TermToBytesRefAttribute; -import org.apache.lucene.analysis.tokenattributes.TestCharTermAttributeImpl; import org.apache.lucene.analysis.tokenattributes.TypeAttribute; +import org.apache.lucene.legacy.LegacyNumericTokenStream; +import org.apache.lucene.legacy.LegacyNumericUtils; +import org.apache.lucene.legacy.LegacyNumericTokenStream.LegacyNumericTermAttributeImpl; +import org.apache.lucene.analysis.BaseTokenStreamTestCase; import org.apache.lucene.analysis.tokenattributes.CharTermAttribute; import org.apache.lucene.analysis.tokenattributes.CharTermAttributeImpl; @@ -150,20 +152,37 @@ public class TestNumericTokenStream extends BaseTokenStreamTestCase { public void testAttributeClone() throws Exception { LegacyNumericTermAttributeImpl att = new LegacyNumericTermAttributeImpl(); att.init(lvalue, 64, 8, 0); // set some value, to make getBytesRef() work - LegacyNumericTermAttributeImpl copy = TestCharTermAttributeImpl.assertCloneIsEqual(att); + LegacyNumericTermAttributeImpl copy = assertCloneIsEqual(att); assertNotSame(att.getBytesRef(), copy.getBytesRef()); - LegacyNumericTermAttributeImpl copy2 = TestCharTermAttributeImpl.assertCopyIsEqual(att); + LegacyNumericTermAttributeImpl copy2 = assertCopyIsEqual(att); assertNotSame(att.getBytesRef(), copy2.getBytesRef()); // LUCENE-7027 test att.init(lvalue, 64, 8, 64); // Exhausted TokenStream -> should return empty BytesRef assertEquals(new BytesRef(), att.getBytesRef()); - copy = TestCharTermAttributeImpl.assertCloneIsEqual(att); + copy = assertCloneIsEqual(att); assertEquals(new BytesRef(), copy.getBytesRef()); assertNotSame(att.getBytesRef(), copy.getBytesRef()); - copy2 = TestCharTermAttributeImpl.assertCopyIsEqual(att); + copy2 = assertCopyIsEqual(att); assertEquals(new BytesRef(), copy2.getBytesRef()); assertNotSame(att.getBytesRef(), copy2.getBytesRef()); } + public static T assertCloneIsEqual(T att) { + @SuppressWarnings("unchecked") + T clone = (T) att.clone(); + assertEquals("Clone must be equal", att, clone); + assertEquals("Clone's hashcode must be equal", att.hashCode(), clone.hashCode()); + return clone; + } + + public static T assertCopyIsEqual(T att) throws Exception { + @SuppressWarnings("unchecked") + T copy = (T) att.getClass().newInstance(); + att.copyTo(copy); + assertEquals("Copied instance must be equal", att, copy); + assertEquals("Copied instance's hashcode must be equal", att.hashCode(), copy.hashCode()); + return copy; + } + } diff --git a/lucene/core/src/java/org/apache/lucene/document/Field.java b/lucene/core/src/java/org/apache/lucene/document/Field.java index 87986101f3b..8f5f8692d66 100644 --- a/lucene/core/src/java/org/apache/lucene/document/Field.java +++ b/lucene/core/src/java/org/apache/lucene/document/Field.java @@ -21,7 +21,6 @@ import java.io.IOException; import java.io.Reader; import org.apache.lucene.analysis.Analyzer; -import org.apache.lucene.analysis.LegacyNumericTokenStream; import org.apache.lucene.analysis.TokenStream; import org.apache.lucene.analysis.tokenattributes.BytesTermAttribute; import org.apache.lucene.analysis.tokenattributes.CharTermAttribute; @@ -426,9 +425,6 @@ public class Field implements IndexableField { if (type.indexOptions() == IndexOptions.NONE || !type.tokenized()) { throw new IllegalArgumentException("TokenStream fields must be indexed and tokenized"); } - if (type.numericType() != null) { - throw new IllegalArgumentException("cannot set private TokenStream on numeric fields"); - } this.tokenStream = tokenStream; } @@ -511,35 +507,6 @@ public class Field implements IndexableField { return null; } - final FieldType.LegacyNumericType numericType = fieldType().numericType(); - if (numericType != null) { - if (!(reuse instanceof LegacyNumericTokenStream && ((LegacyNumericTokenStream)reuse).getPrecisionStep() == type.numericPrecisionStep())) { - // lazy init the TokenStream as it is heavy to instantiate - // (attributes,...) if not needed (stored field loading) - reuse = new LegacyNumericTokenStream(type.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; - } - if (!fieldType().tokenized()) { if (stringValue() != null) { if (!(reuse instanceof StringTokenStream)) { diff --git a/lucene/core/src/java/org/apache/lucene/document/FieldType.java b/lucene/core/src/java/org/apache/lucene/document/FieldType.java index e0f058f520e..6f206a49ca7 100644 --- a/lucene/core/src/java/org/apache/lucene/document/FieldType.java +++ b/lucene/core/src/java/org/apache/lucene/document/FieldType.java @@ -22,30 +22,12 @@ import org.apache.lucene.index.DocValuesType; import org.apache.lucene.index.IndexOptions; import org.apache.lucene.index.IndexableFieldType; import org.apache.lucene.index.PointValues; -import org.apache.lucene.util.LegacyNumericUtils; /** * Describes the properties of a field. */ public class FieldType implements IndexableFieldType { - /** Data type of the numeric value - * @since 3.2 - * - * @deprecated Please switch to {@link org.apache.lucene.index.PointValues} instead - */ - @Deprecated - public enum LegacyNumericType { - /** 32-bit integer numeric type */ - INT, - /** 64-bit long numeric type */ - LONG, - /** 32-bit float numeric type */ - FLOAT, - /** 64-bit double numeric type */ - DOUBLE - } - private boolean stored; private boolean tokenized = true; private boolean storeTermVectors; @@ -54,9 +36,7 @@ public class FieldType implements IndexableFieldType { private boolean storeTermVectorPayloads; private boolean omitNorms; private IndexOptions indexOptions = IndexOptions.NONE; - private LegacyNumericType numericType; private boolean frozen; - private int numericPrecisionStep = LegacyNumericUtils.PRECISION_STEP_DEFAULT; private DocValuesType docValuesType = DocValuesType.NONE; private int dimensionCount; private int dimensionNumBytes; @@ -73,8 +53,6 @@ public class FieldType implements IndexableFieldType { this.storeTermVectorPayloads = ref.storeTermVectorPayloads(); this.omitNorms = ref.omitNorms(); this.indexOptions = ref.indexOptions(); - this.numericType = ref.numericType(); - this.numericPrecisionStep = ref.numericPrecisionStep(); this.docValuesType = ref.docValuesType(); this.dimensionCount = ref.dimensionCount; this.dimensionNumBytes = ref.dimensionNumBytes; @@ -297,70 +275,6 @@ public class FieldType implements IndexableFieldType { this.indexOptions = value; } - /** - * 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.search.LegacyNumericRangeQuery} can be used at - * search time. - *

    - * The default is null (no numeric type) - * @see #setNumericType(org.apache.lucene.document.FieldType.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. - *

    - * This has no effect if {@link #numericType()} returns null. - *

    - * The default is {@link org.apache.lucene.util.LegacyNumericUtils#PRECISION_STEP_DEFAULT} - * @see #setNumericPrecisionStep(int) - * - * @deprecated Please switch to {@link org.apache.lucene.index.PointValues} instead - */ - @Deprecated - public int numericPrecisionStep() { - return numericPrecisionStep; - } - /** * Enables points indexing. */ @@ -403,7 +317,7 @@ public class FieldType implements IndexableFieldType { /** Prints a Field for human consumption. */ @Override - public final String toString() { + public String toString() { StringBuilder result = new StringBuilder(); if (stored()) { result.append("stored"); @@ -434,12 +348,6 @@ public class FieldType implements IndexableFieldType { result.append(",indexOptions="); result.append(indexOptions); } - if (numericType != null) { - result.append(",numericType="); - result.append(numericType); - result.append(",numericPrecisionStep="); - result.append(numericPrecisionStep); - } } if (dimensionCount != 0) { if (result.length() > 0) { @@ -495,8 +403,6 @@ public class FieldType implements IndexableFieldType { result = prime * result + dimensionNumBytes; result = prime * result + ((docValuesType == null) ? 0 : docValuesType.hashCode()); result = prime * result + indexOptions.hashCode(); - result = prime * result + numericPrecisionStep; - result = prime * result + ((numericType == null) ? 0 : numericType.hashCode()); result = prime * result + (omitNorms ? 1231 : 1237); result = prime * result + (storeTermVectorOffsets ? 1231 : 1237); result = prime * result + (storeTermVectorPayloads ? 1231 : 1237); @@ -517,8 +423,6 @@ public class FieldType implements IndexableFieldType { if (dimensionNumBytes != other.dimensionNumBytes) return false; if (docValuesType != other.docValuesType) return false; if (indexOptions != other.indexOptions) return false; - if (numericPrecisionStep != other.numericPrecisionStep) return false; - if (numericType != other.numericType) return false; if (omitNorms != other.omitNorms) return false; if (storeTermVectorOffsets != other.storeTermVectorOffsets) return false; if (storeTermVectorPayloads != other.storeTermVectorPayloads) return false; diff --git a/lucene/core/src/test/org/apache/lucene/document/TestField.java b/lucene/core/src/test/org/apache/lucene/document/TestField.java index 92d6a832141..4ef7ffbcdcc 100644 --- a/lucene/core/src/test/org/apache/lucene/document/TestField.java +++ b/lucene/core/src/test/org/apache/lucene/document/TestField.java @@ -79,29 +79,7 @@ public class TestField extends LuceneTestCase { assertEquals("DoublePoint ", field.toString()); } - public void testLegacyDoubleField() throws Exception { - Field fields[] = new Field[] { - new LegacyDoubleField("foo", 5d, Field.Store.NO), - new LegacyDoubleField("foo", 5d, Field.Store.YES) - }; - for (Field field : fields) { - trySetBoost(field); - trySetByteValue(field); - trySetBytesValue(field); - trySetBytesRefValue(field); - field.setDoubleValue(6d); // ok - trySetIntValue(field); - trySetFloatValue(field); - trySetLongValue(field); - trySetReaderValue(field); - trySetShortValue(field); - trySetStringValue(field); - trySetTokenStreamValue(field); - - assertEquals(6d, field.numericValue().doubleValue(), 0.0d); - } - } public void testDoubleDocValuesField() throws Exception { DoubleDocValuesField field = new DoubleDocValuesField("foo", 5d); @@ -185,30 +163,6 @@ public class TestField extends LuceneTestCase { assertEquals("FloatPoint ", field.toString()); } - public void testLegacyFloatField() throws Exception { - Field fields[] = new Field[] { - new LegacyFloatField("foo", 5f, Field.Store.NO), - new LegacyFloatField("foo", 5f, Field.Store.YES) - }; - - for (Field field : fields) { - trySetBoost(field); - trySetByteValue(field); - trySetBytesValue(field); - trySetBytesRefValue(field); - trySetDoubleValue(field); - trySetIntValue(field); - field.setFloatValue(6f); // ok - trySetLongValue(field); - trySetReaderValue(field); - trySetShortValue(field); - trySetStringValue(field); - trySetTokenStreamValue(field); - - assertEquals(6f, field.numericValue().floatValue(), 0.0f); - } - } - public void testIntPoint() throws Exception { Field field = new IntPoint("foo", 5); @@ -253,30 +207,6 @@ public class TestField extends LuceneTestCase { assertEquals("IntPoint ", field.toString()); } - public void testLegacyIntField() throws Exception { - Field fields[] = new Field[] { - new LegacyIntField("foo", 5, Field.Store.NO), - new LegacyIntField("foo", 5, Field.Store.YES) - }; - - for (Field field : fields) { - trySetBoost(field); - trySetByteValue(field); - trySetBytesValue(field); - trySetBytesRefValue(field); - trySetDoubleValue(field); - field.setIntValue(6); // ok - trySetFloatValue(field); - trySetLongValue(field); - trySetReaderValue(field); - trySetShortValue(field); - trySetStringValue(field); - trySetTokenStreamValue(field); - - assertEquals(6, field.numericValue().intValue()); - } - } - public void testNumericDocValuesField() throws Exception { NumericDocValuesField field = new NumericDocValuesField("foo", 5L); @@ -340,30 +270,6 @@ public class TestField extends LuceneTestCase { assertEquals("LongPoint ", field.toString()); } - public void testLegacyLongField() throws Exception { - Field fields[] = new Field[] { - new LegacyLongField("foo", 5L, Field.Store.NO), - new LegacyLongField("foo", 5L, Field.Store.YES) - }; - - for (Field field : fields) { - trySetBoost(field); - trySetByteValue(field); - trySetBytesValue(field); - trySetBytesRefValue(field); - trySetDoubleValue(field); - trySetIntValue(field); - trySetFloatValue(field); - field.setLongValue(6); // ok - trySetReaderValue(field); - trySetShortValue(field); - trySetStringValue(field); - trySetTokenStreamValue(field); - - assertEquals(6L, field.numericValue().longValue()); - } - } - public void testSortedBytesDocValuesField() throws Exception { SortedDocValuesField field = new SortedDocValuesField("foo", new BytesRef("bar")); diff --git a/lucene/core/src/test/org/apache/lucene/document/TestFieldType.java b/lucene/core/src/test/org/apache/lucene/document/TestFieldType.java index da76f40fe71..9214cb9f844 100644 --- a/lucene/core/src/test/org/apache/lucene/document/TestFieldType.java +++ b/lucene/core/src/test/org/apache/lucene/document/TestFieldType.java @@ -18,7 +18,6 @@ package org.apache.lucene.document; import java.lang.reflect.Method; -import org.apache.lucene.document.FieldType.LegacyNumericType; import org.apache.lucene.index.DocValuesType; import org.apache.lucene.index.IndexOptions; import org.apache.lucene.index.PointValues; @@ -58,14 +57,6 @@ public class TestFieldType extends LuceneTestCase { ft7.setOmitNorms(true); assertFalse(ft7.equals(ft)); - FieldType ft8 = new FieldType(); - ft8.setNumericType(LegacyNumericType.DOUBLE); - assertFalse(ft8.equals(ft)); - - FieldType ft9 = new FieldType(); - ft9.setNumericPrecisionStep(3); - assertFalse(ft9.equals(ft)); - FieldType ft10 = new FieldType(); ft10.setStoreTermVectors(true); assertFalse(ft10.equals(ft)); diff --git a/lucene/core/src/test/org/apache/lucene/index/TestFieldReuse.java b/lucene/core/src/test/org/apache/lucene/index/TestFieldReuse.java index b36cfefa9ff..977df3da618 100644 --- a/lucene/core/src/test/org/apache/lucene/index/TestFieldReuse.java +++ b/lucene/core/src/test/org/apache/lucene/index/TestFieldReuse.java @@ -24,16 +24,12 @@ import java.util.Collections; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.analysis.BaseTokenStreamTestCase; import org.apache.lucene.analysis.CannedTokenStream; -import org.apache.lucene.analysis.LegacyNumericTokenStream.LegacyNumericTermAttribute; -import org.apache.lucene.analysis.LegacyNumericTokenStream; import org.apache.lucene.analysis.Token; import org.apache.lucene.analysis.TokenStream; import org.apache.lucene.document.Field; -import org.apache.lucene.document.LegacyIntField; import org.apache.lucene.document.StringField; import org.apache.lucene.store.Directory; import org.apache.lucene.util.BytesRef; -import org.apache.lucene.util.LegacyNumericUtils; /** test tokenstream reuse by DefaultIndexingChain */ public class TestFieldReuse extends BaseTokenStreamTestCase { @@ -61,7 +57,7 @@ public class TestFieldReuse extends BaseTokenStreamTestCase { // pass a bogus stream and ensure it's still ok stringField = new StringField("foo", "beer", Field.Store.NO); - TokenStream bogus = new LegacyNumericTokenStream(); + TokenStream bogus = new CannedTokenStream(); ts = stringField.tokenStream(null, bogus); assertNotSame(ts, bogus); assertTokenStreamContents(ts, @@ -71,37 +67,6 @@ public class TestFieldReuse extends BaseTokenStreamTestCase { ); } - public void testNumericReuse() throws IOException { - LegacyIntField legacyIntField = new LegacyIntField("foo", 5, Field.Store.NO); - - // passing null - TokenStream ts = legacyIntField.tokenStream(null, null); - assertTrue(ts instanceof LegacyNumericTokenStream); - assertEquals(LegacyNumericUtils.PRECISION_STEP_DEFAULT_32, ((LegacyNumericTokenStream)ts).getPrecisionStep()); - assertNumericContents(5, ts); - - // now reuse previous stream - legacyIntField = new LegacyIntField("foo", 20, Field.Store.NO); - TokenStream ts2 = legacyIntField.tokenStream(null, ts); - assertSame(ts, ts2); - assertNumericContents(20, ts); - - // pass a bogus stream and ensure it's still ok - legacyIntField = new LegacyIntField("foo", 2343, Field.Store.NO); - TokenStream bogus = new CannedTokenStream(new Token("bogus", 0, 5)); - ts = legacyIntField.tokenStream(null, bogus); - assertNotSame(bogus, ts); - assertNumericContents(2343, ts); - - // pass another bogus stream (numeric, but different precision step!) - legacyIntField = new LegacyIntField("foo", 42, Field.Store.NO); - assert 3 != LegacyNumericUtils.PRECISION_STEP_DEFAULT; - bogus = new LegacyNumericTokenStream(3); - ts = legacyIntField.tokenStream(null, bogus); - assertNotSame(bogus, ts); - assertNumericContents(42, ts); - } - static class MyField implements IndexableField { TokenStream lastSeen; TokenStream lastReturned; @@ -163,20 +128,4 @@ public class TestFieldReuse extends BaseTokenStreamTestCase { iw.close(); dir.close(); } - - private void assertNumericContents(int value, TokenStream ts) throws IOException { - assertTrue(ts instanceof LegacyNumericTokenStream); - LegacyNumericTermAttribute numericAtt = ts.getAttribute(LegacyNumericTermAttribute.class); - ts.reset(); - boolean seen = false; - while (ts.incrementToken()) { - if (numericAtt.getShift() == 0) { - assertEquals(value, numericAtt.getRawValue()); - seen = true; - } - } - ts.end(); - ts.close(); - assertTrue(seen); - } } diff --git a/lucene/core/src/test/org/apache/lucene/index/TestTerms.java b/lucene/core/src/test/org/apache/lucene/index/TestTerms.java index 0ee34473607..e8871dcb769 100644 --- a/lucene/core/src/test/org/apache/lucene/index/TestTerms.java +++ b/lucene/core/src/test/org/apache/lucene/index/TestTerms.java @@ -18,17 +18,11 @@ package org.apache.lucene.index; import org.apache.lucene.analysis.CannedBinaryTokenStream; import org.apache.lucene.document.Document; -import org.apache.lucene.document.LegacyDoubleField; import org.apache.lucene.document.Field; -import org.apache.lucene.document.LegacyFloatField; -import org.apache.lucene.document.LegacyIntField; -import org.apache.lucene.document.LegacyLongField; import org.apache.lucene.document.TextField; import org.apache.lucene.store.Directory; import org.apache.lucene.util.BytesRef; -import org.apache.lucene.util.LegacyNumericUtils; import org.apache.lucene.util.LuceneTestCase; -import org.apache.lucene.util.NumericUtils; import org.apache.lucene.util.TestUtil; public class TestTerms extends LuceneTestCase { @@ -88,132 +82,4 @@ public class TestTerms extends LuceneTestCase { w.close(); dir.close(); } - - public void testEmptyIntFieldMinMax() throws Exception { - assertNull(LegacyNumericUtils.getMinInt(EMPTY_TERMS)); - assertNull(LegacyNumericUtils.getMaxInt(EMPTY_TERMS)); - } - - public void testIntFieldMinMax() throws Exception { - Directory dir = newDirectory(); - RandomIndexWriter w = new RandomIndexWriter(random(), dir); - int numDocs = atLeast(100); - int minValue = Integer.MAX_VALUE; - int maxValue = Integer.MIN_VALUE; - for(int i=0;i + @@ -34,13 +35,14 @@ - + - + diff --git a/lucene/join/src/java/org/apache/lucene/search/join/DocValuesTermsCollector.java b/lucene/join/src/java/org/apache/lucene/search/join/DocValuesTermsCollector.java index a9b11ed7008..4bb692a50da 100644 --- a/lucene/join/src/java/org/apache/lucene/search/join/DocValuesTermsCollector.java +++ b/lucene/join/src/java/org/apache/lucene/search/join/DocValuesTermsCollector.java @@ -19,8 +19,6 @@ package org.apache.lucene.search.join; import java.io.IOException; import java.util.function.LongConsumer; -import org.apache.lucene.document.FieldType; -import org.apache.lucene.document.FieldType.LegacyNumericType; import org.apache.lucene.index.BinaryDocValues; import org.apache.lucene.index.DocValues; import org.apache.lucene.index.LeafReader; @@ -28,10 +26,11 @@ import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.index.NumericDocValues; import org.apache.lucene.index.SortedNumericDocValues; import org.apache.lucene.index.SortedSetDocValues; +import org.apache.lucene.legacy.LegacyNumericType; +import org.apache.lucene.legacy.LegacyNumericUtils; import org.apache.lucene.search.SimpleCollector; import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.BytesRefBuilder; -import org.apache.lucene.util.LegacyNumericUtils; abstract class DocValuesTermsCollector extends SimpleCollector { @@ -85,13 +84,13 @@ abstract class DocValuesTermsCollector extends SimpleCollector { return (l) -> LegacyNumericUtils.longToPrefixCoded(l, 0, bytes); default: throw new IllegalArgumentException("Unsupported "+type+ - ". Only "+ LegacyNumericType.INT+" and "+ FieldType.LegacyNumericType.LONG+" are supported." + ". Only "+ LegacyNumericType.INT+" and "+ LegacyNumericType.LONG+" are supported." + "Field "+fieldName ); } } /** this adapter is quite weird. ords are per doc index, don't use ords across different docs*/ - static Function sortedNumericAsSortedSetDocValues(String field, FieldType.LegacyNumericType numTyp) { + static Function sortedNumericAsSortedSetDocValues(String field, LegacyNumericType numTyp) { return (ctx) -> { final SortedNumericDocValues numerics = DocValues.getSortedNumeric(ctx, field); final BytesRefBuilder bytes = new BytesRefBuilder(); diff --git a/lucene/join/src/java/org/apache/lucene/search/join/JoinUtil.java b/lucene/join/src/java/org/apache/lucene/search/join/JoinUtil.java index b0133e570da..49423947383 100644 --- a/lucene/join/src/java/org/apache/lucene/search/join/JoinUtil.java +++ b/lucene/join/src/java/org/apache/lucene/search/join/JoinUtil.java @@ -26,7 +26,7 @@ import java.util.function.BiConsumer; import java.util.function.LongFunction; import org.apache.lucene.document.DoublePoint; -import org.apache.lucene.document.FieldType.LegacyNumericType; +import org.apache.lucene.legacy.LegacyNumericType; import org.apache.lucene.document.FloatPoint; import org.apache.lucene.document.IntPoint; import org.apache.lucene.document.LongPoint; @@ -123,8 +123,8 @@ public final class JoinUtil { * @param multipleValuesPerDocument Whether the from field has multiple terms per document * when true fromField might be {@link DocValuesType#SORTED_NUMERIC}, * otherwise fromField should be {@link DocValuesType#NUMERIC} - * @param toField The to field to join to, should be {@link org.apache.lucene.document.LegacyIntField} or {@link org.apache.lucene.document.LegacyLongField} - * @param numericType either {@link org.apache.lucene.document.FieldType.LegacyNumericType#INT} or {@link org.apache.lucene.document.FieldType.LegacyNumericType#LONG}, it should correspond to fromField and toField types + * @param toField The to field to join to, should be {@link org.apache.lucene.legacy.LegacyIntField} or {@link org.apache.lucene.legacy.LegacyLongField} + * @param numericType either {@link LegacyNumericType#INT} or {@link LegacyNumericType#LONG}, it should correspond to fromField and toField types * @param fromQuery The query to match documents on the from side * @param fromSearcher The searcher that executed the specified fromQuery * @param scoreMode Instructs how scores from the fromQuery are mapped to the returned query diff --git a/lucene/join/src/java/org/apache/lucene/search/join/TermsIncludingScoreQuery.java b/lucene/join/src/java/org/apache/lucene/search/join/TermsIncludingScoreQuery.java index 3b03bd39c38..a39c25fcc93 100644 --- a/lucene/join/src/java/org/apache/lucene/search/join/TermsIncludingScoreQuery.java +++ b/lucene/join/src/java/org/apache/lucene/search/join/TermsIncludingScoreQuery.java @@ -27,6 +27,7 @@ import org.apache.lucene.index.PostingsEnum; import org.apache.lucene.index.Term; import org.apache.lucene.index.Terms; import org.apache.lucene.index.TermsEnum; +import org.apache.lucene.legacy.LegacyNumericUtils; import org.apache.lucene.search.DocIdSetIterator; import org.apache.lucene.search.Explanation; import org.apache.lucene.search.IndexSearcher; @@ -37,7 +38,6 @@ import org.apache.lucene.util.BitSetIterator; import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.BytesRefHash; import org.apache.lucene.util.FixedBitSet; -import org.apache.lucene.util.LegacyNumericUtils; class TermsIncludingScoreQuery extends Query { diff --git a/lucene/join/src/test/org/apache/lucene/search/join/TestJoinUtil.java b/lucene/join/src/test/org/apache/lucene/search/join/TestJoinUtil.java index b29e9ff0e9e..6d9eb2ab339 100644 --- a/lucene/join/src/test/org/apache/lucene/search/join/TestJoinUtil.java +++ b/lucene/join/src/test/org/apache/lucene/search/join/TestJoinUtil.java @@ -37,12 +37,9 @@ import org.apache.lucene.document.Document; import org.apache.lucene.document.DoubleDocValuesField; import org.apache.lucene.document.DoublePoint; import org.apache.lucene.document.Field; -import org.apache.lucene.document.FieldType.LegacyNumericType; import org.apache.lucene.document.FloatDocValuesField; import org.apache.lucene.document.FloatPoint; import org.apache.lucene.document.IntPoint; -import org.apache.lucene.document.LegacyIntField; -import org.apache.lucene.document.LegacyLongField; import org.apache.lucene.document.LongPoint; import org.apache.lucene.document.NumericDocValuesField; import org.apache.lucene.document.SortedDocValuesField; @@ -59,6 +56,9 @@ import org.apache.lucene.index.LeafReader; import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.index.MultiDocValues; import org.apache.lucene.index.MultiDocValues.OrdinalMap; +import org.apache.lucene.legacy.LegacyIntField; +import org.apache.lucene.legacy.LegacyLongField; +import org.apache.lucene.legacy.LegacyNumericType; import org.apache.lucene.index.MultiFields; import org.apache.lucene.index.NoMergePolicy; import org.apache.lucene.index.NumericDocValues; diff --git a/lucene/memory/src/test/org/apache/lucene/index/memory/TestMemoryIndexAgainstRAMDir.java b/lucene/memory/src/test/org/apache/lucene/index/memory/TestMemoryIndexAgainstRAMDir.java index 45e95510dc5..a7857207a39 100644 --- a/lucene/memory/src/test/org/apache/lucene/index/memory/TestMemoryIndexAgainstRAMDir.java +++ b/lucene/memory/src/test/org/apache/lucene/index/memory/TestMemoryIndexAgainstRAMDir.java @@ -45,7 +45,6 @@ import org.apache.lucene.document.Field; import org.apache.lucene.document.FieldType; import org.apache.lucene.document.FloatPoint; import org.apache.lucene.document.IntPoint; -import org.apache.lucene.document.LegacyLongField; import org.apache.lucene.document.LongPoint; import org.apache.lucene.document.NumericDocValuesField; import org.apache.lucene.document.SortedDocValuesField; @@ -457,9 +456,6 @@ public class TestMemoryIndexAgainstRAMDir extends BaseTokenStreamTestCase { Document doc = new Document(); long randomLong = random().nextLong(); doc.add(new NumericDocValuesField("numeric", randomLong)); - if (random().nextBoolean()) { - doc.add(new LegacyLongField("numeric", randomLong, Field.Store.NO)); - } int numValues = atLeast(5); for (int i = 0; i < numValues; i++) { randomLong = random().nextLong(); @@ -468,9 +464,6 @@ public class TestMemoryIndexAgainstRAMDir extends BaseTokenStreamTestCase { // randomly duplicate field/value doc.add(new SortedNumericDocValuesField("sorted_numeric", randomLong)); } - if (random().nextBoolean()) { - doc.add(new LegacyLongField("numeric", randomLong, Field.Store.NO)); - } } BytesRef randomTerm = new BytesRef(randomTerm()); doc.add(new BinaryDocValuesField("binary", randomTerm)); diff --git a/lucene/misc/src/test/org/apache/lucene/search/TestDiversifiedTopDocsCollector.java b/lucene/misc/src/test/org/apache/lucene/search/TestDiversifiedTopDocsCollector.java index da9fdc5dc5d..05a3b239959 100644 --- a/lucene/misc/src/test/org/apache/lucene/search/TestDiversifiedTopDocsCollector.java +++ b/lucene/misc/src/test/org/apache/lucene/search/TestDiversifiedTopDocsCollector.java @@ -21,11 +21,10 @@ import java.util.HashMap; import java.util.Map; import org.apache.lucene.document.Document; -import org.apache.lucene.document.Field.Store; import org.apache.lucene.document.Field; import org.apache.lucene.document.FloatDocValuesField; -import org.apache.lucene.document.LegacyFloatField; import org.apache.lucene.document.SortedDocValuesField; +import org.apache.lucene.document.StoredField; import org.apache.lucene.index.BinaryDocValues; import org.apache.lucene.index.DocValues; import org.apache.lucene.index.FieldInvertState; @@ -331,7 +330,7 @@ public class TestDiversifiedTopDocsCollector extends LuceneTestCase { new BytesRef("")); Field weeksAtNumberOneField = new FloatDocValuesField("weeksAtNumberOne", 0.0F); - Field weeksStoredField = new LegacyFloatField("weeks", 0.0F, Store.YES); + Field weeksStoredField = new StoredField("weeks", 0.0F); Field idField = newStringField("id", "", Field.Store.YES); Field songField = newTextField("song", "", Field.Store.NO); Field storedArtistField = newTextField("artistName", "", Field.Store.NO); diff --git a/lucene/queryparser/build.xml b/lucene/queryparser/build.xml index b6e43c2ce26..f1d59a34a4c 100644 --- a/lucene/queryparser/build.xml +++ b/lucene/queryparser/build.xml @@ -25,15 +25,17 @@ + - + - + diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/LegacyNumericRangeQueryNodeBuilder.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/LegacyNumericRangeQueryNodeBuilder.java index 8ae7d5e2e43..0781afb533c 100644 --- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/LegacyNumericRangeQueryNodeBuilder.java +++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/LegacyNumericRangeQueryNodeBuilder.java @@ -16,7 +16,8 @@ */ package org.apache.lucene.queryparser.flexible.standard.builders; -import org.apache.lucene.document.FieldType; +import org.apache.lucene.legacy.LegacyNumericRangeQuery; +import org.apache.lucene.legacy.LegacyNumericType; import org.apache.lucene.queryparser.flexible.core.QueryNodeException; import org.apache.lucene.queryparser.flexible.core.messages.QueryParserMessages; import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode; @@ -25,12 +26,11 @@ import org.apache.lucene.queryparser.flexible.messages.MessageImpl; import org.apache.lucene.queryparser.flexible.standard.config.LegacyNumericConfig; import org.apache.lucene.queryparser.flexible.standard.nodes.LegacyNumericQueryNode; import org.apache.lucene.queryparser.flexible.standard.nodes.LegacyNumericRangeQueryNode; -import org.apache.lucene.search.LegacyNumericRangeQuery; /** - * Builds {@link org.apache.lucene.search.LegacyNumericRangeQuery}s out of {@link LegacyNumericRangeQueryNode}s. + * Builds {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}s out of {@link LegacyNumericRangeQueryNode}s. * - * @see org.apache.lucene.search.LegacyNumericRangeQuery + * @see org.apache.lucene.legacy.LegacyNumericRangeQuery * @see LegacyNumericRangeQueryNode * @deprecated Index with points and use {@link PointRangeQueryNodeBuilder} instead. */ @@ -56,7 +56,7 @@ public class LegacyNumericRangeQueryNodeBuilder implements StandardQueryBuilder Number upperNumber = upperNumericNode.getValue(); LegacyNumericConfig numericConfig = numericRangeNode.getNumericConfig(); - FieldType.LegacyNumericType numberType = numericConfig.getType(); + LegacyNumericType numberType = numericConfig.getType(); String field = StringUtils.toString(numericRangeNode.getField()); boolean minInclusive = numericRangeNode.isLowerInclusive(); boolean maxInclusive = numericRangeNode.isUpperInclusive(); diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/config/LegacyNumericConfig.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/config/LegacyNumericConfig.java index 6cd3c490e57..038023e65ae 100644 --- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/config/LegacyNumericConfig.java +++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/config/LegacyNumericConfig.java @@ -19,14 +19,13 @@ package org.apache.lucene.queryparser.flexible.standard.config; import java.text.NumberFormat; import java.util.Objects; -import org.apache.lucene.document.FieldType; -import org.apache.lucene.document.FieldType.LegacyNumericType; +import org.apache.lucene.legacy.LegacyNumericType; /** * This class holds the configuration used to parse numeric queries and create - * {@link org.apache.lucene.search.LegacyNumericRangeQuery}s. + * {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}s. * - * @see org.apache.lucene.search.LegacyNumericRangeQuery + * @see org.apache.lucene.legacy.LegacyNumericRangeQuery * @see NumberFormat * @deprecated Index with Points instead and use {@link PointsConfig} */ @@ -37,7 +36,7 @@ public class LegacyNumericConfig { private NumberFormat format; - private FieldType.LegacyNumericType type; + private LegacyNumericType type; /** * Constructs a {@link LegacyNumericConfig} object. @@ -52,7 +51,7 @@ public class LegacyNumericConfig { * * @see LegacyNumericConfig#setPrecisionStep(int) * @see LegacyNumericConfig#setNumberFormat(NumberFormat) - * @see #setType(org.apache.lucene.document.FieldType.LegacyNumericType) + * @see #setType(LegacyNumericType) */ public LegacyNumericConfig(int precisionStep, NumberFormat format, LegacyNumericType type) { @@ -67,7 +66,7 @@ public class LegacyNumericConfig { * * @return the precision used to index the numeric values * - * @see org.apache.lucene.search.LegacyNumericRangeQuery#getPrecisionStep() + * @see org.apache.lucene.legacy.LegacyNumericRangeQuery#getPrecisionStep() */ public int getPrecisionStep() { return precisionStep; @@ -79,7 +78,7 @@ public class LegacyNumericConfig { * @param precisionStep * the precision used to index the numeric values * - * @see org.apache.lucene.search.LegacyNumericRangeQuery#getPrecisionStep() + * @see org.apache.lucene.legacy.LegacyNumericRangeQuery#getPrecisionStep() */ public void setPrecisionStep(int precisionStep) { this.precisionStep = precisionStep; diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/nodes/LegacyNumericRangeQueryNode.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/nodes/LegacyNumericRangeQueryNode.java index 27c285eb34c..20cde351ce7 100644 --- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/nodes/LegacyNumericRangeQueryNode.java +++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/nodes/LegacyNumericRangeQueryNode.java @@ -16,8 +16,7 @@ */ package org.apache.lucene.queryparser.flexible.standard.nodes; -import org.apache.lucene.document.FieldType; -import org.apache.lucene.document.FieldType.LegacyNumericType; +import org.apache.lucene.legacy.LegacyNumericType; import org.apache.lucene.queryparser.flexible.core.QueryNodeException; import org.apache.lucene.queryparser.flexible.core.messages.QueryParserMessages; import org.apache.lucene.queryparser.flexible.messages.MessageImpl; @@ -57,13 +56,13 @@ public class LegacyNumericRangeQueryNode extends private static LegacyNumericType getNumericDataType(Number number) throws QueryNodeException { if (number instanceof Long) { - return FieldType.LegacyNumericType.LONG; + return LegacyNumericType.LONG; } else if (number instanceof Integer) { - return FieldType.LegacyNumericType.INT; + return LegacyNumericType.INT; } else if (number instanceof Double) { return LegacyNumericType.DOUBLE; } else if (number instanceof Float) { - return FieldType.LegacyNumericType.FLOAT; + return LegacyNumericType.FLOAT; } else { throw new QueryNodeException( new MessageImpl( diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/xml/builders/LegacyNumericRangeQueryBuilder.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/xml/builders/LegacyNumericRangeQueryBuilder.java index f7aef3f477b..9f4505f056c 100644 --- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/xml/builders/LegacyNumericRangeQueryBuilder.java +++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/xml/builders/LegacyNumericRangeQueryBuilder.java @@ -16,19 +16,19 @@ */ package org.apache.lucene.queryparser.xml.builders; -import org.apache.lucene.search.LegacyNumericRangeQuery; import org.apache.lucene.search.Query; -import org.apache.lucene.util.LegacyNumericUtils; +import org.apache.lucene.legacy.LegacyNumericRangeQuery; +import org.apache.lucene.legacy.LegacyNumericUtils; import org.apache.lucene.queryparser.xml.DOMUtils; import org.apache.lucene.queryparser.xml.ParserException; import org.apache.lucene.queryparser.xml.QueryBuilder; import org.w3c.dom.Element; /** - * Creates a {@link org.apache.lucene.search.LegacyNumericRangeQuery}. The table below specifies the required + * Creates a {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}. The table below specifies the required * attributes and the defaults if optional attributes are omitted. For more * detail on what each of the attributes actually do, consult the documentation - * for {@link org.apache.lucene.search.LegacyNumericRangeQuery}: + * for {@link org.apache.lucene.legacy.LegacyNumericRangeQuery}: * * * diff --git a/lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/standard/TestLegacyNumericQueryParser.java b/lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/standard/TestLegacyNumericQueryParser.java index c6ab7f5ffff..398923e299f 100644 --- a/lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/standard/TestLegacyNumericQueryParser.java +++ b/lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/standard/TestLegacyNumericQueryParser.java @@ -32,15 +32,15 @@ import java.util.TimeZone; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.analysis.MockAnalyzer; import org.apache.lucene.document.Document; -import org.apache.lucene.document.LegacyDoubleField; import org.apache.lucene.document.Field; -import org.apache.lucene.document.FieldType.LegacyNumericType; -import org.apache.lucene.document.FieldType; -import org.apache.lucene.document.LegacyFloatField; -import org.apache.lucene.document.LegacyIntField; -import org.apache.lucene.document.LegacyLongField; import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.RandomIndexWriter; +import org.apache.lucene.legacy.LegacyDoubleField; +import org.apache.lucene.legacy.LegacyFieldType; +import org.apache.lucene.legacy.LegacyFloatField; +import org.apache.lucene.legacy.LegacyIntField; +import org.apache.lucene.legacy.LegacyLongField; +import org.apache.lucene.legacy.LegacyNumericType; import org.apache.lucene.queryparser.flexible.core.QueryNodeException; import org.apache.lucene.queryparser.flexible.core.parser.EscapeQuerySyntax; import org.apache.lucene.queryparser.flexible.standard.config.NumberDateFormat; @@ -179,7 +179,7 @@ public class TestLegacyNumericQueryParser extends LuceneTestCase { ; randomNumberMap.put(LegacyNumericType.LONG.name(), randomLong); - randomNumberMap.put(FieldType.LegacyNumericType.INT.name(), randomInt); + randomNumberMap.put(LegacyNumericType.INT.name(), randomInt); randomNumberMap.put(LegacyNumericType.FLOAT.name(), randomFloat); randomNumberMap.put(LegacyNumericType.DOUBLE.name(), randomDouble); randomNumberMap.put(DATE_FIELD_NAME, randomDate); @@ -201,7 +201,7 @@ public class TestLegacyNumericQueryParser extends LuceneTestCase { numericConfigMap.put(type.name(), new LegacyNumericConfig(PRECISION_STEP, NUMBER_FORMAT, type)); - FieldType ft = new FieldType(LegacyIntField.TYPE_NOT_STORED); + LegacyFieldType ft = new LegacyFieldType(LegacyIntField.TYPE_NOT_STORED); ft.setNumericType(type); ft.setStored(true); ft.setNumericPrecisionStep(PRECISION_STEP); @@ -231,7 +231,7 @@ public class TestLegacyNumericQueryParser extends LuceneTestCase { numericConfigMap.put(DATE_FIELD_NAME, new LegacyNumericConfig(PRECISION_STEP, DATE_FORMAT, LegacyNumericType.LONG)); - FieldType ft = new FieldType(LegacyLongField.TYPE_NOT_STORED); + LegacyFieldType ft = new LegacyFieldType(LegacyLongField.TYPE_NOT_STORED); ft.setStored(true); ft.setNumericPrecisionStep(PRECISION_STEP); LegacyLongField dateField = new LegacyLongField(DATE_FIELD_NAME, 0l, ft); @@ -268,10 +268,10 @@ public class TestLegacyNumericQueryParser extends LuceneTestCase { || DATE_FIELD_NAME.equals(fieldName)) { number = -number.longValue(); - } else if (FieldType.LegacyNumericType.DOUBLE.name().equals(fieldName)) { + } else if (LegacyNumericType.DOUBLE.name().equals(fieldName)) { number = -number.doubleValue(); - } else if (FieldType.LegacyNumericType.FLOAT.name().equals(fieldName)) { + } else if (LegacyNumericType.FLOAT.name().equals(fieldName)) { number = -number.floatValue(); } else if (LegacyNumericType.INT.name().equals(fieldName)) { @@ -299,16 +299,16 @@ public class TestLegacyNumericQueryParser extends LuceneTestCase { numericFieldMap.get(LegacyNumericType.DOUBLE.name()).setDoubleValue( number.doubleValue()); - number = getNumberType(numberType, FieldType.LegacyNumericType.INT.name()); - numericFieldMap.get(FieldType.LegacyNumericType.INT.name()).setIntValue( + number = getNumberType(numberType, LegacyNumericType.INT.name()); + numericFieldMap.get(LegacyNumericType.INT.name()).setIntValue( number.intValue()); number = getNumberType(numberType, LegacyNumericType.LONG.name()); - numericFieldMap.get(FieldType.LegacyNumericType.LONG.name()).setLongValue( + numericFieldMap.get(LegacyNumericType.LONG.name()).setLongValue( number.longValue()); - number = getNumberType(numberType, FieldType.LegacyNumericType.FLOAT.name()); - numericFieldMap.get(FieldType.LegacyNumericType.FLOAT.name()).setFloatValue( + number = getNumberType(numberType, LegacyNumericType.FLOAT.name()); + numericFieldMap.get(LegacyNumericType.FLOAT.name()).setFloatValue( number.floatValue()); number = getNumberType(numberType, DATE_FIELD_NAME); @@ -456,7 +456,7 @@ public class TestLegacyNumericQueryParser extends LuceneTestCase { StringBuilder sb = new StringBuilder(); - for (LegacyNumericType type : FieldType.LegacyNumericType.values()) { + for (LegacyNumericType type : LegacyNumericType.values()) { String boundStr = numberToString(getNumberType(boundType, type.name())); sb.append("+").append(type.name()).append(operator).append('"').append(boundStr).append('"').append(' '); diff --git a/lucene/queryparser/src/test/org/apache/lucene/queryparser/xml/CoreParserTestIndexData.java b/lucene/queryparser/src/test/org/apache/lucene/queryparser/xml/CoreParserTestIndexData.java index 71b627e74cd..4763005d985 100644 --- a/lucene/queryparser/src/test/org/apache/lucene/queryparser/xml/CoreParserTestIndexData.java +++ b/lucene/queryparser/src/test/org/apache/lucene/queryparser/xml/CoreParserTestIndexData.java @@ -20,10 +20,10 @@ import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; import org.apache.lucene.document.IntPoint; -import org.apache.lucene.document.LegacyIntField; import org.apache.lucene.index.DirectoryReader; import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.IndexWriter; +import org.apache.lucene.legacy.LegacyIntField; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.store.Directory; import org.apache.lucene.util.LuceneTestCase; diff --git a/lucene/queryparser/src/test/org/apache/lucene/queryparser/xml/builders/TestNumericRangeQueryBuilder.java b/lucene/queryparser/src/test/org/apache/lucene/queryparser/xml/builders/TestNumericRangeQueryBuilder.java index 8fc0641e4e7..0bc019595be 100644 --- a/lucene/queryparser/src/test/org/apache/lucene/queryparser/xml/builders/TestNumericRangeQueryBuilder.java +++ b/lucene/queryparser/src/test/org/apache/lucene/queryparser/xml/builders/TestNumericRangeQueryBuilder.java @@ -16,9 +16,9 @@ */ package org.apache.lucene.queryparser.xml.builders; -import org.apache.lucene.search.LegacyNumericRangeQuery; import org.apache.lucene.search.Query; import org.apache.lucene.util.LuceneTestCase; +import org.apache.lucene.legacy.LegacyNumericRangeQuery; import org.apache.lucene.queryparser.xml.ParserException; import org.w3c.dom.Document; import org.xml.sax.SAXException; diff --git a/lucene/spatial-extras/build.xml b/lucene/spatial-extras/build.xml index a77f9ea2a21..2e425fda202 100644 --- a/lucene/spatial-extras/build.xml +++ b/lucene/spatial-extras/build.xml @@ -31,6 +31,7 @@ + @@ -42,16 +43,17 @@ - + - + - \ No newline at end of file + diff --git a/lucene/spatial-extras/src/java/org/apache/lucene/spatial/bbox/BBoxStrategy.java b/lucene/spatial-extras/src/java/org/apache/lucene/spatial/bbox/BBoxStrategy.java index 63a113839b5..90e36d835db 100644 --- a/lucene/spatial-extras/src/java/org/apache/lucene/spatial/bbox/BBoxStrategy.java +++ b/lucene/spatial-extras/src/java/org/apache/lucene/spatial/bbox/BBoxStrategy.java @@ -20,17 +20,20 @@ import org.apache.lucene.document.DoubleDocValuesField; import org.apache.lucene.document.DoublePoint; import org.apache.lucene.document.Field; import org.apache.lucene.document.FieldType; -import org.apache.lucene.document.LegacyDoubleField; import org.apache.lucene.document.StoredField; import org.apache.lucene.document.StringField; import org.apache.lucene.index.DocValuesType; import org.apache.lucene.index.IndexOptions; import org.apache.lucene.index.Term; +import org.apache.lucene.legacy.LegacyDoubleField; +import org.apache.lucene.legacy.LegacyFieldType; +import org.apache.lucene.legacy.LegacyNumericRangeQuery; +import org.apache.lucene.legacy.LegacyNumericType; +import org.apache.lucene.legacy.LegacyNumericUtils; import org.apache.lucene.queries.function.ValueSource; import org.apache.lucene.search.BooleanClause; import org.apache.lucene.search.BooleanQuery; import org.apache.lucene.search.ConstantScoreQuery; -import org.apache.lucene.search.LegacyNumericRangeQuery; import org.apache.lucene.search.Query; import org.apache.lucene.search.TermQuery; import org.apache.lucene.spatial.SpatialStrategy; @@ -39,7 +42,6 @@ import org.apache.lucene.spatial.query.SpatialOperation; import org.apache.lucene.spatial.query.UnsupportedSpatialOperation; import org.apache.lucene.spatial.util.DistanceToShapeValueSource; import org.apache.lucene.util.BytesRefBuilder; -import org.apache.lucene.util.LegacyNumericUtils; import org.apache.lucene.util.NumericUtils; import org.locationtech.spatial4j.context.SpatialContext; import org.locationtech.spatial4j.shape.Point; @@ -87,7 +89,7 @@ public class BBoxStrategy extends SpatialStrategy { public static FieldType DEFAULT_FIELDTYPE; @Deprecated - public static FieldType LEGACY_FIELDTYPE; + public static LegacyFieldType LEGACY_FIELDTYPE; static { // Default: pointValues + docValues FieldType type = new FieldType(); @@ -97,14 +99,14 @@ public class BBoxStrategy extends SpatialStrategy { type.freeze(); DEFAULT_FIELDTYPE = type; // Legacy default: legacyNumerics + docValues - type = new FieldType(); - type.setIndexOptions(IndexOptions.DOCS); - type.setNumericType(FieldType.LegacyNumericType.DOUBLE); - type.setNumericPrecisionStep(8);// same as solr default - type.setDocValuesType(DocValuesType.NUMERIC);//docValues - type.setStored(false); - type.freeze(); - LEGACY_FIELDTYPE = type; + LegacyFieldType legacyType = new LegacyFieldType(); + legacyType.setIndexOptions(IndexOptions.DOCS); + legacyType.setNumericType(LegacyNumericType.DOUBLE); + legacyType.setNumericPrecisionStep(8);// same as solr default + legacyType.setDocValuesType(DocValuesType.NUMERIC);//docValues + legacyType.setStored(false); + legacyType.freeze(); + LEGACY_FIELDTYPE = legacyType; } public static final String SUFFIX_MINX = "__minX"; @@ -130,7 +132,7 @@ public class BBoxStrategy extends SpatialStrategy { private final boolean hasDocVals; private final boolean hasPointVals; // equiv to "hasLegacyNumerics": - private final FieldType legacyNumericFieldType; // not stored; holds precision step. + private final LegacyFieldType legacyNumericFieldType; // not stored; holds precision step. private final FieldType xdlFieldType; /** @@ -177,16 +179,17 @@ public class BBoxStrategy extends SpatialStrategy { if ((this.hasPointVals = fieldType.pointDimensionCount() > 0)) { numQuads++; } - if (fieldType.indexOptions() != IndexOptions.NONE && fieldType.numericType() != null) { + if (fieldType.indexOptions() != IndexOptions.NONE && fieldType instanceof LegacyFieldType && ((LegacyFieldType)fieldType).numericType() != null) { if (hasPointVals) { throw new IllegalArgumentException("pointValues and LegacyNumericType are mutually exclusive"); } - if (fieldType.numericType() != FieldType.LegacyNumericType.DOUBLE) { - throw new IllegalArgumentException(getClass() + " does not support " + fieldType.numericType()); + final LegacyFieldType legacyType = (LegacyFieldType) fieldType; + if (legacyType.numericType() != LegacyNumericType.DOUBLE) { + throw new IllegalArgumentException(getClass() + " does not support " + legacyType.numericType()); } numQuads++; - legacyNumericFieldType = new FieldType(LegacyDoubleField.TYPE_NOT_STORED); - legacyNumericFieldType.setNumericPrecisionStep(fieldType.numericPrecisionStep()); + legacyNumericFieldType = new LegacyFieldType(LegacyDoubleField.TYPE_NOT_STORED); + legacyNumericFieldType.setNumericPrecisionStep(legacyType.numericPrecisionStep()); legacyNumericFieldType.freeze(); } else { legacyNumericFieldType = null; diff --git a/lucene/spatial-extras/src/java/org/apache/lucene/spatial/prefix/BytesRefIteratorTokenStream.java b/lucene/spatial-extras/src/java/org/apache/lucene/spatial/prefix/BytesRefIteratorTokenStream.java index e724ab05fe6..757e2bd38f7 100644 --- a/lucene/spatial-extras/src/java/org/apache/lucene/spatial/prefix/BytesRefIteratorTokenStream.java +++ b/lucene/spatial-extras/src/java/org/apache/lucene/spatial/prefix/BytesRefIteratorTokenStream.java @@ -26,7 +26,7 @@ import org.apache.lucene.util.BytesRefIterator; /** * A TokenStream used internally by {@link org.apache.lucene.spatial.prefix.PrefixTreeStrategy}. * - * This is modelled after {@link org.apache.lucene.analysis.LegacyNumericTokenStream}. + * This is modelled after {@link org.apache.lucene.legacy.LegacyNumericTokenStream}. * * @lucene.internal */ diff --git a/lucene/spatial-extras/src/java/org/apache/lucene/spatial/vector/PointVectorStrategy.java b/lucene/spatial-extras/src/java/org/apache/lucene/spatial/vector/PointVectorStrategy.java index 197547c1d56..59aff490916 100644 --- a/lucene/spatial-extras/src/java/org/apache/lucene/spatial/vector/PointVectorStrategy.java +++ b/lucene/spatial-extras/src/java/org/apache/lucene/spatial/vector/PointVectorStrategy.java @@ -20,16 +20,18 @@ import org.apache.lucene.document.DoubleDocValuesField; import org.apache.lucene.document.DoublePoint; import org.apache.lucene.document.Field; import org.apache.lucene.document.FieldType; -import org.apache.lucene.document.LegacyDoubleField; import org.apache.lucene.document.StoredField; import org.apache.lucene.index.DocValuesType; import org.apache.lucene.index.IndexOptions; +import org.apache.lucene.legacy.LegacyDoubleField; +import org.apache.lucene.legacy.LegacyFieldType; +import org.apache.lucene.legacy.LegacyNumericRangeQuery; +import org.apache.lucene.legacy.LegacyNumericType; import org.apache.lucene.queries.function.FunctionRangeQuery; import org.apache.lucene.queries.function.ValueSource; import org.apache.lucene.search.BooleanClause; import org.apache.lucene.search.BooleanQuery; import org.apache.lucene.search.ConstantScoreQuery; -import org.apache.lucene.search.LegacyNumericRangeQuery; import org.apache.lucene.search.Query; import org.apache.lucene.spatial.SpatialStrategy; import org.apache.lucene.spatial.query.SpatialArgs; @@ -85,7 +87,7 @@ public class PointVectorStrategy extends SpatialStrategy { public static FieldType DEFAULT_FIELDTYPE; @Deprecated - public static FieldType LEGACY_FIELDTYPE; + public static LegacyFieldType LEGACY_FIELDTYPE; static { // Default: pointValues + docValues FieldType type = new FieldType(); @@ -95,14 +97,14 @@ public class PointVectorStrategy extends SpatialStrategy { type.freeze(); DEFAULT_FIELDTYPE = type; // Legacy default: legacyNumerics - type = new FieldType(); - type.setIndexOptions(IndexOptions.DOCS); - type.setNumericType(FieldType.LegacyNumericType.DOUBLE); - type.setNumericPrecisionStep(8);// same as solr default - type.setDocValuesType(DocValuesType.NONE);//no docValues! - type.setStored(false); - type.freeze(); - LEGACY_FIELDTYPE = type; + LegacyFieldType legacyType = new LegacyFieldType(); + legacyType.setIndexOptions(IndexOptions.DOCS); + legacyType.setNumericType(LegacyNumericType.DOUBLE); + legacyType.setNumericPrecisionStep(8);// same as solr default + legacyType.setDocValuesType(DocValuesType.NONE);//no docValues! + legacyType.setStored(false); + legacyType.freeze(); + LEGACY_FIELDTYPE = legacyType; } public static final String SUFFIX_X = "__x"; @@ -116,7 +118,7 @@ public class PointVectorStrategy extends SpatialStrategy { private final boolean hasDocVals; private final boolean hasPointVals; // equiv to "hasLegacyNumerics": - private final FieldType legacyNumericFieldType; // not stored; holds precision step. + private final LegacyFieldType legacyNumericFieldType; // not stored; holds precision step. /** * Create a new {@link PointVectorStrategy} instance that uses {@link DoublePoint} and {@link DoublePoint#newRangeQuery} @@ -157,16 +159,17 @@ public class PointVectorStrategy extends SpatialStrategy { if ((this.hasPointVals = fieldType.pointDimensionCount() > 0)) { numPairs++; } - if (fieldType.indexOptions() != IndexOptions.NONE && fieldType.numericType() != null) { + if (fieldType.indexOptions() != IndexOptions.NONE && fieldType instanceof LegacyFieldType && ((LegacyFieldType)fieldType).numericType() != null) { if (hasPointVals) { throw new IllegalArgumentException("pointValues and LegacyNumericType are mutually exclusive"); } - if (fieldType.numericType() != FieldType.LegacyNumericType.DOUBLE) { - throw new IllegalArgumentException(getClass() + " does not support " + fieldType.numericType()); + final LegacyFieldType legacyType = (LegacyFieldType) fieldType; + if (legacyType.numericType() != LegacyNumericType.DOUBLE) { + throw new IllegalArgumentException(getClass() + " does not support " + legacyType.numericType()); } numPairs++; - legacyNumericFieldType = new FieldType(LegacyDoubleField.TYPE_NOT_STORED); - legacyNumericFieldType.setNumericPrecisionStep(fieldType.numericPrecisionStep()); + legacyNumericFieldType = new LegacyFieldType(LegacyDoubleField.TYPE_NOT_STORED); + legacyNumericFieldType.setNumericPrecisionStep(legacyType.numericPrecisionStep()); legacyNumericFieldType.freeze(); } else { legacyNumericFieldType = null; diff --git a/lucene/spatial-extras/src/test/org/apache/lucene/spatial/bbox/TestBBoxStrategy.java b/lucene/spatial-extras/src/test/org/apache/lucene/spatial/bbox/TestBBoxStrategy.java index 01e925926d2..20df7305cbe 100644 --- a/lucene/spatial-extras/src/test/org/apache/lucene/spatial/bbox/TestBBoxStrategy.java +++ b/lucene/spatial-extras/src/test/org/apache/lucene/spatial/bbox/TestBBoxStrategy.java @@ -22,6 +22,7 @@ import com.carrotsearch.randomizedtesting.annotations.Repeat; import org.apache.lucene.document.FieldType; import org.apache.lucene.index.DocValuesType; import org.apache.lucene.index.IndexOptions; +import org.apache.lucene.legacy.LegacyFieldType; import org.apache.lucene.search.Query; import org.apache.lucene.spatial.SpatialMatchConcern; import org.apache.lucene.spatial.prefix.RandomSpatialOpStrategyTestCase; @@ -100,7 +101,12 @@ public class TestBBoxStrategy extends RandomSpatialOpStrategyTestCase { } //test we can disable docValues for predicate tests if (random().nextBoolean()) { - FieldType fieldType = new FieldType(((BBoxStrategy)strategy).getFieldType()); + FieldType fieldType = ((BBoxStrategy)strategy).getFieldType(); + if (fieldType instanceof LegacyFieldType) { + fieldType = new LegacyFieldType((LegacyFieldType)fieldType); + } else { + fieldType = new FieldType(fieldType); + } fieldType.setDocValuesType(DocValuesType.NONE); strategy = new BBoxStrategy(ctx, strategy.getFieldName(), fieldType); } diff --git a/solr/contrib/analytics/src/java/org/apache/solr/analytics/util/AnalyticsParsers.java b/solr/contrib/analytics/src/java/org/apache/solr/analytics/util/AnalyticsParsers.java index 7a7e697d059..aadb9e2d4ce 100644 --- a/solr/contrib/analytics/src/java/org/apache/solr/analytics/util/AnalyticsParsers.java +++ b/solr/contrib/analytics/src/java/org/apache/solr/analytics/util/AnalyticsParsers.java @@ -20,8 +20,8 @@ import java.io.IOException; import java.time.Instant; import java.util.Arrays; +import org.apache.lucene.legacy.LegacyNumericUtils; import org.apache.lucene.util.BytesRef; -import org.apache.lucene.util.LegacyNumericUtils; import org.apache.lucene.util.NumericUtils; import org.apache.solr.schema.FieldType; import org.apache.solr.schema.TrieDateField; diff --git a/solr/contrib/analytics/src/java/org/apache/solr/analytics/util/valuesource/DateFieldSource.java b/solr/contrib/analytics/src/java/org/apache/solr/analytics/util/valuesource/DateFieldSource.java index 4d66e0025bc..22dde4c00ab 100644 --- a/solr/contrib/analytics/src/java/org/apache/solr/analytics/util/valuesource/DateFieldSource.java +++ b/solr/contrib/analytics/src/java/org/apache/solr/analytics/util/valuesource/DateFieldSource.java @@ -24,12 +24,12 @@ import java.util.Map; import org.apache.lucene.index.DocValues; import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.index.NumericDocValues; +import org.apache.lucene.legacy.LegacyNumericUtils; import org.apache.lucene.queries.function.FunctionValues; import org.apache.lucene.queries.function.docvalues.LongDocValues; import org.apache.lucene.queries.function.valuesource.LongFieldSource; import org.apache.lucene.util.Bits; import org.apache.lucene.util.BytesRef; -import org.apache.lucene.util.LegacyNumericUtils; import org.apache.lucene.util.mutable.MutableValue; import org.apache.lucene.util.mutable.MutableValueDate; diff --git a/solr/core/src/java/org/apache/solr/handler/component/StatsField.java b/solr/core/src/java/org/apache/solr/handler/component/StatsField.java index 4c2a2b6a5ab..5df1b45cc93 100644 --- a/solr/core/src/java/org/apache/solr/handler/component/StatsField.java +++ b/solr/core/src/java/org/apache/solr/handler/component/StatsField.java @@ -29,8 +29,7 @@ import java.util.Map; import java.util.Set; import org.apache.commons.lang.StringUtils; -import org.apache.lucene.document.FieldType; -import org.apache.lucene.document.FieldType.LegacyNumericType; +import org.apache.lucene.legacy.LegacyNumericType; import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.queries.function.FunctionQuery; import org.apache.lucene.queries.function.ValueSource; @@ -637,13 +636,13 @@ public class StatsField { return null; } - final FieldType.LegacyNumericType hashableNumType = getHashableNumericType(field); + final LegacyNumericType hashableNumType = getHashableNumericType(field); // some sane defaults int log2m = 13; // roughly equivilent to "cardinality='0.33'" int regwidth = 6; // with decent hash, this is plenty for all valid long hashes - if (LegacyNumericType.FLOAT.equals(hashableNumType) || FieldType.LegacyNumericType.INT.equals(hashableNumType)) { + if (LegacyNumericType.FLOAT.equals(hashableNumType) || LegacyNumericType.INT.equals(hashableNumType)) { // for 32bit values, we can adjust our default regwidth down a bit regwidth--; @@ -707,7 +706,7 @@ public class StatsField { if (null == hasher) { // if this is a function, or a non Long field, pre-hashed is invalid // NOTE: we ignore hashableNumType - it's LONG for non numerics like Strings - if (null == field || !FieldType.LegacyNumericType.LONG.equals(field.getType().getNumericType())) { + if (null == field || !LegacyNumericType.LONG.equals(field.getType().getNumericType())) { throw new SolrException(ErrorCode.BAD_REQUEST, "hllPreHashed is only supported with Long based fields"); } } @@ -740,16 +739,16 @@ public class StatsField { } /** - * Returns the effective {@link org.apache.lucene.document.FieldType.LegacyNumericType} for the field for the purposes of hash values. + * Returns the effective {@link LegacyNumericType} for the field for the purposes of hash values. * ie: If the field has an explict LegacyNumericType that is returned; If the field has no explicit - * LegacyNumericType then {@link org.apache.lucene.document.FieldType.LegacyNumericType#LONG} is returned; If field is null, then - * {@link org.apache.lucene.document.FieldType.LegacyNumericType#FLOAT} is assumed for ValueSource. + * LegacyNumericType then {@link LegacyNumericType#LONG} is returned; If field is null, then + * {@link LegacyNumericType#FLOAT} is assumed for ValueSource. */ private static LegacyNumericType getHashableNumericType(SchemaField field) { if (null == field) { return LegacyNumericType.FLOAT; } final LegacyNumericType result = field.getType().getNumericType(); - return null == result ? FieldType.LegacyNumericType.LONG : result; + return null == result ? LegacyNumericType.LONG : result; } } diff --git a/solr/core/src/java/org/apache/solr/request/IntervalFacets.java b/solr/core/src/java/org/apache/solr/request/IntervalFacets.java index fedc7fe0ca4..db26e12218d 100644 --- a/solr/core/src/java/org/apache/solr/request/IntervalFacets.java +++ b/solr/core/src/java/org/apache/solr/request/IntervalFacets.java @@ -25,7 +25,7 @@ import java.util.Iterator; import java.util.List; import java.util.Locale; -import org.apache.lucene.document.FieldType.LegacyNumericType; +import org.apache.lucene.legacy.LegacyNumericType; import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.index.DocValues; import org.apache.lucene.index.NumericDocValues; diff --git a/solr/core/src/java/org/apache/solr/request/NumericFacets.java b/solr/core/src/java/org/apache/solr/request/NumericFacets.java index 1034947ca9f..fd85d3fd5d7 100644 --- a/solr/core/src/java/org/apache/solr/request/NumericFacets.java +++ b/solr/core/src/java/org/apache/solr/request/NumericFacets.java @@ -33,6 +33,7 @@ import org.apache.lucene.index.NumericDocValues; import org.apache.lucene.index.ReaderUtil; import org.apache.lucene.index.Terms; import org.apache.lucene.index.TermsEnum; +import org.apache.lucene.legacy.LegacyNumericType; import org.apache.lucene.queries.function.FunctionValues; import org.apache.lucene.queries.function.ValueSource; import org.apache.lucene.util.Bits; @@ -132,7 +133,7 @@ final class NumericFacets { mincount = Math.max(mincount, 1); final SchemaField sf = searcher.getSchema().getField(fieldName); final FieldType ft = sf.getType(); - final org.apache.lucene.document.FieldType.LegacyNumericType numericType = ft.getNumericType(); + final LegacyNumericType numericType = ft.getNumericType(); if (numericType == null) { throw new IllegalStateException(); } diff --git a/solr/core/src/java/org/apache/solr/schema/BBoxField.java b/solr/core/src/java/org/apache/solr/schema/BBoxField.java index e41d3c6e4e0..d7fda7ce0da 100644 --- a/solr/core/src/java/org/apache/solr/schema/BBoxField.java +++ b/solr/core/src/java/org/apache/solr/schema/BBoxField.java @@ -23,6 +23,7 @@ import java.util.List; import java.util.Map; import org.apache.lucene.index.DocValuesType; +import org.apache.lucene.legacy.LegacyFieldType; import org.apache.lucene.queries.function.ValueSource; import org.apache.lucene.spatial.bbox.BBoxOverlapRatioValueSource; import org.apache.lucene.spatial.bbox.BBoxStrategy; @@ -141,7 +142,11 @@ public class BBoxField extends AbstractSpatialFieldType implements //and annoyingly this Field isn't going to have a docValues format because Solr uses a separate Field for that if (solrNumField.hasDocValues()) { - luceneType = new org.apache.lucene.document.FieldType(luceneType); + if (luceneType instanceof LegacyFieldType) { + luceneType = new LegacyFieldType((LegacyFieldType)luceneType); + } else { + luceneType = new org.apache.lucene.document.FieldType(luceneType); + } luceneType.setDocValuesType(DocValuesType.NUMERIC); } return new BBoxStrategy(ctx, fieldName, luceneType); diff --git a/solr/core/src/java/org/apache/solr/schema/EnumField.java b/solr/core/src/java/org/apache/solr/schema/EnumField.java index 27f3a0a1ea8..4820e77bb11 100644 --- a/solr/core/src/java/org/apache/solr/schema/EnumField.java +++ b/solr/core/src/java/org/apache/solr/schema/EnumField.java @@ -32,24 +32,25 @@ import javax.xml.xpath.XPathConstants; import javax.xml.xpath.XPathExpressionException; import javax.xml.xpath.XPathFactory; -import org.apache.lucene.document.FieldType; -import org.apache.lucene.document.LegacyIntField; import org.apache.lucene.document.NumericDocValuesField; import org.apache.lucene.document.SortedSetDocValuesField; import org.apache.lucene.index.IndexOptions; import org.apache.lucene.index.IndexableField; +import org.apache.lucene.legacy.LegacyFieldType; +import org.apache.lucene.legacy.LegacyIntField; +import org.apache.lucene.legacy.LegacyNumericRangeQuery; +import org.apache.lucene.legacy.LegacyNumericType; +import org.apache.lucene.legacy.LegacyNumericUtils; import org.apache.lucene.queries.function.ValueSource; import org.apache.lucene.queries.function.valuesource.EnumFieldSource; import org.apache.lucene.search.ConstantScoreQuery; import org.apache.lucene.search.DocValuesRangeQuery; -import org.apache.lucene.search.LegacyNumericRangeQuery; import org.apache.lucene.search.Query; import org.apache.lucene.search.SortField; import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.BytesRefBuilder; import org.apache.lucene.util.CharsRef; import org.apache.lucene.util.CharsRefBuilder; -import org.apache.lucene.util.LegacyNumericUtils; import org.apache.solr.common.EnumFieldValue; import org.apache.solr.common.SolrException; import org.apache.solr.response.TextResponseWriter; @@ -234,8 +235,8 @@ public class EnumField extends PrimitiveFieldType { * {@inheritDoc} */ @Override - public FieldType.LegacyNumericType getNumericType() { - return FieldType.LegacyNumericType.INT; + public LegacyNumericType getNumericType() { + return LegacyNumericType.INT; } /** @@ -387,7 +388,7 @@ public class EnumField extends PrimitiveFieldType { throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Unknown value for enum field: " + value.toString()); String intAsString = intValue.toString(); - final FieldType newType = new FieldType(); + final LegacyFieldType newType = new LegacyFieldType(); newType.setTokenized(field.isTokenized()); newType.setStored(field.stored()); @@ -397,7 +398,7 @@ public class EnumField extends PrimitiveFieldType { newType.setStoreTermVectorOffsets(field.storeTermOffsets()); newType.setStoreTermVectorPositions(field.storeTermPositions()); newType.setStoreTermVectorPayloads(field.storeTermPayloads()); - newType.setNumericType(FieldType.LegacyNumericType.INT); + newType.setNumericType(LegacyNumericType.INT); newType.setNumericPrecisionStep(DEFAULT_PRECISION_STEP); final org.apache.lucene.document.Field f; diff --git a/solr/core/src/java/org/apache/solr/schema/FieldType.java b/solr/core/src/java/org/apache/solr/schema/FieldType.java index 6556ddb77f6..32a91d98316 100644 --- a/solr/core/src/java/org/apache/solr/schema/FieldType.java +++ b/solr/core/src/java/org/apache/solr/schema/FieldType.java @@ -38,6 +38,7 @@ import org.apache.lucene.document.Field; import org.apache.lucene.index.IndexOptions; import org.apache.lucene.index.IndexableField; import org.apache.lucene.index.Term; +import org.apache.lucene.legacy.LegacyNumericType; import org.apache.lucene.queries.function.ValueSource; import org.apache.lucene.search.DocValuesRangeQuery; import org.apache.lucene.search.DocValuesRewriteMethod; @@ -621,7 +622,7 @@ public abstract class FieldType extends FieldProperties { /** Return the numeric type of this field, or null if this field is not a * numeric field. */ - public org.apache.lucene.document.FieldType.LegacyNumericType getNumericType() { + public LegacyNumericType getNumericType() { return null; } diff --git a/solr/core/src/java/org/apache/solr/schema/SpatialPointVectorFieldType.java b/solr/core/src/java/org/apache/solr/schema/SpatialPointVectorFieldType.java index 18d80a35146..f6bb782e515 100644 --- a/solr/core/src/java/org/apache/solr/schema/SpatialPointVectorFieldType.java +++ b/solr/core/src/java/org/apache/solr/schema/SpatialPointVectorFieldType.java @@ -20,6 +20,8 @@ import java.util.ArrayList; import java.util.List; import java.util.Map; +import org.apache.lucene.legacy.LegacyFieldType; +import org.apache.lucene.legacy.LegacyNumericType; import org.apache.lucene.spatial.vector.PointVectorStrategy; /** @@ -78,8 +80,8 @@ public class SpatialPointVectorFieldType extends AbstractSpatialFieldType * For each number being added to this field, multiple terms are generated as per the algorithm described in the above @@ -82,7 +82,7 @@ import org.slf4j.LoggerFactory; * generated, range search will be no faster than any other number field, but sorting will still be possible. * * - * @see org.apache.lucene.search.LegacyNumericRangeQuery + * @see org.apache.lucene.legacy.LegacyNumericRangeQuery * @since solr 1.4 */ public class TrieField extends PrimitiveFieldType { @@ -349,17 +349,17 @@ public class TrieField extends PrimitiveFieldType { } @Override - public FieldType.LegacyNumericType getNumericType() { + public LegacyNumericType getNumericType() { switch (type) { case INTEGER: - return FieldType.LegacyNumericType.INT; + return LegacyNumericType.INT; case LONG: case DATE: - return FieldType.LegacyNumericType.LONG; + return LegacyNumericType.LONG; case FLOAT: - return FieldType.LegacyNumericType.FLOAT; + return LegacyNumericType.FLOAT; case DOUBLE: - return FieldType.LegacyNumericType.DOUBLE; + return LegacyNumericType.DOUBLE; default: throw new AssertionError(); } @@ -666,7 +666,7 @@ public class TrieField extends PrimitiveFieldType { return null; } - FieldType ft = new FieldType(); + LegacyFieldType ft = new LegacyFieldType(); ft.setStored(stored); ft.setTokenized(true); ft.setOmitNorms(field.omitNorms()); @@ -677,16 +677,16 @@ public class TrieField extends PrimitiveFieldType { ft.setNumericType(LegacyNumericType.INT); break; case FLOAT: - ft.setNumericType(FieldType.LegacyNumericType.FLOAT); + ft.setNumericType(LegacyNumericType.FLOAT); break; case LONG: - ft.setNumericType(FieldType.LegacyNumericType.LONG); + ft.setNumericType(LegacyNumericType.LONG); break; case DOUBLE: - ft.setNumericType(FieldType.LegacyNumericType.DOUBLE); + ft.setNumericType(LegacyNumericType.DOUBLE); break; case DATE: - ft.setNumericType(FieldType.LegacyNumericType.LONG); + ft.setNumericType(LegacyNumericType.LONG); break; default: throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Unknown type for trie field: " + type); diff --git a/solr/core/src/java/org/apache/solr/schema/TrieFloatField.java b/solr/core/src/java/org/apache/solr/schema/TrieFloatField.java index 8d1739e6782..bcc4d4fe3b1 100644 --- a/solr/core/src/java/org/apache/solr/schema/TrieFloatField.java +++ b/solr/core/src/java/org/apache/solr/schema/TrieFloatField.java @@ -23,13 +23,13 @@ import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.index.DocValues; import org.apache.lucene.index.SortedDocValues; import org.apache.lucene.index.SortedSetDocValues; +import org.apache.lucene.legacy.LegacyNumericUtils; import org.apache.lucene.queries.function.ValueSource; import org.apache.lucene.queries.function.FunctionValues; import org.apache.lucene.queries.function.docvalues.FloatDocValues; import org.apache.lucene.queries.function.valuesource.SortedSetFieldSource; import org.apache.lucene.search.SortedSetSelector; import org.apache.lucene.util.BytesRef; -import org.apache.lucene.util.LegacyNumericUtils; import org.apache.lucene.util.NumericUtils; import org.apache.lucene.util.mutable.MutableValue; import org.apache.lucene.util.mutable.MutableValueFloat; diff --git a/solr/core/src/java/org/apache/solr/schema/TrieIntField.java b/solr/core/src/java/org/apache/solr/schema/TrieIntField.java index 07d9c74f472..6c8622b39e6 100644 --- a/solr/core/src/java/org/apache/solr/schema/TrieIntField.java +++ b/solr/core/src/java/org/apache/solr/schema/TrieIntField.java @@ -23,13 +23,13 @@ import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.index.DocValues; import org.apache.lucene.index.SortedDocValues; import org.apache.lucene.index.SortedSetDocValues; +import org.apache.lucene.legacy.LegacyNumericUtils; import org.apache.lucene.queries.function.ValueSource; import org.apache.lucene.queries.function.FunctionValues; import org.apache.lucene.queries.function.docvalues.IntDocValues; import org.apache.lucene.queries.function.valuesource.SortedSetFieldSource; import org.apache.lucene.search.SortedSetSelector; import org.apache.lucene.util.BytesRef; -import org.apache.lucene.util.LegacyNumericUtils; import org.apache.lucene.util.mutable.MutableValue; import org.apache.lucene.util.mutable.MutableValueInt; diff --git a/solr/core/src/java/org/apache/solr/schema/TrieLongField.java b/solr/core/src/java/org/apache/solr/schema/TrieLongField.java index 28345af9622..371d5bb0a14 100644 --- a/solr/core/src/java/org/apache/solr/schema/TrieLongField.java +++ b/solr/core/src/java/org/apache/solr/schema/TrieLongField.java @@ -23,13 +23,13 @@ import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.index.DocValues; import org.apache.lucene.index.SortedDocValues; import org.apache.lucene.index.SortedSetDocValues; +import org.apache.lucene.legacy.LegacyNumericUtils; import org.apache.lucene.queries.function.ValueSource; import org.apache.lucene.queries.function.FunctionValues; import org.apache.lucene.queries.function.docvalues.LongDocValues; import org.apache.lucene.queries.function.valuesource.SortedSetFieldSource; import org.apache.lucene.search.SortedSetSelector; import org.apache.lucene.util.BytesRef; -import org.apache.lucene.util.LegacyNumericUtils; import org.apache.lucene.util.mutable.MutableValue; import org.apache.lucene.util.mutable.MutableValueLong; diff --git a/solr/core/src/java/org/apache/solr/search/QueryParsing.java b/solr/core/src/java/org/apache/solr/search/QueryParsing.java index e7a6c3632fa..fb32c6e934d 100644 --- a/solr/core/src/java/org/apache/solr/search/QueryParsing.java +++ b/solr/core/src/java/org/apache/solr/search/QueryParsing.java @@ -17,12 +17,12 @@ package org.apache.solr.search; import org.apache.lucene.index.Term; +import org.apache.lucene.legacy.LegacyNumericRangeQuery; import org.apache.lucene.search.BooleanClause; import org.apache.lucene.search.BooleanQuery; import org.apache.lucene.search.BoostQuery; import org.apache.lucene.search.ConstantScoreQuery; import org.apache.lucene.search.FuzzyQuery; -import org.apache.lucene.search.LegacyNumericRangeQuery; import org.apache.lucene.search.PrefixQuery; import org.apache.lucene.search.Query; import org.apache.lucene.search.TermQuery; diff --git a/solr/core/src/java/org/apache/solr/search/QueryWrapperFilter.java b/solr/core/src/java/org/apache/solr/search/QueryWrapperFilter.java index 6bba1de2c64..d526cf394ab 100644 --- a/solr/core/src/java/org/apache/solr/search/QueryWrapperFilter.java +++ b/solr/core/src/java/org/apache/solr/search/QueryWrapperFilter.java @@ -34,7 +34,7 @@ import org.apache.lucene.util.Bits; * Constrains search results to only match those which also match a provided * query. * - *

    This could be used, for example, with a {@link org.apache.lucene.search.LegacyNumericRangeQuery} on a suitably + *

    This could be used, for example, with a {@link org.apache.lucene.legacy.LegacyNumericRangeQuery} on a suitably * formatted date field to implement date filtering. One could re-use a single * CachingWrapperFilter(QueryWrapperFilter) that matches, e.g., only documents modified * within the last week. This would only need to be reconstructed once per day. diff --git a/solr/core/src/java/org/apache/solr/search/facet/FacetField.java b/solr/core/src/java/org/apache/solr/search/facet/FacetField.java index c06e182eed3..92c64e74b16 100644 --- a/solr/core/src/java/org/apache/solr/search/facet/FacetField.java +++ b/solr/core/src/java/org/apache/solr/search/facet/FacetField.java @@ -19,6 +19,7 @@ package org.apache.solr.search.facet; import java.util.HashMap; import java.util.Map; +import org.apache.lucene.legacy.LegacyNumericType; import org.apache.solr.common.SolrException; import org.apache.solr.schema.FieldType; import org.apache.solr.schema.SchemaField; @@ -94,7 +95,7 @@ public class FacetField extends FacetRequest { return new FacetFieldProcessorByEnumTermsStream(fcontext, this, sf); } - org.apache.lucene.document.FieldType.LegacyNumericType ntype = ft.getNumericType(); + LegacyNumericType ntype = ft.getNumericType(); if (!multiToken) { if (ntype != null) { diff --git a/solr/core/src/java/org/apache/solr/search/mlt/CloudMLTQParser.java b/solr/core/src/java/org/apache/solr/search/mlt/CloudMLTQParser.java index 46b927efd97..0f85feb13c9 100644 --- a/solr/core/src/java/org/apache/solr/search/mlt/CloudMLTQParser.java +++ b/solr/core/src/java/org/apache/solr/search/mlt/CloudMLTQParser.java @@ -23,6 +23,7 @@ import java.util.Map; import java.util.regex.Pattern; import org.apache.lucene.index.Term; +import org.apache.lucene.legacy.LegacyNumericUtils; import org.apache.lucene.queries.mlt.MoreLikeThis; import org.apache.lucene.search.BooleanClause; import org.apache.lucene.search.BooleanQuery; @@ -30,7 +31,6 @@ import org.apache.lucene.search.BoostQuery; import org.apache.lucene.search.Query; import org.apache.lucene.search.TermQuery; import org.apache.lucene.util.BytesRefBuilder; -import org.apache.lucene.util.LegacyNumericUtils; import org.apache.solr.common.SolrDocument; import org.apache.solr.common.SolrException; import org.apache.solr.common.StringUtils; diff --git a/solr/core/src/java/org/apache/solr/search/mlt/SimpleMLTQParser.java b/solr/core/src/java/org/apache/solr/search/mlt/SimpleMLTQParser.java index 962f452e918..da3a4874681 100644 --- a/solr/core/src/java/org/apache/solr/search/mlt/SimpleMLTQParser.java +++ b/solr/core/src/java/org/apache/solr/search/mlt/SimpleMLTQParser.java @@ -16,6 +16,7 @@ */ package org.apache.solr.search.mlt; import org.apache.lucene.index.Term; +import org.apache.lucene.legacy.LegacyNumericUtils; import org.apache.lucene.queries.mlt.MoreLikeThis; import org.apache.lucene.search.BooleanClause; import org.apache.lucene.search.BooleanQuery; @@ -25,7 +26,6 @@ import org.apache.lucene.search.ScoreDoc; import org.apache.lucene.search.TermQuery; import org.apache.lucene.search.TopDocs; import org.apache.lucene.util.BytesRefBuilder; -import org.apache.lucene.util.LegacyNumericUtils; import org.apache.solr.common.SolrException; import org.apache.solr.common.StringUtils; import org.apache.solr.common.params.SolrParams; diff --git a/solr/core/src/java/org/apache/solr/uninverting/FieldCache.java b/solr/core/src/java/org/apache/solr/uninverting/FieldCache.java index 7ef495618e2..be08a603b40 100644 --- a/solr/core/src/java/org/apache/solr/uninverting/FieldCache.java +++ b/solr/core/src/java/org/apache/solr/uninverting/FieldCache.java @@ -28,10 +28,10 @@ import org.apache.lucene.index.SortedDocValues; import org.apache.lucene.index.SortedSetDocValues; import org.apache.lucene.index.Terms; import org.apache.lucene.index.TermsEnum; +import org.apache.lucene.legacy.LegacyNumericUtils; import org.apache.lucene.util.Accountable; import org.apache.lucene.util.Bits; import org.apache.lucene.util.BytesRef; -import org.apache.lucene.util.LegacyNumericUtils; import org.apache.lucene.util.NumericUtils; import org.apache.lucene.util.RamUsageEstimator; @@ -161,8 +161,8 @@ interface FieldCache { }; /** - * A parser instance for int values encoded by {@link org.apache.lucene.util.LegacyNumericUtils}, e.g. when indexed - * via {@link org.apache.lucene.document.LegacyIntField}/{@link org.apache.lucene.analysis.LegacyNumericTokenStream}. + * A parser instance for int values encoded by {@link org.apache.lucene.legacy.LegacyNumericUtils}, e.g. when indexed + * via {@link org.apache.lucene.legacy.LegacyIntField}/{@link org.apache.lucene.legacy.LegacyNumericTokenStream}. * @deprecated Index with points and use {@link #INT_POINT_PARSER} instead. */ @Deprecated @@ -184,8 +184,8 @@ interface FieldCache { }; /** - * A parser instance for float values encoded with {@link org.apache.lucene.util.LegacyNumericUtils}, e.g. when indexed - * via {@link org.apache.lucene.document.LegacyFloatField}/{@link org.apache.lucene.analysis.LegacyNumericTokenStream}. + * A parser instance for float values encoded with {@link org.apache.lucene.legacy.LegacyNumericUtils}, e.g. when indexed + * via {@link org.apache.lucene.legacy.LegacyFloatField}/{@link org.apache.lucene.legacy.LegacyNumericTokenStream}. * @deprecated Index with points and use {@link #FLOAT_POINT_PARSER} instead. */ @Deprecated @@ -209,8 +209,8 @@ interface FieldCache { }; /** - * A parser instance for long values encoded by {@link org.apache.lucene.util.LegacyNumericUtils}, e.g. when indexed - * via {@link org.apache.lucene.document.LegacyLongField}/{@link org.apache.lucene.analysis.LegacyNumericTokenStream}. + * A parser instance for long values encoded by {@link org.apache.lucene.legacy.LegacyNumericUtils}, e.g. when indexed + * via {@link org.apache.lucene.legacy.LegacyLongField}/{@link org.apache.lucene.legacy.LegacyNumericTokenStream}. * @deprecated Index with points and use {@link #LONG_POINT_PARSER} instead. */ @Deprecated @@ -231,8 +231,8 @@ interface FieldCache { }; /** - * A parser instance for double values encoded with {@link org.apache.lucene.util.LegacyNumericUtils}, e.g. when indexed - * via {@link org.apache.lucene.document.LegacyDoubleField}/{@link org.apache.lucene.analysis.LegacyNumericTokenStream}. + * A parser instance for double values encoded with {@link org.apache.lucene.legacy.LegacyNumericUtils}, e.g. when indexed + * via {@link org.apache.lucene.legacy.LegacyDoubleField}/{@link org.apache.lucene.legacy.LegacyNumericTokenStream}. * @deprecated Index with points and use {@link #DOUBLE_POINT_PARSER} instead. */ @Deprecated @@ -279,7 +279,7 @@ interface FieldCache { * @param parser * Computes long for string values. May be {@code null} if the * requested field was indexed as {@link NumericDocValuesField} or - * {@link org.apache.lucene.document.LegacyLongField}. + * {@link org.apache.lucene.legacy.LegacyLongField}. * @param setDocsWithField * If true then {@link #getDocsWithField} will also be computed and * stored in the FieldCache. diff --git a/solr/core/src/java/org/apache/solr/uninverting/UninvertingReader.java b/solr/core/src/java/org/apache/solr/uninverting/UninvertingReader.java index 4450cbb7d86..42b2f7628ba 100644 --- a/solr/core/src/java/org/apache/solr/uninverting/UninvertingReader.java +++ b/solr/core/src/java/org/apache/solr/uninverting/UninvertingReader.java @@ -86,7 +86,7 @@ public class UninvertingReader extends FilterLeafReader { */ DOUBLE_POINT, /** - * Single-valued Integer, (e.g. indexed with {@link org.apache.lucene.document.LegacyIntField}) + * Single-valued Integer, (e.g. indexed with {@link org.apache.lucene.legacy.LegacyIntField}) *

    * Fields with this type act as if they were indexed with * {@link NumericDocValuesField}. @@ -95,7 +95,7 @@ public class UninvertingReader extends FilterLeafReader { @Deprecated LEGACY_INTEGER, /** - * Single-valued Long, (e.g. indexed with {@link org.apache.lucene.document.LegacyLongField}) + * Single-valued Long, (e.g. indexed with {@link org.apache.lucene.legacy.LegacyLongField}) *

    * Fields with this type act as if they were indexed with * {@link NumericDocValuesField}. @@ -104,7 +104,7 @@ public class UninvertingReader extends FilterLeafReader { @Deprecated LEGACY_LONG, /** - * Single-valued Float, (e.g. indexed with {@link org.apache.lucene.document.LegacyFloatField}) + * Single-valued Float, (e.g. indexed with {@link org.apache.lucene.legacy.LegacyFloatField}) *

    * Fields with this type act as if they were indexed with * {@link NumericDocValuesField}. @@ -113,7 +113,7 @@ public class UninvertingReader extends FilterLeafReader { @Deprecated LEGACY_FLOAT, /** - * Single-valued Double, (e.g. indexed with {@link org.apache.lucene.document.LegacyDoubleField}) + * Single-valued Double, (e.g. indexed with {@link org.apache.lucene.legacy.LegacyDoubleField}) *

    * Fields with this type act as if they were indexed with * {@link NumericDocValuesField}. @@ -143,28 +143,28 @@ public class UninvertingReader extends FilterLeafReader { */ SORTED_SET_BINARY, /** - * Multi-valued Integer, (e.g. indexed with {@link org.apache.lucene.document.LegacyIntField}) + * Multi-valued Integer, (e.g. indexed with {@link org.apache.lucene.legacy.LegacyIntField}) *

    * Fields with this type act as if they were indexed with * {@link SortedSetDocValuesField}. */ SORTED_SET_INTEGER, /** - * Multi-valued Float, (e.g. indexed with {@link org.apache.lucene.document.LegacyFloatField}) + * Multi-valued Float, (e.g. indexed with {@link org.apache.lucene.legacy.LegacyFloatField}) *

    * Fields with this type act as if they were indexed with * {@link SortedSetDocValuesField}. */ SORTED_SET_FLOAT, /** - * Multi-valued Long, (e.g. indexed with {@link org.apache.lucene.document.LegacyLongField}) + * Multi-valued Long, (e.g. indexed with {@link org.apache.lucene.legacy.LegacyLongField}) *

    * Fields with this type act as if they were indexed with * {@link SortedSetDocValuesField}. */ SORTED_SET_LONG, /** - * Multi-valued Double, (e.g. indexed with {@link org.apache.lucene.document.LegacyDoubleField}) + * Multi-valued Double, (e.g. indexed with {@link org.apache.lucene.legacy.LegacyDoubleField}) *

    * Fields with this type act as if they were indexed with * {@link SortedSetDocValuesField}. diff --git a/solr/core/src/java/org/apache/solr/update/VersionInfo.java b/solr/core/src/java/org/apache/solr/update/VersionInfo.java index bee30f500d8..0003c24358b 100644 --- a/solr/core/src/java/org/apache/solr/update/VersionInfo.java +++ b/solr/core/src/java/org/apache/solr/update/VersionInfo.java @@ -25,12 +25,12 @@ import java.util.concurrent.locks.ReentrantReadWriteLock; import org.apache.lucene.index.LeafReader; import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.index.Terms; +import org.apache.lucene.legacy.LegacyNumericUtils; import org.apache.lucene.queries.function.FunctionValues; import org.apache.lucene.queries.function.ValueSource; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.util.BitUtil; import org.apache.lucene.util.BytesRef; -import org.apache.lucene.util.LegacyNumericUtils; import org.apache.solr.common.SolrException; import org.apache.solr.common.util.SuppressForbidden; import org.apache.solr.index.SlowCompositeReaderWrapper; diff --git a/solr/core/src/test/org/apache/solr/search/TestMaxScoreQueryParser.java b/solr/core/src/test/org/apache/solr/search/TestMaxScoreQueryParser.java index 32e3eb207c7..6059528d21f 100644 --- a/solr/core/src/test/org/apache/solr/search/TestMaxScoreQueryParser.java +++ b/solr/core/src/test/org/apache/solr/search/TestMaxScoreQueryParser.java @@ -17,6 +17,7 @@ package org.apache.solr.search; import org.apache.lucene.index.Term; +import org.apache.lucene.legacy.LegacyNumericRangeQuery; import org.apache.lucene.search.*; import org.apache.solr.common.params.ModifiableSolrParams; import org.apache.solr.util.AbstractSolrTestCase; diff --git a/solr/core/src/test/org/apache/solr/search/function/TestOrdValues.java b/solr/core/src/test/org/apache/solr/search/function/TestOrdValues.java index 785ee55883a..b3a70ae6d39 100644 --- a/solr/core/src/test/org/apache/solr/search/function/TestOrdValues.java +++ b/solr/core/src/test/org/apache/solr/search/function/TestOrdValues.java @@ -21,8 +21,6 @@ import org.apache.lucene.analysis.MockAnalyzer; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; import org.apache.lucene.document.FieldType; -import org.apache.lucene.document.LegacyFloatField; -import org.apache.lucene.document.LegacyIntField; import org.apache.lucene.document.NumericDocValuesField; import org.apache.lucene.document.SortedDocValuesField; import org.apache.lucene.document.TextField; @@ -31,6 +29,8 @@ import org.apache.lucene.index.DirectoryReader; import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.IndexWriterConfig; import org.apache.lucene.index.RandomIndexWriter; +import org.apache.lucene.legacy.LegacyFloatField; +import org.apache.lucene.legacy.LegacyIntField; import org.apache.lucene.queries.function.FunctionQuery; import org.apache.lucene.queries.function.ValueSource; import org.apache.lucene.queries.function.valuesource.FloatFieldSource; diff --git a/solr/core/src/test/org/apache/solr/uninverting/TestDocTermOrds.java b/solr/core/src/test/org/apache/solr/uninverting/TestDocTermOrds.java index f1627a6ee35..46339a75ba0 100644 --- a/solr/core/src/test/org/apache/solr/uninverting/TestDocTermOrds.java +++ b/solr/core/src/test/org/apache/solr/uninverting/TestDocTermOrds.java @@ -28,8 +28,6 @@ import org.apache.lucene.analysis.MockAnalyzer; import org.apache.lucene.codecs.Codec; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; -import org.apache.lucene.document.LegacyIntField; -import org.apache.lucene.document.LegacyLongField; import org.apache.lucene.document.StringField; import org.apache.lucene.index.DirectoryReader; import org.apache.lucene.index.DocValues; @@ -45,10 +43,12 @@ import org.apache.lucene.index.SortedSetDocValues; import org.apache.lucene.index.Term; import org.apache.lucene.index.Terms; import org.apache.lucene.index.TermsEnum.SeekStatus; +import org.apache.lucene.legacy.LegacyIntField; +import org.apache.lucene.legacy.LegacyLongField; +import org.apache.lucene.legacy.LegacyNumericUtils; import org.apache.lucene.index.TermsEnum; import org.apache.lucene.store.Directory; import org.apache.lucene.util.BytesRef; -import org.apache.lucene.util.LegacyNumericUtils; import org.apache.lucene.util.LuceneTestCase; import org.apache.lucene.util.StringHelper; import org.apache.lucene.util.TestUtil; diff --git a/solr/core/src/test/org/apache/solr/uninverting/TestFieldCacheSanityChecker.java b/solr/core/src/test/org/apache/solr/uninverting/TestFieldCacheSanityChecker.java index d54d5792447..a5958f9af60 100644 --- a/solr/core/src/test/org/apache/solr/uninverting/TestFieldCacheSanityChecker.java +++ b/solr/core/src/test/org/apache/solr/uninverting/TestFieldCacheSanityChecker.java @@ -21,14 +21,14 @@ import java.io.IOException; import org.apache.lucene.analysis.MockAnalyzer; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; -import org.apache.lucene.document.LegacyDoubleField; -import org.apache.lucene.document.LegacyFloatField; -import org.apache.lucene.document.LegacyIntField; -import org.apache.lucene.document.LegacyLongField; import org.apache.lucene.index.DirectoryReader; import org.apache.lucene.index.IndexWriter; import org.apache.lucene.index.LeafReader; import org.apache.lucene.index.MultiReader; +import org.apache.lucene.legacy.LegacyDoubleField; +import org.apache.lucene.legacy.LegacyFloatField; +import org.apache.lucene.legacy.LegacyIntField; +import org.apache.lucene.legacy.LegacyLongField; import org.apache.lucene.store.Directory; import org.apache.lucene.util.LuceneTestCase; import org.apache.solr.index.SlowCompositeReaderWrapper; diff --git a/solr/core/src/test/org/apache/solr/uninverting/TestFieldCacheSort.java b/solr/core/src/test/org/apache/solr/uninverting/TestFieldCacheSort.java index 34d92379b39..d53f610f653 100644 --- a/solr/core/src/test/org/apache/solr/uninverting/TestFieldCacheSort.java +++ b/solr/core/src/test/org/apache/solr/uninverting/TestFieldCacheSort.java @@ -24,13 +24,9 @@ import java.util.Map; import org.apache.lucene.analysis.MockAnalyzer; import org.apache.lucene.document.Document; import org.apache.lucene.document.DoublePoint; -import org.apache.lucene.document.LegacyDoubleField; import org.apache.lucene.document.Field; import org.apache.lucene.document.FloatPoint; import org.apache.lucene.document.IntPoint; -import org.apache.lucene.document.LegacyFloatField; -import org.apache.lucene.document.LegacyIntField; -import org.apache.lucene.document.LegacyLongField; import org.apache.lucene.document.LongPoint; import org.apache.lucene.document.StoredField; import org.apache.lucene.document.StringField; @@ -41,6 +37,10 @@ import org.apache.lucene.index.IndexWriterConfig; import org.apache.lucene.index.MultiReader; import org.apache.lucene.index.RandomIndexWriter; import org.apache.lucene.index.Term; +import org.apache.lucene.legacy.LegacyDoubleField; +import org.apache.lucene.legacy.LegacyFloatField; +import org.apache.lucene.legacy.LegacyIntField; +import org.apache.lucene.legacy.LegacyLongField; import org.apache.lucene.search.BooleanClause.Occur; import org.apache.lucene.search.BooleanQuery; import org.apache.lucene.search.IndexSearcher; diff --git a/solr/core/src/test/org/apache/solr/uninverting/TestLegacyFieldCache.java b/solr/core/src/test/org/apache/solr/uninverting/TestLegacyFieldCache.java index 1192f4b77c8..5220460d811 100644 --- a/solr/core/src/test/org/apache/solr/uninverting/TestLegacyFieldCache.java +++ b/solr/core/src/test/org/apache/solr/uninverting/TestLegacyFieldCache.java @@ -28,10 +28,6 @@ import org.apache.lucene.document.BinaryDocValuesField; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field.Store; import org.apache.lucene.document.Field; -import org.apache.lucene.document.LegacyDoubleField; -import org.apache.lucene.document.LegacyFloatField; -import org.apache.lucene.document.LegacyIntField; -import org.apache.lucene.document.LegacyLongField; import org.apache.lucene.document.NumericDocValuesField; import org.apache.lucene.document.SortedDocValuesField; import org.apache.lucene.document.SortedSetDocValuesField; @@ -45,11 +41,15 @@ import org.apache.lucene.index.NumericDocValues; import org.apache.lucene.index.RandomIndexWriter; import org.apache.lucene.index.Terms; import org.apache.lucene.index.TermsEnum; +import org.apache.lucene.legacy.LegacyDoubleField; +import org.apache.lucene.legacy.LegacyFloatField; +import org.apache.lucene.legacy.LegacyIntField; +import org.apache.lucene.legacy.LegacyLongField; +import org.apache.lucene.legacy.LegacyNumericUtils; import org.apache.lucene.store.Directory; import org.apache.lucene.util.Bits; import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.IOUtils; -import org.apache.lucene.util.LegacyNumericUtils; import org.apache.lucene.util.LuceneTestCase; import org.apache.lucene.util.TestUtil; import org.apache.solr.index.SlowCompositeReaderWrapper; diff --git a/solr/core/src/test/org/apache/solr/uninverting/TestNumericTerms32.java b/solr/core/src/test/org/apache/solr/uninverting/TestNumericTerms32.java index 2b861adb43d..6fed73b829f 100644 --- a/solr/core/src/test/org/apache/solr/uninverting/TestNumericTerms32.java +++ b/solr/core/src/test/org/apache/solr/uninverting/TestNumericTerms32.java @@ -21,12 +21,12 @@ import java.util.Map; import org.apache.lucene.analysis.MockAnalyzer; import org.apache.lucene.document.Document; -import org.apache.lucene.document.FieldType; -import org.apache.lucene.document.LegacyIntField; import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.RandomIndexWriter; +import org.apache.lucene.legacy.LegacyFieldType; +import org.apache.lucene.legacy.LegacyIntField; +import org.apache.lucene.legacy.LegacyNumericRangeQuery; import org.apache.lucene.search.IndexSearcher; -import org.apache.lucene.search.LegacyNumericRangeQuery; import org.apache.lucene.search.Query; import org.apache.lucene.search.ScoreDoc; import org.apache.lucene.search.Sort; @@ -62,17 +62,17 @@ public class TestNumericTerms32 extends LuceneTestCase { .setMaxBufferedDocs(TestUtil.nextInt(random(), 100, 1000)) .setMergePolicy(newLogMergePolicy())); - final FieldType storedInt = new FieldType(LegacyIntField.TYPE_NOT_STORED); + final LegacyFieldType storedInt = new LegacyFieldType(LegacyIntField.TYPE_NOT_STORED); storedInt.setStored(true); storedInt.freeze(); - final FieldType storedInt8 = new FieldType(storedInt); + final LegacyFieldType storedInt8 = new LegacyFieldType(storedInt); storedInt8.setNumericPrecisionStep(8); - final FieldType storedInt4 = new FieldType(storedInt); + final LegacyFieldType storedInt4 = new LegacyFieldType(storedInt); storedInt4.setNumericPrecisionStep(4); - final FieldType storedInt2 = new FieldType(storedInt); + final LegacyFieldType storedInt2 = new LegacyFieldType(storedInt); storedInt2.setNumericPrecisionStep(2); LegacyIntField diff --git a/solr/core/src/test/org/apache/solr/uninverting/TestNumericTerms64.java b/solr/core/src/test/org/apache/solr/uninverting/TestNumericTerms64.java index 4da8be98c0f..2f341b708c2 100644 --- a/solr/core/src/test/org/apache/solr/uninverting/TestNumericTerms64.java +++ b/solr/core/src/test/org/apache/solr/uninverting/TestNumericTerms64.java @@ -21,12 +21,12 @@ import java.util.Map; import org.apache.lucene.analysis.MockAnalyzer; import org.apache.lucene.document.Document; -import org.apache.lucene.document.FieldType; -import org.apache.lucene.document.LegacyLongField; import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.RandomIndexWriter; +import org.apache.lucene.legacy.LegacyFieldType; +import org.apache.lucene.legacy.LegacyLongField; +import org.apache.lucene.legacy.LegacyNumericRangeQuery; import org.apache.lucene.search.IndexSearcher; -import org.apache.lucene.search.LegacyNumericRangeQuery; import org.apache.lucene.search.Query; import org.apache.lucene.search.ScoreDoc; import org.apache.lucene.search.Sort; @@ -62,20 +62,20 @@ public class TestNumericTerms64 extends LuceneTestCase { .setMaxBufferedDocs(TestUtil.nextInt(random(), 100, 1000)) .setMergePolicy(newLogMergePolicy())); - final FieldType storedLong = new FieldType(LegacyLongField.TYPE_NOT_STORED); + final LegacyFieldType storedLong = new LegacyFieldType(LegacyLongField.TYPE_NOT_STORED); storedLong.setStored(true); storedLong.freeze(); - final FieldType storedLong8 = new FieldType(storedLong); + final LegacyFieldType storedLong8 = new LegacyFieldType(storedLong); storedLong8.setNumericPrecisionStep(8); - final FieldType storedLong4 = new FieldType(storedLong); + final LegacyFieldType storedLong4 = new LegacyFieldType(storedLong); storedLong4.setNumericPrecisionStep(4); - final FieldType storedLong6 = new FieldType(storedLong); + final LegacyFieldType storedLong6 = new LegacyFieldType(storedLong); storedLong6.setNumericPrecisionStep(6); - final FieldType storedLong2 = new FieldType(storedLong); + final LegacyFieldType storedLong2 = new LegacyFieldType(storedLong); storedLong2.setNumericPrecisionStep(2); LegacyLongField diff --git a/solr/core/src/test/org/apache/solr/uninverting/TestUninvertingReader.java b/solr/core/src/test/org/apache/solr/uninverting/TestUninvertingReader.java index 2ecc63e6d11..c0188e4358c 100644 --- a/solr/core/src/test/org/apache/solr/uninverting/TestUninvertingReader.java +++ b/solr/core/src/test/org/apache/solr/uninverting/TestUninvertingReader.java @@ -28,10 +28,7 @@ import java.util.Set; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field.Store; import org.apache.lucene.document.Field; -import org.apache.lucene.document.FieldType; import org.apache.lucene.document.IntPoint; -import org.apache.lucene.document.LegacyIntField; -import org.apache.lucene.document.LegacyLongField; import org.apache.lucene.document.NumericDocValuesField; import org.apache.lucene.document.StoredField; import org.apache.lucene.document.StringField; @@ -43,9 +40,12 @@ import org.apache.lucene.index.IndexWriter; import org.apache.lucene.index.LeafReader; import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.index.SortedSetDocValues; +import org.apache.lucene.legacy.LegacyFieldType; +import org.apache.lucene.legacy.LegacyIntField; +import org.apache.lucene.legacy.LegacyLongField; +import org.apache.lucene.legacy.LegacyNumericUtils; import org.apache.lucene.store.Directory; import org.apache.lucene.util.BytesRef; -import org.apache.lucene.util.LegacyNumericUtils; import org.apache.lucene.util.LuceneTestCase; import org.apache.lucene.util.TestUtil; import org.apache.solr.index.SlowCompositeReaderWrapper; @@ -224,7 +224,7 @@ public class TestUninvertingReader extends LuceneTestCase { final Directory dir = newDirectory(); final IndexWriter iw = new IndexWriter(dir, newIndexWriterConfig(null)); - final FieldType NO_TRIE_TYPE = new FieldType(LegacyIntField.TYPE_NOT_STORED); + final LegacyFieldType NO_TRIE_TYPE = new LegacyFieldType(LegacyIntField.TYPE_NOT_STORED); NO_TRIE_TYPE.setNumericPrecisionStep(Integer.MAX_VALUE); final Map UNINVERT_MAP = new LinkedHashMap();

    Attribute name