You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by rm...@apache.org on 2021/03/15 03:11:53 UTC
[lucene] branch main updated: LUCENE-9796: Fix SortedDocValues to
no longer extend BinaryDocValues
This is an automated email from the ASF dual-hosted git repository.
rmuir pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/lucene.git
The following commit(s) were added to refs/heads/main by this push:
new f3a284a LUCENE-9796: Fix SortedDocValues to no longer extend BinaryDocValues
f3a284a is described below
commit f3a284ad830b9473467b5cb364408db5e4cc607f
Author: Robert Muir <rm...@apache.org>
AuthorDate: Sun Mar 14 23:07:48 2021 -0400
LUCENE-9796: Fix SortedDocValues to no longer extend BinaryDocValues
SortedDocValues do not have a per-document binary value, they have a
per-document numeric `ordValue()`. The ordinal can then be dereferenced
to its binary form with `lookupOrd()`, but it was a performance trap to
implement a `binaryValue()` on the SortedDocValues api that does this
behind-the-scenes on every document.
You can replace calls of `binaryValue()` with `lookupOrd(ordValue())`
as a "quick fix", but it is better to use the ordinal alone
(integer-based datastructures) for per-document access, and only call
lookupOrd() a few times at the end (e.g. for the hits you want to display).
Otherwise, if you really don't want per-document ordinals, but instead a
per-document `byte[]`, use a BinaryDocValues field.
This change only addresses the API (slow `binaryValue()` trap), but
doesn't yet fix any slow algorithms that were discovered in the process,
so it doesn't yield any performance improvements.
---
lucene/CHANGES.txt | 3 ++
lucene/MIGRATE.md | 13 +++++
.../collation/TestCollationDocValuesField.java | 2 +-
.../icu/TestICUCollationDocValuesField.java | 2 +-
.../backward_index/TestBackwardsCompatibility.java | 4 +-
.../java/org/apache/lucene/index/DocValues.java | 9 ++--
.../apache/lucene/index/FilterSortedDocValues.java | 5 --
.../org/apache/lucene/index/SortedDocValues.java | 14 +-----
.../lucene/index/TestBinaryDocValuesUpdates.java | 4 +-
.../org/apache/lucene/index/TestDocValues.java | 6 ++-
.../apache/lucene/index/TestDocValuesIndexing.java | 6 +--
.../org/apache/lucene/index/TestIndexSorting.java | 22 ++++-----
.../apache/lucene/index/TestMultiDocValues.java | 8 ++--
.../lucene/index/TestNumericDocValuesUpdates.java | 4 +-
.../lucene/index/TestSortingCodecReader.java | 4 +-
.../lucene/search/TestElevationComparator.java | 2 +-
.../test/org/apache/lucene/search/TestSort.java | 56 ----------------------
.../org/apache/lucene/search/TestSortRandom.java | 4 --
.../lucene/search/grouping/TermGroupSelector.java | 2 +-
.../search/join/DocValuesTermsCollector.java | 6 +--
.../lucene/search/join/GenericTermsCollector.java | 4 +-
.../org/apache/lucene/search/join/JoinUtil.java | 3 +-
.../apache/lucene/search/join/TermsCollector.java | 10 ++--
.../search/join/TermsWithScoreCollector.java | 16 +++----
.../apache/lucene/search/join/TestJoinUtil.java | 13 +++--
.../luke/models/documents/DocValuesAdapter.java | 2 +-
.../apache/lucene/index/memory/MemoryIndex.java | 37 +++++++++++++-
.../lucene/index/memory/TestMemoryIndex.java | 2 +-
.../memory/TestMemoryIndexAgainstDirectory.java | 1 -
.../apache/lucene/misc/search/DocValuesStats.java | 2 +-
.../search/TestDiversifiedTopDocsCollector.java | 7 ++-
.../java/org/apache/lucene/monitor/QueryIndex.java | 4 +-
.../function/docvalues/DocTermsIndexDocValues.java | 4 +-
.../valuesource/JoinDocFreqValueSource.java | 6 +--
.../apache/lucene/index/AssertingLeafReader.java | 8 ----
.../lucene/index/BaseDocValuesFormatTestCase.java | 26 +++++-----
.../org/apache/lucene/util/LuceneTestCase.java | 4 +-
37 files changed, 145 insertions(+), 180 deletions(-)
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txt
index 4aa3164..05eecb9 100644
--- a/lucene/CHANGES.txt
+++ b/lucene/CHANGES.txt
@@ -92,6 +92,9 @@ API Changes
* LUCENE-9480: Make DataInput's skipBytes(long) abstract as the implementation was not performant.
IndexInput's api is unaffected: skipBytes() is implemented via seek(). (Greg Miller)
+* LUCENE-9796: SortedDocValues no longer extends BinaryDocValues, as binaryValue() was not performant.
+ See MIGRATE.md for details. (Robert Muir)
+
Improvements
* LUCENE-9687: Hunspell support improvements: add API for spell-checking and suggestions, support compound words,
diff --git a/lucene/MIGRATE.md b/lucene/MIGRATE.md
index c531735..37ca344 100644
--- a/lucene/MIGRATE.md
+++ b/lucene/MIGRATE.md
@@ -363,3 +363,16 @@ used in multi level applications
Sorting on a numeric field that is indexed with both doc values and points may use an
optimization to skip non-competitive documents. This optimization relies on the assumption
that the same data is stored in these points and doc values.
+
+## SortedDocValues no longer extends BinaryDocValues (LUCENE-9796)
+
+SortedDocValues no longer extends BinaryDocValues: SortedDocValues do not have a per-document
+binary value, they have a per-document numeric `ordValue()`. The ordinal can then be dereferenced
+to its binary form with `lookupOrd()`, but it was a performance trap to implement a `binaryValue()`
+on the SortedDocValues api that does this behind-the-scenes on every document.
+
+You can replace calls of `binaryValue()` with `lookupOrd(ordValue())` as a "quick fix", but it is
+better to use the ordinal alone (integer-based datastructures) for per-document access, and only
+call lookupOrd() a few times at the end (e.g. for the hits you want to display). Otherwise, if you
+really don't want per-document ordinals, but instead a per-document `byte[]`, use a BinaryDocValues
+field.
diff --git a/lucene/analysis/common/src/test/org/apache/lucene/collation/TestCollationDocValuesField.java b/lucene/analysis/common/src/test/org/apache/lucene/collation/TestCollationDocValuesField.java
index c62cee4..69ab63c 100644
--- a/lucene/analysis/common/src/test/org/apache/lucene/collation/TestCollationDocValuesField.java
+++ b/lucene/analysis/common/src/test/org/apache/lucene/collation/TestCollationDocValuesField.java
@@ -126,7 +126,7 @@ public class TestCollationDocValuesField extends LuceneTestCase {
boolean collatorAccepts =
collate(collator, s, startPoint) >= 0 && collate(collator, s, endPoint) <= 0;
assertEquals(docID, dvs.nextDoc());
- BytesRef br = dvs.binaryValue();
+ BytesRef br = dvs.lookupOrd(dvs.ordValue());
boolean luceneAccepts = br.compareTo(startBR) >= 0 && br.compareTo(endBR) <= 0;
assertEquals(startPoint + " <= " + s + " <= " + endPoint, collatorAccepts, luceneAccepts);
}
diff --git a/lucene/analysis/icu/src/test/org/apache/lucene/analysis/icu/TestICUCollationDocValuesField.java b/lucene/analysis/icu/src/test/org/apache/lucene/analysis/icu/TestICUCollationDocValuesField.java
index a53a928..dd6fb5a 100644
--- a/lucene/analysis/icu/src/test/org/apache/lucene/analysis/icu/TestICUCollationDocValuesField.java
+++ b/lucene/analysis/icu/src/test/org/apache/lucene/analysis/icu/TestICUCollationDocValuesField.java
@@ -124,7 +124,7 @@ public class TestICUCollationDocValuesField extends LuceneTestCase {
boolean collatorAccepts =
collator.compare(s, startPoint) >= 0 && collator.compare(s, endPoint) <= 0;
assertEquals(docID, dvs.nextDoc());
- BytesRef br = dvs.binaryValue();
+ BytesRef br = dvs.lookupOrd(dvs.ordValue());
boolean luceneAccepts = br.compareTo(startBR) >= 0 && br.compareTo(endBR) <= 0;
assertEquals(collatorAccepts, luceneAccepts);
}
diff --git a/lucene/backward-codecs/src/test/org/apache/lucene/backward_index/TestBackwardsCompatibility.java b/lucene/backward-codecs/src/test/org/apache/lucene/backward_index/TestBackwardsCompatibility.java
index 4ad3801..cffb5b5 100644
--- a/lucene/backward-codecs/src/test/org/apache/lucene/backward_index/TestBackwardsCompatibility.java
+++ b/lucene/backward-codecs/src/test/org/apache/lucene/backward_index/TestBackwardsCompatibility.java
@@ -1146,10 +1146,10 @@ public class TestBackwardsCompatibility extends LuceneTestCase {
term = dvBytesDerefVar.binaryValue();
assertEquals(expectedRef, term);
assertEquals(i, dvBytesSortedFixed.nextDoc());
- term = dvBytesSortedFixed.binaryValue();
+ term = dvBytesSortedFixed.lookupOrd(dvBytesSortedFixed.ordValue());
assertEquals(expectedRef, term);
assertEquals(i, dvBytesSortedVar.nextDoc());
- term = dvBytesSortedVar.binaryValue();
+ term = dvBytesSortedVar.lookupOrd(dvBytesSortedVar.ordValue());
assertEquals(expectedRef, term);
assertEquals(i, dvBytesStraightFixed.nextDoc());
term = dvBytesStraightFixed.binaryValue();
diff --git a/lucene/core/src/java/org/apache/lucene/index/DocValues.java b/lucene/core/src/java/org/apache/lucene/index/DocValues.java
index e78a666..6741ae6 100644
--- a/lucene/core/src/java/org/apache/lucene/index/DocValues.java
+++ b/lucene/core/src/java/org/apache/lucene/index/DocValues.java
@@ -333,17 +333,14 @@ public final class DocValues {
* reader.
* @throws IllegalStateException if {@code field} exists, but was not indexed with docvalues.
* @throws IllegalStateException if {@code field} has docvalues, but the type is not {@link
- * DocValuesType#BINARY} or {@link DocValuesType#SORTED}.
+ * DocValuesType#BINARY}.
* @throws IOException if an I/O error occurs.
*/
public static BinaryDocValues getBinary(LeafReader reader, String field) throws IOException {
BinaryDocValues dv = reader.getBinaryDocValues(field);
if (dv == null) {
- dv = reader.getSortedDocValues(field);
- if (dv == null) {
- checkField(reader, field, DocValuesType.BINARY, DocValuesType.SORTED);
- return emptyBinary();
- }
+ checkField(reader, field, DocValuesType.BINARY);
+ return emptyBinary();
}
return dv;
}
diff --git a/lucene/core/src/java/org/apache/lucene/index/FilterSortedDocValues.java b/lucene/core/src/java/org/apache/lucene/index/FilterSortedDocValues.java
index 290265f..01c8e3e 100644
--- a/lucene/core/src/java/org/apache/lucene/index/FilterSortedDocValues.java
+++ b/lucene/core/src/java/org/apache/lucene/index/FilterSortedDocValues.java
@@ -49,11 +49,6 @@ public abstract class FilterSortedDocValues extends SortedDocValues {
}
@Override
- public BytesRef binaryValue() throws IOException {
- return in.binaryValue();
- }
-
- @Override
public int getValueCount() {
return in.getValueCount();
}
diff --git a/lucene/core/src/java/org/apache/lucene/index/SortedDocValues.java b/lucene/core/src/java/org/apache/lucene/index/SortedDocValues.java
index 1132c42..15bc16a 100644
--- a/lucene/core/src/java/org/apache/lucene/index/SortedDocValues.java
+++ b/lucene/core/src/java/org/apache/lucene/index/SortedDocValues.java
@@ -28,7 +28,7 @@ import org.apache.lucene.util.automaton.CompiledAutomaton;
* dictionary of unique values. A pointer to the dictionary value (ordinal) can be retrieved for
* each document. Ordinals are dense and in increasing sorted order.
*/
-public abstract class SortedDocValues extends BinaryDocValues {
+public abstract class SortedDocValues extends DocValuesIterator {
/** Sole constructor. (For invocation by subclass constructors, typically implicit.) */
protected SortedDocValues() {}
@@ -52,18 +52,6 @@ public abstract class SortedDocValues extends BinaryDocValues {
*/
public abstract BytesRef lookupOrd(int ord) throws IOException;
- private final BytesRef empty = new BytesRef();
-
- @Override
- public BytesRef binaryValue() throws IOException {
- int ord = ordValue();
- if (ord == -1) {
- return empty;
- } else {
- return lookupOrd(ord);
- }
- }
-
/**
* Returns the number of unique values.
*
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestBinaryDocValuesUpdates.java b/lucene/core/src/test/org/apache/lucene/index/TestBinaryDocValuesUpdates.java
index 8e9ca76..74658ad 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestBinaryDocValuesUpdates.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestBinaryDocValuesUpdates.java
@@ -358,7 +358,7 @@ public class TestBinaryDocValuesUpdates extends LuceneTestCase {
assertEquals(i, bdv.nextDoc());
assertEquals(17, getValue(bdv));
assertEquals(i, sdv.nextDoc());
- BytesRef term = sdv.binaryValue();
+ BytesRef term = sdv.lookupOrd(sdv.ordValue());
assertEquals(new BytesRef(Integer.toString(i)), term);
assertEquals(i, ssdv.nextDoc());
long ord = ssdv.nextOrd();
@@ -507,7 +507,7 @@ public class TestBinaryDocValuesUpdates extends LuceneTestCase {
assertEquals(i, bdv.nextDoc());
assertEquals(17, getValue(bdv));
assertEquals(i, sdv.nextDoc());
- BytesRef term = sdv.binaryValue();
+ BytesRef term = sdv.lookupOrd(sdv.ordValue());
assertEquals(new BytesRef("value"), term);
}
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestDocValues.java b/lucene/core/src/test/org/apache/lucene/index/TestDocValues.java
index 90d28a4..5ad74ee 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestDocValues.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestDocValues.java
@@ -185,7 +185,6 @@ public class TestDocValues extends LuceneTestCase {
LeafReader r = getOnlyLeafReader(dr);
// ok
- assertNotNull(DocValues.getBinary(r, "foo"));
assertNotNull(DocValues.getSorted(r, "foo"));
assertNotNull(DocValues.getSortedSet(r, "foo"));
@@ -193,6 +192,11 @@ public class TestDocValues extends LuceneTestCase {
expectThrows(
IllegalStateException.class,
() -> {
+ DocValues.getBinary(r, "foo");
+ });
+ expectThrows(
+ IllegalStateException.class,
+ () -> {
DocValues.getNumeric(r, "foo");
});
expectThrows(
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestDocValuesIndexing.java b/lucene/core/src/test/org/apache/lucene/index/TestDocValuesIndexing.java
index 3ab3741..eef214c 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestDocValuesIndexing.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestDocValuesIndexing.java
@@ -178,15 +178,15 @@ public class TestDocValuesIndexing extends LuceneTestCase {
w.addDocument(doc);
w.forceMerge(1);
DirectoryReader r = w.getReader();
- BinaryDocValues s = DocValues.getBinary(getOnlyLeafReader(r), "field");
+ SortedDocValues s = DocValues.getSorted(getOnlyLeafReader(r), "field");
assertEquals(0, s.nextDoc());
- BytesRef bytes1 = s.binaryValue();
+ BytesRef bytes1 = s.lookupOrd(s.ordValue());
assertEquals(bytes.length, bytes1.length);
bytes[0] = 0;
assertEquals(b, bytes1);
assertEquals(1, s.nextDoc());
- bytes1 = s.binaryValue();
+ bytes1 = s.lookupOrd(s.ordValue());
assertEquals(bytes.length, bytes1.length);
bytes[0] = 1;
assertEquals(b, bytes1);
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestIndexSorting.java b/lucene/core/src/test/org/apache/lucene/index/TestIndexSorting.java
index db9c587..deb938d 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestIndexSorting.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestIndexSorting.java
@@ -307,11 +307,11 @@ public class TestIndexSorting extends LuceneTestCase {
assertEquals(3, leaf.maxDoc());
SortedDocValues values = leaf.getSortedDocValues("foo");
assertEquals(0, values.nextDoc());
- assertEquals("aaa", values.binaryValue().utf8ToString());
+ assertEquals("aaa", values.lookupOrd(values.ordValue()).utf8ToString());
assertEquals(1, values.nextDoc());
- assertEquals("mmm", values.binaryValue().utf8ToString());
+ assertEquals("mmm", values.lookupOrd(values.ordValue()).utf8ToString());
assertEquals(2, values.nextDoc());
- assertEquals("zzz", values.binaryValue().utf8ToString());
+ assertEquals("zzz", values.lookupOrd(values.ordValue()).utf8ToString());
r.close();
w.close();
dir.close();
@@ -392,15 +392,15 @@ public class TestIndexSorting extends LuceneTestCase {
SortedDocValues values = leaf.getSortedDocValues("foo");
if (reverse) {
assertEquals(0, values.nextDoc());
- assertEquals("zzz", values.binaryValue().utf8ToString());
+ assertEquals("zzz", values.lookupOrd(values.ordValue()).utf8ToString());
assertEquals(1, values.nextDoc());
- assertEquals("mmm", values.binaryValue().utf8ToString());
+ assertEquals("mmm", values.lookupOrd(values.ordValue()).utf8ToString());
} else {
// docID 0 is missing:
assertEquals(1, values.nextDoc());
- assertEquals("mmm", values.binaryValue().utf8ToString());
+ assertEquals("mmm", values.lookupOrd(values.ordValue()).utf8ToString());
assertEquals(2, values.nextDoc());
- assertEquals("zzz", values.binaryValue().utf8ToString());
+ assertEquals("zzz", values.lookupOrd(values.ordValue()).utf8ToString());
}
r.close();
w.close();
@@ -496,14 +496,14 @@ public class TestIndexSorting extends LuceneTestCase {
SortedDocValues values = leaf.getSortedDocValues("foo");
if (reverse) {
assertEquals(1, values.nextDoc());
- assertEquals("zzz", values.binaryValue().utf8ToString());
+ assertEquals("zzz", values.lookupOrd(values.ordValue()).utf8ToString());
assertEquals(2, values.nextDoc());
- assertEquals("mmm", values.binaryValue().utf8ToString());
+ assertEquals("mmm", values.lookupOrd(values.ordValue()).utf8ToString());
} else {
assertEquals(0, values.nextDoc());
- assertEquals("mmm", values.binaryValue().utf8ToString());
+ assertEquals("mmm", values.lookupOrd(values.ordValue()).utf8ToString());
assertEquals(1, values.nextDoc());
- assertEquals("zzz", values.binaryValue().utf8ToString());
+ assertEquals("zzz", values.lookupOrd(values.ordValue()).utf8ToString());
}
assertEquals(NO_MORE_DOCS, values.nextDoc());
r.close();
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestMultiDocValues.java b/lucene/core/src/test/org/apache/lucene/index/TestMultiDocValues.java
index 1ec775c..0cbde11 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestMultiDocValues.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestMultiDocValues.java
@@ -163,8 +163,8 @@ public class TestMultiDocValues extends LuceneTestCase {
}
// check value
- final BytesRef expected = BytesRef.deepCopyOf(single.binaryValue());
- final BytesRef actual = multi.binaryValue();
+ final BytesRef expected = BytesRef.deepCopyOf(single.lookupOrd(single.ordValue()));
+ final BytesRef actual = multi.lookupOrd(multi.ordValue());
assertEquals(expected, actual);
// check ord
@@ -216,8 +216,8 @@ public class TestMultiDocValues extends LuceneTestCase {
// check ord
assertEquals(single.ordValue(), multi.ordValue());
// check ord value
- final BytesRef expected = BytesRef.deepCopyOf(single.binaryValue());
- final BytesRef actual = multi.binaryValue();
+ final BytesRef expected = BytesRef.deepCopyOf(single.lookupOrd(single.ordValue()));
+ final BytesRef actual = multi.lookupOrd(multi.ordValue());
assertEquals(expected, actual);
}
testRandomAdvance(
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestNumericDocValuesUpdates.java b/lucene/core/src/test/org/apache/lucene/index/TestNumericDocValuesUpdates.java
index c98c7b2..0d54180 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestNumericDocValuesUpdates.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestNumericDocValuesUpdates.java
@@ -456,7 +456,7 @@ public class TestNumericDocValuesUpdates extends LuceneTestCase {
BytesRef term = bdv.binaryValue();
assertEquals(new BytesRef(Integer.toString(i)), term);
assertEquals(i, sdv.nextDoc());
- term = sdv.binaryValue();
+ term = sdv.lookupOrd(sdv.ordValue());
assertEquals(new BytesRef(Integer.toString(i)), term);
assertEquals(i, ssdv.nextDoc());
@@ -615,7 +615,7 @@ public class TestNumericDocValuesUpdates extends LuceneTestCase {
assertEquals(i, ndv.nextDoc());
assertEquals(17, ndv.longValue());
assertEquals(i, sdv.nextDoc());
- final BytesRef term = sdv.binaryValue();
+ final BytesRef term = sdv.lookupOrd(sdv.ordValue());
assertEquals(new BytesRef("value"), term);
}
diff --git a/lucene/core/src/test/org/apache/lucene/index/TestSortingCodecReader.java b/lucene/core/src/test/org/apache/lucene/index/TestSortingCodecReader.java
index db1a1ee..2bc6b16 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestSortingCodecReader.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestSortingCodecReader.java
@@ -223,7 +223,9 @@ public class TestSortingCodecReader extends LuceneTestCase {
assertTrue(binary_sorted_dv.advanceExact(idNext));
assertEquals(idNext, vectorValues.advance(idNext));
assertEquals(new BytesRef(ids.longValue() + ""), binary_dv.binaryValue());
- assertEquals(new BytesRef(ids.longValue() + ""), binary_sorted_dv.binaryValue());
+ assertEquals(
+ new BytesRef(ids.longValue() + ""),
+ binary_sorted_dv.lookupOrd(binary_sorted_dv.ordValue()));
assertEquals(
new BytesRef(ids.longValue() + ""),
sorted_set_dv.lookupOrd(sorted_set_dv.nextOrd()));
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestElevationComparator.java b/lucene/core/src/test/org/apache/lucene/search/TestElevationComparator.java
index 8d0e634..a5b1c75 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestElevationComparator.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestElevationComparator.java
@@ -174,7 +174,7 @@ class ElevationComparatorSource extends FieldComparatorSource {
private int docVal(int doc) throws IOException {
SortedDocValues idIndex = DocValues.getSorted(context.reader(), fieldname);
if (idIndex.advance(doc) == doc) {
- final BytesRef term = idIndex.binaryValue();
+ final BytesRef term = idIndex.lookupOrd(idIndex.ordValue());
Integer prio = priority.get(term);
return prio == null ? 0 : prio.intValue();
} else {
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestSort.java b/lucene/core/src/test/org/apache/lucene/search/TestSort.java
index 783f049..448e28d 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestSort.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestSort.java
@@ -193,62 +193,6 @@ public class TestSort extends LuceneTestCase {
dir.close();
}
- /** Tests sorting on type string_val, but with a SortedDocValuesField */
- public void testStringValSorted() throws IOException {
- Directory dir = newDirectory();
- RandomIndexWriter writer = new RandomIndexWriter(random(), dir);
- Document doc = new Document();
- doc.add(new SortedDocValuesField("value", new BytesRef("foo")));
- doc.add(newStringField("value", "foo", Field.Store.YES));
- writer.addDocument(doc);
- doc = new Document();
- doc.add(new SortedDocValuesField("value", new BytesRef("bar")));
- doc.add(newStringField("value", "bar", Field.Store.YES));
- writer.addDocument(doc);
- IndexReader ir = writer.getReader();
- writer.close();
-
- IndexSearcher searcher = newSearcher(ir);
- Sort sort = new Sort(new SortField("value", SortField.Type.STRING_VAL));
-
- TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
- assertEquals(2, td.totalHits.value);
- // 'bar' comes before 'foo'
- assertEquals("bar", searcher.doc(td.scoreDocs[0].doc).get("value"));
- assertEquals("foo", searcher.doc(td.scoreDocs[1].doc).get("value"));
-
- ir.close();
- dir.close();
- }
-
- /** Tests reverse sorting on type string_val, but with a SortedDocValuesField */
- public void testStringValReverseSorted() throws IOException {
- Directory dir = newDirectory();
- RandomIndexWriter writer = new RandomIndexWriter(random(), dir);
- Document doc = new Document();
- doc.add(new SortedDocValuesField("value", new BytesRef("bar")));
- doc.add(newStringField("value", "bar", Field.Store.YES));
- writer.addDocument(doc);
- doc = new Document();
- doc.add(new SortedDocValuesField("value", new BytesRef("foo")));
- doc.add(newStringField("value", "foo", Field.Store.YES));
- writer.addDocument(doc);
- IndexReader ir = writer.getReader();
- writer.close();
-
- IndexSearcher searcher = newSearcher(ir);
- Sort sort = new Sort(new SortField("value", SortField.Type.STRING_VAL, true));
-
- TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
- assertEquals(2, td.totalHits.value);
- // 'foo' comes after 'bar' in reverse order
- assertEquals("foo", searcher.doc(td.scoreDocs[0].doc).get("value"));
- assertEquals("bar", searcher.doc(td.scoreDocs[1].doc).get("value"));
-
- ir.close();
- dir.close();
- }
-
/** Tests sorting on type int */
public void testInt() throws IOException {
Directory dir = newDirectory();
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestSortRandom.java b/lucene/core/src/test/org/apache/lucene/search/TestSortRandom.java
index ba9ca0a..5637279 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestSortRandom.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestSortRandom.java
@@ -48,10 +48,6 @@ public class TestSortRandom extends LuceneTestCase {
testRandomStringSort(SortField.Type.STRING);
}
- public void testRandomStringValSort() throws Exception {
- testRandomStringSort(SortField.Type.STRING_VAL);
- }
-
private void testRandomStringSort(SortField.Type type) throws Exception {
Random random = new Random(random().nextLong());
diff --git a/lucene/grouping/src/java/org/apache/lucene/search/grouping/TermGroupSelector.java b/lucene/grouping/src/java/org/apache/lucene/search/grouping/TermGroupSelector.java
index 802776e..5cedebb 100644
--- a/lucene/grouping/src/java/org/apache/lucene/search/grouping/TermGroupSelector.java
+++ b/lucene/grouping/src/java/org/apache/lucene/search/grouping/TermGroupSelector.java
@@ -81,7 +81,7 @@ public class TermGroupSelector extends GroupSelector<BytesRef> {
if (secondPass) {
return State.SKIP;
}
- groupId = values.add(docValues.binaryValue());
+ groupId = values.add(docValues.lookupOrd(docValues.ordValue()));
ordsToGroupIds.put(ord, groupId);
return State.ACCEPT;
}
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 fc6cb79..d7ed0d3 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
@@ -17,10 +17,10 @@
package org.apache.lucene.search.join;
import java.io.IOException;
-import org.apache.lucene.index.BinaryDocValues;
import org.apache.lucene.index.DocValues;
import org.apache.lucene.index.LeafReader;
import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.index.SortedDocValues;
import org.apache.lucene.index.SortedSetDocValues;
import org.apache.lucene.search.SimpleCollector;
@@ -43,8 +43,8 @@ abstract class DocValuesTermsCollector<DV> extends SimpleCollector {
docValues = docValuesCall.apply(context.reader());
}
- static Function<BinaryDocValues> binaryDocValues(String field) {
- return (ctx) -> DocValues.getBinary(ctx, field);
+ static Function<SortedDocValues> sortedDocValues(String field) {
+ return (ctx) -> DocValues.getSorted(ctx, field);
}
static Function<SortedSetDocValues> sortedSetDocValues(String field) {
diff --git a/lucene/join/src/java/org/apache/lucene/search/join/GenericTermsCollector.java b/lucene/join/src/java/org/apache/lucene/search/join/GenericTermsCollector.java
index d774207..bb65f33 100644
--- a/lucene/join/src/java/org/apache/lucene/search/join/GenericTermsCollector.java
+++ b/lucene/join/src/java/org/apache/lucene/search/join/GenericTermsCollector.java
@@ -18,8 +18,8 @@ package org.apache.lucene.search.join;
import java.io.IOException;
import java.io.PrintStream;
-import org.apache.lucene.index.BinaryDocValues;
import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.index.SortedDocValues;
import org.apache.lucene.index.SortedSetDocValues;
import org.apache.lucene.search.Collector;
import org.apache.lucene.search.LeafCollector;
@@ -106,7 +106,7 @@ interface GenericTermsCollector extends Collector {
}
static GenericTermsCollector createCollectorSV(
- Function<BinaryDocValues> svFunction, ScoreMode mode) {
+ Function<SortedDocValues> svFunction, ScoreMode mode) {
switch (mode) {
case None:
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 448432c..5eef951 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
@@ -28,7 +28,6 @@ import org.apache.lucene.document.DoublePoint;
import org.apache.lucene.document.FloatPoint;
import org.apache.lucene.document.IntPoint;
import org.apache.lucene.document.LongPoint;
-import org.apache.lucene.index.BinaryDocValues;
import org.apache.lucene.index.DocValues;
import org.apache.lucene.index.DocValuesType;
import org.apache.lucene.index.LeafReader;
@@ -104,7 +103,7 @@ public final class JoinUtil {
DocValuesTermsCollector.sortedSetDocValues(fromField);
termsWithScoreCollector = GenericTermsCollector.createCollectorMV(mvFunction, scoreMode);
} else {
- Function<BinaryDocValues> svFunction = DocValuesTermsCollector.binaryDocValues(fromField);
+ Function<SortedDocValues> svFunction = DocValuesTermsCollector.sortedDocValues(fromField);
termsWithScoreCollector = GenericTermsCollector.createCollectorSV(svFunction, scoreMode);
}
diff --git a/lucene/join/src/java/org/apache/lucene/search/join/TermsCollector.java b/lucene/join/src/java/org/apache/lucene/search/join/TermsCollector.java
index d73ea53..de85937 100644
--- a/lucene/join/src/java/org/apache/lucene/search/join/TermsCollector.java
+++ b/lucene/join/src/java/org/apache/lucene/search/join/TermsCollector.java
@@ -17,7 +17,7 @@
package org.apache.lucene.search.join;
import java.io.IOException;
-import org.apache.lucene.index.BinaryDocValues;
+import org.apache.lucene.index.SortedDocValues;
import org.apache.lucene.index.SortedSetDocValues;
import org.apache.lucene.util.BytesRef;
import org.apache.lucene.util.BytesRefHash;
@@ -50,7 +50,7 @@ abstract class TermsCollector<DV> extends DocValuesTermsCollector<DV> {
static TermsCollector<?> create(String field, boolean multipleValuesPerDocument) {
return multipleValuesPerDocument
? new MV(sortedSetDocValues(field))
- : new SV(binaryDocValues(field));
+ : new SV(sortedDocValues(field));
}
// impl that works with multiple values per document
@@ -76,9 +76,9 @@ abstract class TermsCollector<DV> extends DocValuesTermsCollector<DV> {
}
// impl that works with single value per document
- static class SV extends TermsCollector<BinaryDocValues> {
+ static class SV extends TermsCollector<SortedDocValues> {
- SV(Function<BinaryDocValues> docValuesCall) {
+ SV(Function<SortedDocValues> docValuesCall) {
super(docValuesCall);
}
@@ -86,7 +86,7 @@ abstract class TermsCollector<DV> extends DocValuesTermsCollector<DV> {
public void collect(int doc) throws IOException {
BytesRef term;
if (docValues.advanceExact(doc)) {
- term = docValues.binaryValue();
+ term = docValues.lookupOrd(docValues.ordValue());
} else {
term = new BytesRef(BytesRef.EMPTY_BYTES);
}
diff --git a/lucene/join/src/java/org/apache/lucene/search/join/TermsWithScoreCollector.java b/lucene/join/src/java/org/apache/lucene/search/join/TermsWithScoreCollector.java
index 5bc12af..db4df71 100644
--- a/lucene/join/src/java/org/apache/lucene/search/join/TermsWithScoreCollector.java
+++ b/lucene/join/src/java/org/apache/lucene/search/join/TermsWithScoreCollector.java
@@ -18,7 +18,7 @@ package org.apache.lucene.search.join;
import java.io.IOException;
import java.util.Arrays;
-import org.apache.lucene.index.BinaryDocValues;
+import org.apache.lucene.index.SortedDocValues;
import org.apache.lucene.index.SortedSetDocValues;
import org.apache.lucene.search.Scorable;
import org.apache.lucene.util.ArrayUtil;
@@ -81,17 +81,17 @@ abstract class TermsWithScoreCollector<DV> extends DocValuesTermsCollector<DV>
} else {
switch (scoreMode) {
case Avg:
- return new SV.Avg(binaryDocValues(field));
+ return new SV.Avg(sortedDocValues(field));
default:
- return new SV(binaryDocValues(field), scoreMode);
+ return new SV(sortedDocValues(field), scoreMode);
}
}
}
// impl that works with single value per document
- static class SV extends TermsWithScoreCollector<BinaryDocValues> {
+ static class SV extends TermsWithScoreCollector<SortedDocValues> {
- SV(Function<BinaryDocValues> docValuesCall, ScoreMode scoreMode) {
+ SV(Function<SortedDocValues> docValuesCall, ScoreMode scoreMode) {
super(docValuesCall, scoreMode);
}
@@ -99,7 +99,7 @@ abstract class TermsWithScoreCollector<DV> extends DocValuesTermsCollector<DV>
public void collect(int doc) throws IOException {
BytesRef value;
if (docValues.advanceExact(doc)) {
- value = docValues.binaryValue();
+ value = docValues.lookupOrd(docValues.ordValue());
} else {
value = new BytesRef(BytesRef.EMPTY_BYTES);
}
@@ -147,7 +147,7 @@ abstract class TermsWithScoreCollector<DV> extends DocValuesTermsCollector<DV>
int[] scoreCounts = new int[INITIAL_ARRAY_SIZE];
- Avg(Function<BinaryDocValues> docValuesCall) {
+ Avg(Function<SortedDocValues> docValuesCall) {
super(docValuesCall, ScoreMode.Avg);
}
@@ -155,7 +155,7 @@ abstract class TermsWithScoreCollector<DV> extends DocValuesTermsCollector<DV>
public void collect(int doc) throws IOException {
BytesRef value;
if (docValues.advanceExact(doc)) {
- value = docValues.binaryValue();
+ value = docValues.lookupOrd(docValues.ordValue());
} else {
value = new BytesRef(BytesRef.EMPTY_BYTES);
}
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 8cbd88a..f6a5e76 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
@@ -49,7 +49,6 @@ import org.apache.lucene.document.SortedNumericDocValuesField;
import org.apache.lucene.document.SortedSetDocValuesField;
import org.apache.lucene.document.StringField;
import org.apache.lucene.document.TextField;
-import org.apache.lucene.index.BinaryDocValues;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.DocValues;
import org.apache.lucene.index.IndexReader;
@@ -1796,13 +1795,13 @@ public class TestJoinUtil extends LuceneTestCase {
new SimpleCollector() {
private Scorable scorer;
- private BinaryDocValues terms;
+ private SortedDocValues terms;
@Override
public void collect(int doc) throws IOException {
final BytesRef joinValue;
if (terms.advanceExact(doc)) {
- joinValue = terms.binaryValue();
+ joinValue = terms.lookupOrd(terms.ordValue());
} else {
// missing;
return;
@@ -1825,7 +1824,7 @@ public class TestJoinUtil extends LuceneTestCase {
@Override
protected void doSetNextReader(LeafReaderContext context) throws IOException {
- terms = DocValues.getBinary(context.reader(), fromField);
+ terms = DocValues.getSorted(context.reader(), fromField);
}
@Override
@@ -1870,14 +1869,14 @@ public class TestJoinUtil extends LuceneTestCase {
new MatchAllDocsQuery(),
new SimpleCollector() {
- private BinaryDocValues terms;
+ private SortedDocValues terms;
private int docBase;
@Override
public void collect(int doc) throws IOException {
final BytesRef joinValue;
if (terms.advanceExact(doc)) {
- joinValue = terms.binaryValue();
+ joinValue = terms.lookupOrd(terms.ordValue());
} else {
// missing;
joinValue = new BytesRef(BytesRef.EMPTY_BYTES);
@@ -1891,7 +1890,7 @@ public class TestJoinUtil extends LuceneTestCase {
@Override
protected void doSetNextReader(LeafReaderContext context) throws IOException {
- terms = DocValues.getBinary(context.reader(), toField);
+ terms = DocValues.getSorted(context.reader(), toField);
docBase = context.docBase;
}
diff --git a/lucene/luke/src/java/org/apache/lucene/luke/models/documents/DocValuesAdapter.java b/lucene/luke/src/java/org/apache/lucene/luke/models/documents/DocValuesAdapter.java
index 83245fa..4676ce7 100644
--- a/lucene/luke/src/java/org/apache/lucene/luke/models/documents/DocValuesAdapter.java
+++ b/lucene/luke/src/java/org/apache/lucene/luke/models/documents/DocValuesAdapter.java
@@ -127,7 +127,7 @@ final class DocValuesAdapter {
DocValues dv =
DocValues.of(
dvType,
- Collections.singletonList(BytesRef.deepCopyOf(svalues.binaryValue())),
+ Collections.singletonList(BytesRef.deepCopyOf(svalues.lookupOrd(svalues.ordValue()))),
Collections.emptyList());
return Optional.of(dv);
}
diff --git a/lucene/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java b/lucene/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java
index a6273cb..6dcf8d0 100644
--- a/lucene/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java
+++ b/lucene/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java
@@ -1268,7 +1268,42 @@ public class MemoryIndex {
@Override
public BinaryDocValues getBinaryDocValues(String field) {
- return getSortedDocValues(field, DocValuesType.BINARY);
+ final SortedDocValues in = getSortedDocValues(field, DocValuesType.BINARY);
+ if (in == null) {
+ return null;
+ }
+ // wraps a SortedDocValues and makes it look like its binary
+ return new BinaryDocValues() {
+ @Override
+ public BytesRef binaryValue() throws IOException {
+ return in.lookupOrd(in.ordValue());
+ }
+
+ @Override
+ public boolean advanceExact(int target) throws IOException {
+ return in.advanceExact(target);
+ }
+
+ @Override
+ public int docID() {
+ return in.docID();
+ }
+
+ @Override
+ public int nextDoc() throws IOException {
+ return in.nextDoc();
+ }
+
+ @Override
+ public int advance(int target) throws IOException {
+ return in.advance(target);
+ }
+
+ @Override
+ public long cost() {
+ return in.cost();
+ }
+ };
}
@Override
diff --git a/lucene/memory/src/test/org/apache/lucene/index/memory/TestMemoryIndex.java b/lucene/memory/src/test/org/apache/lucene/index/memory/TestMemoryIndex.java
index fe0447f..25568c6 100644
--- a/lucene/memory/src/test/org/apache/lucene/index/memory/TestMemoryIndex.java
+++ b/lucene/memory/src/test/org/apache/lucene/index/memory/TestMemoryIndex.java
@@ -290,7 +290,7 @@ public class TestMemoryIndex extends LuceneTestCase {
assertEquals(DocIdSetIterator.NO_MORE_DOCS, binaryDocValues.nextDoc());
SortedDocValues sortedDocValues = leafReader.getSortedDocValues("sorted");
assertEquals(0, sortedDocValues.nextDoc());
- assertEquals("b", sortedDocValues.binaryValue().utf8ToString());
+ assertEquals("b", sortedDocValues.lookupOrd(sortedDocValues.ordValue()).utf8ToString());
assertEquals(0, sortedDocValues.ordValue());
assertEquals("b", sortedDocValues.lookupOrd(0).utf8ToString());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, sortedDocValues.nextDoc());
diff --git a/lucene/memory/src/test/org/apache/lucene/index/memory/TestMemoryIndexAgainstDirectory.java b/lucene/memory/src/test/org/apache/lucene/index/memory/TestMemoryIndexAgainstDirectory.java
index 895fe41..cea0a9d 100644
--- a/lucene/memory/src/test/org/apache/lucene/index/memory/TestMemoryIndexAgainstDirectory.java
+++ b/lucene/memory/src/test/org/apache/lucene/index/memory/TestMemoryIndexAgainstDirectory.java
@@ -535,7 +535,6 @@ public class TestMemoryIndexAgainstDirectory extends BaseTokenStreamTestCase {
assertEquals(controlSortedDocValues.getValueCount(), sortedDocValues.getValueCount());
assertEquals(0, sortedDocValues.nextDoc());
assertEquals(0, controlSortedDocValues.nextDoc());
- assertEquals(controlSortedDocValues.binaryValue(), sortedDocValues.binaryValue());
assertEquals(controlSortedDocValues.ordValue(), sortedDocValues.ordValue());
assertEquals(controlSortedDocValues.lookupOrd(0), sortedDocValues.lookupOrd(0));
diff --git a/lucene/misc/src/java/org/apache/lucene/misc/search/DocValuesStats.java b/lucene/misc/src/java/org/apache/lucene/misc/search/DocValuesStats.java
index c7c5d19..55b0432 100644
--- a/lucene/misc/src/java/org/apache/lucene/misc/search/DocValuesStats.java
+++ b/lucene/misc/src/java/org/apache/lucene/misc/search/DocValuesStats.java
@@ -371,7 +371,7 @@ public abstract class DocValuesStats<T> {
@Override
protected void doAccumulate(int count) throws IOException {
- BytesRef val = sdv.binaryValue();
+ BytesRef val = sdv.lookupOrd(sdv.ordValue());
if (max == null || val.compareTo(max) > 0) {
max = copyFrom(val, max);
}
diff --git a/lucene/misc/src/test/org/apache/lucene/misc/search/TestDiversifiedTopDocsCollector.java b/lucene/misc/src/test/org/apache/lucene/misc/search/TestDiversifiedTopDocsCollector.java
index 93953ae..e070546 100644
--- a/lucene/misc/src/test/org/apache/lucene/misc/search/TestDiversifiedTopDocsCollector.java
+++ b/lucene/misc/src/test/org/apache/lucene/misc/search/TestDiversifiedTopDocsCollector.java
@@ -24,7 +24,6 @@ import org.apache.lucene.document.Field;
import org.apache.lucene.document.FloatDocValuesField;
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.IndexReader;
import org.apache.lucene.index.LeafReaderContext;
@@ -190,7 +189,7 @@ public class TestDiversifiedTopDocsCollector extends LuceneTestCase {
extends DiversifiedTopDocsCollector {
private final String field;
- private BinaryDocValues vals;
+ private SortedDocValues vals;
public HashedDocValuesDiversifiedCollector(int size, int maxHitsPerKey, String field) {
super(size, maxHitsPerKey);
@@ -227,14 +226,14 @@ public class TestDiversifiedTopDocsCollector extends LuceneTestCase {
@Override
public long longValue() throws IOException {
- return vals == null ? -1 : vals.binaryValue().hashCode();
+ return vals == null ? -1 : vals.lookupOrd(vals.ordValue()).hashCode();
}
};
}
@Override
public LeafCollector getLeafCollector(LeafReaderContext context) throws IOException {
- this.vals = DocValues.getBinary(context.reader(), field);
+ this.vals = DocValues.getSorted(context.reader(), field);
return super.getLeafCollector(context);
}
}
diff --git a/lucene/monitor/src/java/org/apache/lucene/monitor/QueryIndex.java b/lucene/monitor/src/java/org/apache/lucene/monitor/QueryIndex.java
index 22e8cc4..e44ecb8 100644
--- a/lucene/monitor/src/java/org/apache/lucene/monitor/QueryIndex.java
+++ b/lucene/monitor/src/java/org/apache/lucene/monitor/QueryIndex.java
@@ -433,8 +433,8 @@ class QueryIndex implements Closeable {
@Override
public void collect(int doc) throws IOException {
dataValues.advanceTo(doc);
- BytesRef cache_id = dataValues.cacheId.binaryValue();
- BytesRef query_id = dataValues.queryId.binaryValue();
+ BytesRef cache_id = dataValues.cacheId.lookupOrd(dataValues.cacheId.ordValue());
+ BytesRef query_id = dataValues.queryId.lookupOrd(dataValues.queryId.ordValue());
QueryCacheEntry query = queries.get(cache_id.utf8ToString());
matcher.matchQuery(query_id.utf8ToString(), query, dataValues);
}
diff --git a/lucene/queries/src/java/org/apache/lucene/queries/function/docvalues/DocTermsIndexDocValues.java b/lucene/queries/src/java/org/apache/lucene/queries/function/docvalues/DocTermsIndexDocValues.java
index 2b35ad7..adaadd2 100644
--- a/lucene/queries/src/java/org/apache/lucene/queries/function/docvalues/DocTermsIndexDocValues.java
+++ b/lucene/queries/src/java/org/apache/lucene/queries/function/docvalues/DocTermsIndexDocValues.java
@@ -92,7 +92,7 @@ public abstract class DocTermsIndexDocValues extends FunctionValues {
if (getOrdForDoc(doc) == -1) {
return false;
} else {
- target.copyBytes(termsIndex.binaryValue());
+ target.copyBytes(termsIndex.lookupOrd(termsIndex.ordValue()));
return true;
}
}
@@ -102,7 +102,7 @@ public abstract class DocTermsIndexDocValues extends FunctionValues {
if (getOrdForDoc(doc) == -1) {
return null;
}
- final BytesRef term = termsIndex.binaryValue();
+ final BytesRef term = termsIndex.lookupOrd(termsIndex.ordValue());
spareChars.copyUTF8Bytes(term);
return spareChars.toString();
}
diff --git a/lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/JoinDocFreqValueSource.java b/lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/JoinDocFreqValueSource.java
index ee93b1c..fea562d 100644
--- a/lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/JoinDocFreqValueSource.java
+++ b/lucene/queries/src/java/org/apache/lucene/queries/function/valuesource/JoinDocFreqValueSource.java
@@ -18,12 +18,12 @@ package org.apache.lucene.queries.function.valuesource;
import java.io.IOException;
import java.util.Map;
-import org.apache.lucene.index.BinaryDocValues;
import org.apache.lucene.index.DocValues;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.LeafReaderContext;
import org.apache.lucene.index.MultiTerms;
import org.apache.lucene.index.ReaderUtil;
+import org.apache.lucene.index.SortedDocValues;
import org.apache.lucene.index.Terms;
import org.apache.lucene.index.TermsEnum;
import org.apache.lucene.queries.function.FunctionValues;
@@ -54,7 +54,7 @@ public class JoinDocFreqValueSource extends FieldCacheSource {
@Override
public FunctionValues getValues(Map<Object, Object> context, LeafReaderContext readerContext)
throws IOException {
- final BinaryDocValues terms = DocValues.getBinary(readerContext.reader(), field);
+ final SortedDocValues terms = DocValues.getSorted(readerContext.reader(), field);
final IndexReader top = ReaderUtil.getTopLevelContext(readerContext).reader();
Terms t = MultiTerms.getTerms(top, qfield);
final TermsEnum termsEnum = t == null ? TermsEnum.EMPTY : t.iterator();
@@ -75,7 +75,7 @@ public class JoinDocFreqValueSource extends FieldCacheSource {
curDocID = terms.advance(doc);
}
if (doc == curDocID) {
- BytesRef term = terms.binaryValue();
+ BytesRef term = terms.lookupOrd(terms.ordValue());
if (termsEnum.seekExact(term)) {
return termsEnum.docFreq();
}
diff --git a/lucene/test-framework/src/java/org/apache/lucene/index/AssertingLeafReader.java b/lucene/test-framework/src/java/org/apache/lucene/index/AssertingLeafReader.java
index 62792b1..74def72 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/index/AssertingLeafReader.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/index/AssertingLeafReader.java
@@ -838,14 +838,6 @@ public class AssertingLeafReader extends FilterLeafReader {
}
@Override
- public BytesRef binaryValue() throws IOException {
- assertThread("Sorted doc values", creationThread);
- final BytesRef result = in.binaryValue();
- assert result.isValid();
- return result;
- }
-
- @Override
public int lookupTerm(BytesRef key) throws IOException {
assertThread("Sorted doc values", creationThread);
assert key.isValid();
diff --git a/lucene/test-framework/src/java/org/apache/lucene/index/BaseDocValuesFormatTestCase.java b/lucene/test-framework/src/java/org/apache/lucene/index/BaseDocValuesFormatTestCase.java
index db0688f..860de66 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/index/BaseDocValuesFormatTestCase.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/index/BaseDocValuesFormatTestCase.java
@@ -802,7 +802,7 @@ public abstract class BaseDocValuesFormatTestCase extends BaseIndexFileFormatTes
SortedDocValues dv = ireader.leaves().get(0).reader().getSortedDocValues("dv");
assertEquals(2, dv.getValueCount()); // 2 ords
assertEquals(0, dv.nextDoc());
- BytesRef scratch = dv.binaryValue();
+ BytesRef scratch = dv.lookupOrd(dv.ordValue());
assertEquals(new BytesRef("hello world 1"), scratch);
scratch = dv.lookupOrd(1);
assertEquals(new BytesRef("hello world 2"), scratch);
@@ -1094,9 +1094,9 @@ public abstract class BaseDocValuesFormatTestCase extends BaseIndexFileFormatTes
// Now search the index:
IndexReader ireader = DirectoryReader.open(directory); // read-only=true
assert ireader.leaves().size() == 1;
- BinaryDocValues dv = DocValues.getBinary(ireader.leaves().get(0).reader(), "dv");
+ SortedDocValues dv = DocValues.getSorted(ireader.leaves().get(0).reader(), "dv");
assertEquals(0, dv.nextDoc());
- assertEquals(new BytesRef(bytes), dv.binaryValue());
+ assertEquals(new BytesRef(bytes), dv.lookupOrd(dv.ordValue()));
ireader.close();
directory.close();
}
@@ -1139,11 +1139,11 @@ public abstract class BaseDocValuesFormatTestCase extends BaseIndexFileFormatTes
// Now search the index:
IndexReader ireader = DirectoryReader.open(directory); // read-only=true
assert ireader.leaves().size() == 1;
- BinaryDocValues dv = DocValues.getBinary(ireader.leaves().get(0).reader(), "dv");
+ SortedDocValues dv = DocValues.getSorted(ireader.leaves().get(0).reader(), "dv");
byte mybytes[] = new byte[20];
assertEquals(0, dv.nextDoc());
- assertEquals("boo!", dv.binaryValue().utf8ToString());
- assertFalse(dv.binaryValue().bytes == mybytes);
+ assertEquals("boo!", dv.lookupOrd(dv.ordValue()).utf8ToString());
+ assertFalse(dv.lookupOrd(dv.ordValue()).bytes == mybytes);
ireader.close();
directory.close();
@@ -1258,7 +1258,7 @@ public abstract class BaseDocValuesFormatTestCase extends BaseIndexFileFormatTes
expected = new BytesRef(entry.getValue());
docValues = MultiDocValues.getSortedValues(reader, "field");
assertEquals(docId, docValues.advance(docId));
- final BytesRef actual = docValues.binaryValue();
+ final BytesRef actual = docValues.lookupOrd(docValues.ordValue());
assertEquals(expected, actual);
}
@@ -1657,7 +1657,7 @@ public abstract class BaseDocValuesFormatTestCase extends BaseIndexFileFormatTes
TestUtil.checkReader(ir);
for (LeafReaderContext context : ir.leaves()) {
LeafReader r = context.reader();
- BinaryDocValues docValues = DocValues.getBinary(r, "dv");
+ SortedDocValues docValues = DocValues.getSorted(r, "dv");
docValues.nextDoc();
for (int i = 0; i < r.maxDoc(); i++) {
BytesRef binaryValue = r.document(i).getBinaryValue("stored");
@@ -1665,7 +1665,7 @@ public abstract class BaseDocValuesFormatTestCase extends BaseIndexFileFormatTes
assertTrue(docValues.docID() > i);
} else {
assertEquals(i, docValues.docID());
- assertEquals(binaryValue, docValues.binaryValue());
+ assertEquals(binaryValue, docValues.lookupOrd(docValues.ordValue()));
docValues.nextDoc();
}
}
@@ -1679,7 +1679,7 @@ public abstract class BaseDocValuesFormatTestCase extends BaseIndexFileFormatTes
TestUtil.checkReader(ir);
for (LeafReaderContext context : ir.leaves()) {
LeafReader r = context.reader();
- BinaryDocValues docValues = DocValues.getBinary(r, "dv");
+ SortedDocValues docValues = DocValues.getSorted(r, "dv");
docValues.nextDoc();
for (int i = 0; i < r.maxDoc(); i++) {
BytesRef binaryValue = r.document(i).getBinaryValue("stored");
@@ -1687,7 +1687,7 @@ public abstract class BaseDocValuesFormatTestCase extends BaseIndexFileFormatTes
assertTrue(docValues.docID() > i);
} else {
assertEquals(i, docValues.docID());
- assertEquals(binaryValue, docValues.binaryValue());
+ assertEquals(binaryValue, docValues.lookupOrd(docValues.ordValue()));
docValues.nextDoc();
}
}
@@ -2689,7 +2689,7 @@ public abstract class BaseDocValuesFormatTestCase extends BaseIndexFileFormatTes
BytesRef scratch = binaries.binaryValue();
assertEquals(binaryValue, scratch);
assertEquals(j, sorted.nextDoc());
- scratch = sorted.binaryValue();
+ scratch = sorted.lookupOrd(sorted.ordValue());
assertEquals(binaryValue, scratch);
String expected = r.document(j).get("storedNum");
assertEquals(j, numerics.nextDoc());
@@ -2810,7 +2810,7 @@ public abstract class BaseDocValuesFormatTestCase extends BaseIndexFileFormatTes
BytesRef scratch = binaries.binaryValue();
assertEquals(binaryValue, scratch);
assertEquals(j, sorted.nextDoc());
- scratch = sorted.binaryValue();
+ scratch = sorted.lookupOrd(sorted.ordValue());
assertEquals(binaryValue, scratch);
}
}
diff --git a/lucene/test-framework/src/java/org/apache/lucene/util/LuceneTestCase.java b/lucene/test-framework/src/java/org/apache/lucene/util/LuceneTestCase.java
index 8bf1973..f05b62f 100644
--- a/lucene/test-framework/src/java/org/apache/lucene/util/LuceneTestCase.java
+++ b/lucene/test-framework/src/java/org/apache/lucene/util/LuceneTestCase.java
@@ -2631,8 +2631,8 @@ public abstract class LuceneTestCase extends Assert {
for (int docID = 0; docID < leftReader.maxDoc(); docID++) {
assertEquals(docID, leftValues.nextDoc());
assertEquals(docID, rightValues.nextDoc());
- final BytesRef left = BytesRef.deepCopyOf(leftValues.binaryValue());
- final BytesRef right = rightValues.binaryValue();
+ final BytesRef left = BytesRef.deepCopyOf(leftValues.lookupOrd(leftValues.ordValue()));
+ final BytesRef right = rightValues.lookupOrd(rightValues.ordValue());
assertEquals(info, left, right);
}
} else {