You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by da...@apache.org on 2018/12/11 09:27:32 UTC
[03/47] lucene-solr:jira/http2: Add the ability to set the number of
hits to track accurately
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/84d5015e/lucene/core/src/test/org/apache/lucene/index/TestIndexSorting.java
----------------------------------------------------------------------
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 3857a97..5bfd9d5 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestIndexSorting.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestIndexSorting.java
@@ -355,166 +355,206 @@ public class TestIndexSorting extends LuceneTestCase {
}
public void testMissingStringFirst() throws Exception {
- Directory dir = newDirectory();
- IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- SortField sortField = new SortField("foo", SortField.Type.STRING);
- sortField.setMissingValue(SortField.STRING_FIRST);
- Sort indexSort = new Sort(sortField);
- iwc.setIndexSort(indexSort);
- IndexWriter w = new IndexWriter(dir, iwc);
- Document doc = new Document();
- doc.add(new SortedDocValuesField("foo", new BytesRef("zzz")));
- w.addDocument(doc);
- // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
- w.commit();
+ for (boolean reverse : new boolean[] {true, false}) {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
+ SortField sortField = new SortField("foo", SortField.Type.STRING, reverse);
+ sortField.setMissingValue(SortField.STRING_FIRST);
+ Sort indexSort = new Sort(sortField);
+ iwc.setIndexSort(indexSort);
+ IndexWriter w = new IndexWriter(dir, iwc);
+ Document doc = new Document();
+ doc.add(new SortedDocValuesField("foo", new BytesRef("zzz")));
+ w.addDocument(doc);
+ // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
+ w.commit();
- // missing
- w.addDocument(new Document());
- w.commit();
+ // missing
+ w.addDocument(new Document());
+ w.commit();
- doc = new Document();
- doc.add(new SortedDocValuesField("foo", new BytesRef("mmm")));
- w.addDocument(doc);
- w.forceMerge(1);
+ doc = new Document();
+ doc.add(new SortedDocValuesField("foo", new BytesRef("mmm")));
+ w.addDocument(doc);
+ w.forceMerge(1);
- DirectoryReader r = DirectoryReader.open(w);
- LeafReader leaf = getOnlyLeafReader(r);
- assertEquals(3, leaf.maxDoc());
- SortedDocValues values = leaf.getSortedDocValues("foo");
- // docID 0 is missing:
- assertEquals(1, values.nextDoc());
- assertEquals("mmm", values.binaryValue().utf8ToString());
- assertEquals(2, values.nextDoc());
- assertEquals("zzz", values.binaryValue().utf8ToString());
- r.close();
- w.close();
- dir.close();
+ DirectoryReader r = DirectoryReader.open(w);
+ LeafReader leaf = getOnlyLeafReader(r);
+ assertEquals(3, leaf.maxDoc());
+ SortedDocValues values = leaf.getSortedDocValues("foo");
+ if (reverse) {
+ assertEquals(0, values.nextDoc());
+ assertEquals("zzz", values.binaryValue().utf8ToString());
+ assertEquals(1, values.nextDoc());
+ assertEquals("mmm", values.binaryValue().utf8ToString());
+ } else {
+ // docID 0 is missing:
+ assertEquals(1, values.nextDoc());
+ assertEquals("mmm", values.binaryValue().utf8ToString());
+ assertEquals(2, values.nextDoc());
+ assertEquals("zzz", values.binaryValue().utf8ToString());
+ }
+ r.close();
+ w.close();
+ dir.close();
+ }
}
public void testMissingMultiValuedStringFirst() throws Exception {
- Directory dir = newDirectory();
- IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- SortField sortField = new SortedSetSortField("foo", false);
- sortField.setMissingValue(SortField.STRING_FIRST);
- Sort indexSort = new Sort(sortField);
- iwc.setIndexSort(indexSort);
- IndexWriter w = new IndexWriter(dir, iwc);
- Document doc = new Document();
- doc.add(new NumericDocValuesField("id", 3));
- doc.add(new SortedSetDocValuesField("foo", new BytesRef("zzz")));
- doc.add(new SortedSetDocValuesField("foo", new BytesRef("zzza")));
- doc.add(new SortedSetDocValuesField("foo", new BytesRef("zzzd")));
- w.addDocument(doc);
- // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
- w.commit();
+ for (boolean reverse : new boolean[] {true, false}) {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
+ SortField sortField = new SortedSetSortField("foo", reverse);
+ sortField.setMissingValue(SortField.STRING_FIRST);
+ Sort indexSort = new Sort(sortField);
+ iwc.setIndexSort(indexSort);
+ IndexWriter w = new IndexWriter(dir, iwc);
+ Document doc = new Document();
+ doc.add(new NumericDocValuesField("id", 3));
+ doc.add(new SortedSetDocValuesField("foo", new BytesRef("zzz")));
+ doc.add(new SortedSetDocValuesField("foo", new BytesRef("zzza")));
+ doc.add(new SortedSetDocValuesField("foo", new BytesRef("zzzd")));
+ w.addDocument(doc);
+ // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
+ w.commit();
- // missing
- doc = new Document();
- doc.add(new NumericDocValuesField("id", 1));
- w.addDocument(doc);
- w.commit();
+ // missing
+ doc = new Document();
+ doc.add(new NumericDocValuesField("id", 1));
+ w.addDocument(doc);
+ w.commit();
- doc = new Document();
- doc.add(new NumericDocValuesField("id", 2));
- doc.add(new SortedSetDocValuesField("foo", new BytesRef("mmm")));
- doc.add(new SortedSetDocValuesField("foo", new BytesRef("nnnn")));
- w.addDocument(doc);
- w.forceMerge(1);
+ doc = new Document();
+ doc.add(new NumericDocValuesField("id", 2));
+ doc.add(new SortedSetDocValuesField("foo", new BytesRef("mmm")));
+ doc.add(new SortedSetDocValuesField("foo", new BytesRef("nnnn")));
+ w.addDocument(doc);
+ w.forceMerge(1);
- DirectoryReader r = DirectoryReader.open(w);
- LeafReader leaf = getOnlyLeafReader(r);
- assertEquals(3, leaf.maxDoc());
- NumericDocValues values = leaf.getNumericDocValues("id");
- assertEquals(0, values.nextDoc());
- assertEquals(1l, values.longValue());
- assertEquals(1, values.nextDoc());
- assertEquals(2l, values.longValue());
- assertEquals(2, values.nextDoc());
- assertEquals(3l, values.longValue());
- r.close();
- w.close();
- dir.close();
+ DirectoryReader r = DirectoryReader.open(w);
+ LeafReader leaf = getOnlyLeafReader(r);
+ assertEquals(3, leaf.maxDoc());
+ NumericDocValues values = leaf.getNumericDocValues("id");
+ if (reverse) {
+ assertEquals(0, values.nextDoc());
+ assertEquals(3l, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(2l, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(1l, values.longValue());
+ } else {
+ assertEquals(0, values.nextDoc());
+ assertEquals(1l, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(2l, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(3l, values.longValue());
+ }
+ r.close();
+ w.close();
+ dir.close();
+ }
}
public void testMissingStringLast() throws Exception {
- Directory dir = newDirectory();
- IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- SortField sortField = new SortField("foo", SortField.Type.STRING);
- sortField.setMissingValue(SortField.STRING_LAST);
- Sort indexSort = new Sort(sortField);
- iwc.setIndexSort(indexSort);
- IndexWriter w = new IndexWriter(dir, iwc);
- Document doc = new Document();
- doc.add(new SortedDocValuesField("foo", new BytesRef("zzz")));
- w.addDocument(doc);
- // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
- w.commit();
+ for (boolean reverse : new boolean[] {true, false}) {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
+ SortField sortField = new SortField("foo", SortField.Type.STRING, reverse);
+ sortField.setMissingValue(SortField.STRING_LAST);
+ Sort indexSort = new Sort(sortField);
+ iwc.setIndexSort(indexSort);
+ IndexWriter w = new IndexWriter(dir, iwc);
+ Document doc = new Document();
+ doc.add(new SortedDocValuesField("foo", new BytesRef("zzz")));
+ w.addDocument(doc);
+ // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
+ w.commit();
- // missing
- w.addDocument(new Document());
- w.commit();
+ // missing
+ w.addDocument(new Document());
+ w.commit();
- doc = new Document();
- doc.add(new SortedDocValuesField("foo", new BytesRef("mmm")));
- w.addDocument(doc);
- w.forceMerge(1);
+ doc = new Document();
+ doc.add(new SortedDocValuesField("foo", new BytesRef("mmm")));
+ w.addDocument(doc);
+ w.forceMerge(1);
- DirectoryReader r = DirectoryReader.open(w);
- LeafReader leaf = getOnlyLeafReader(r);
- assertEquals(3, leaf.maxDoc());
- SortedDocValues values = leaf.getSortedDocValues("foo");
- assertEquals(0, values.nextDoc());
- assertEquals("mmm", values.binaryValue().utf8ToString());
- assertEquals(1, values.nextDoc());
- assertEquals("zzz", values.binaryValue().utf8ToString());
- assertEquals(NO_MORE_DOCS, values.nextDoc());
- r.close();
- w.close();
- dir.close();
+ DirectoryReader r = DirectoryReader.open(w);
+ LeafReader leaf = getOnlyLeafReader(r);
+ assertEquals(3, leaf.maxDoc());
+ SortedDocValues values = leaf.getSortedDocValues("foo");
+ if (reverse) {
+ assertEquals(1, values.nextDoc());
+ assertEquals("zzz", values.binaryValue().utf8ToString());
+ assertEquals(2, values.nextDoc());
+ assertEquals("mmm", values.binaryValue().utf8ToString());
+ } else {
+ assertEquals(0, values.nextDoc());
+ assertEquals("mmm", values.binaryValue().utf8ToString());
+ assertEquals(1, values.nextDoc());
+ assertEquals("zzz", values.binaryValue().utf8ToString());
+ }
+ assertEquals(NO_MORE_DOCS, values.nextDoc());
+ r.close();
+ w.close();
+ dir.close();
+ }
}
public void testMissingMultiValuedStringLast() throws Exception {
- Directory dir = newDirectory();
- IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- SortField sortField = new SortedSetSortField("foo", false);
- sortField.setMissingValue(SortField.STRING_LAST);
- Sort indexSort = new Sort(sortField);
- iwc.setIndexSort(indexSort);
- IndexWriter w = new IndexWriter(dir, iwc);
- Document doc = new Document();
- doc.add(new NumericDocValuesField("id", 2));
- doc.add(new SortedSetDocValuesField("foo", new BytesRef("zzz")));
- doc.add(new SortedSetDocValuesField("foo", new BytesRef("zzzd")));
- w.addDocument(doc);
- // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
- w.commit();
+ for (boolean reverse : new boolean[] {true, false}) {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
+ SortField sortField = new SortedSetSortField("foo", reverse);
+ sortField.setMissingValue(SortField.STRING_LAST);
+ Sort indexSort = new Sort(sortField);
+ iwc.setIndexSort(indexSort);
+ IndexWriter w = new IndexWriter(dir, iwc);
+ Document doc = new Document();
+ doc.add(new NumericDocValuesField("id", 2));
+ doc.add(new SortedSetDocValuesField("foo", new BytesRef("zzz")));
+ doc.add(new SortedSetDocValuesField("foo", new BytesRef("zzzd")));
+ w.addDocument(doc);
+ // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
+ w.commit();
- // missing
- doc = new Document();
- doc.add(new NumericDocValuesField("id", 3));
- w.addDocument(doc);
- w.commit();
+ // missing
+ doc = new Document();
+ doc.add(new NumericDocValuesField("id", 3));
+ w.addDocument(doc);
+ w.commit();
- doc = new Document();
- doc.add(new NumericDocValuesField("id", 1));
- doc.add(new SortedSetDocValuesField("foo", new BytesRef("mmm")));
- doc.add(new SortedSetDocValuesField("foo", new BytesRef("ppp")));
- w.addDocument(doc);
- w.forceMerge(1);
+ doc = new Document();
+ doc.add(new NumericDocValuesField("id", 1));
+ doc.add(new SortedSetDocValuesField("foo", new BytesRef("mmm")));
+ doc.add(new SortedSetDocValuesField("foo", new BytesRef("ppp")));
+ w.addDocument(doc);
+ w.forceMerge(1);
- DirectoryReader r = DirectoryReader.open(w);
- LeafReader leaf = getOnlyLeafReader(r);
- assertEquals(3, leaf.maxDoc());
- NumericDocValues values = leaf.getNumericDocValues("id");
- assertEquals(0, values.nextDoc());
- assertEquals(1l, values.longValue());
- assertEquals(1, values.nextDoc());
- assertEquals(2l, values.longValue());
- assertEquals(2, values.nextDoc());
- assertEquals(3l, values.longValue());
- r.close();
- w.close();
- dir.close();
+ DirectoryReader r = DirectoryReader.open(w);
+ LeafReader leaf = getOnlyLeafReader(r);
+ assertEquals(3, leaf.maxDoc());
+ NumericDocValues values = leaf.getNumericDocValues("id");
+ if (reverse) {
+ assertEquals(0, values.nextDoc());
+ assertEquals(3l, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(2l, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(1l, values.longValue());
+ } else {
+ assertEquals(0, values.nextDoc());
+ assertEquals(1l, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(2l, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(3l, values.longValue());
+ }
+ r.close();
+ w.close();
+ dir.close();
+ }
}
public void testBasicLong() throws Exception {
@@ -597,11 +637,213 @@ public class TestIndexSorting extends LuceneTestCase {
}
public void testMissingLongFirst() throws Exception {
+ for (boolean reverse : new boolean[] {true, false}) {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
+ SortField sortField = new SortField("foo", SortField.Type.LONG, reverse);
+ sortField.setMissingValue(Long.valueOf(Long.MIN_VALUE));
+ Sort indexSort = new Sort(sortField);
+ iwc.setIndexSort(indexSort);
+ IndexWriter w = new IndexWriter(dir, iwc);
+ Document doc = new Document();
+ doc.add(new NumericDocValuesField("foo", 18));
+ w.addDocument(doc);
+ // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
+ w.commit();
+
+ // missing
+ w.addDocument(new Document());
+ w.commit();
+
+ doc = new Document();
+ doc.add(new NumericDocValuesField("foo", 7));
+ w.addDocument(doc);
+ w.forceMerge(1);
+
+ DirectoryReader r = DirectoryReader.open(w);
+ LeafReader leaf = getOnlyLeafReader(r);
+ assertEquals(3, leaf.maxDoc());
+ NumericDocValues values = leaf.getNumericDocValues("foo");
+ if (reverse) {
+ assertEquals(0, values.nextDoc());
+ assertEquals(18, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(7, values.longValue());
+ } else {
+ // docID 0 has no value
+ assertEquals(1, values.nextDoc());
+ assertEquals(7, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(18, values.longValue());
+ }
+ r.close();
+ w.close();
+ dir.close();
+ }
+ }
+
+ public void testMissingMultiValuedLongFirst() throws Exception {
+ for (boolean reverse : new boolean[] {true, false}) {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
+ SortField sortField = new SortedNumericSortField("foo", SortField.Type.LONG, reverse);
+ sortField.setMissingValue(Long.valueOf(Long.MIN_VALUE));
+ Sort indexSort = new Sort(sortField);
+ iwc.setIndexSort(indexSort);
+ IndexWriter w = new IndexWriter(dir, iwc);
+ Document doc = new Document();
+ doc.add(new NumericDocValuesField("id", 3));
+ doc.add(new SortedNumericDocValuesField("foo", 18));
+ doc.add(new SortedNumericDocValuesField("foo", 27));
+ w.addDocument(doc);
+ // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
+ w.commit();
+
+ // missing
+ doc = new Document();
+ doc.add(new NumericDocValuesField("id", 1));
+ w.addDocument(doc);
+ w.commit();
+
+ doc = new Document();
+ doc.add(new NumericDocValuesField("id", 2));
+ doc.add(new SortedNumericDocValuesField("foo", 7));
+ doc.add(new SortedNumericDocValuesField("foo", 24));
+ w.addDocument(doc);
+ w.forceMerge(1);
+
+ DirectoryReader r = DirectoryReader.open(w);
+ LeafReader leaf = getOnlyLeafReader(r);
+ assertEquals(3, leaf.maxDoc());
+ NumericDocValues values = leaf.getNumericDocValues("id");
+ if (reverse) {
+ assertEquals(0, values.nextDoc());
+ assertEquals(3, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(2, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(1, values.longValue());
+ } else {
+ assertEquals(0, values.nextDoc());
+ assertEquals(1, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(2, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(3, values.longValue());
+ }
+ r.close();
+ w.close();
+ dir.close();
+ }
+ }
+
+ public void testMissingLongLast() throws Exception {
+ for (boolean reverse : new boolean[] {true, false}) {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
+ SortField sortField = new SortField("foo", SortField.Type.LONG, reverse);
+ sortField.setMissingValue(Long.valueOf(Long.MAX_VALUE));
+ Sort indexSort = new Sort(sortField);
+ iwc.setIndexSort(indexSort);
+ IndexWriter w = new IndexWriter(dir, iwc);
+ Document doc = new Document();
+ doc.add(new NumericDocValuesField("foo", 18));
+ w.addDocument(doc);
+ // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
+ w.commit();
+
+ // missing
+ w.addDocument(new Document());
+ w.commit();
+
+ doc = new Document();
+ doc.add(new NumericDocValuesField("foo", 7));
+ w.addDocument(doc);
+ w.forceMerge(1);
+
+ DirectoryReader r = DirectoryReader.open(w);
+ LeafReader leaf = getOnlyLeafReader(r);
+ assertEquals(3, leaf.maxDoc());
+ NumericDocValues values = leaf.getNumericDocValues("foo");
+ if (reverse) {
+ // docID 0 is missing
+ assertEquals(1, values.nextDoc());
+ assertEquals(18, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(7, values.longValue());
+ } else {
+ assertEquals(0, values.nextDoc());
+ assertEquals(7, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(18, values.longValue());
+ }
+ assertEquals(NO_MORE_DOCS, values.nextDoc());
+ r.close();
+ w.close();
+ dir.close();
+ }
+ }
+
+ public void testMissingMultiValuedLongLast() throws Exception {
+ for (boolean reverse : new boolean[] {true, false}) {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
+ SortField sortField = new SortedNumericSortField("foo", SortField.Type.LONG, reverse);
+ sortField.setMissingValue(Long.valueOf(Long.MAX_VALUE));
+ Sort indexSort = new Sort(sortField);
+ iwc.setIndexSort(indexSort);
+ IndexWriter w = new IndexWriter(dir, iwc);
+ Document doc = new Document();
+ doc.add(new NumericDocValuesField("id", 2));
+ doc.add(new SortedNumericDocValuesField("foo", 18));
+ doc.add(new SortedNumericDocValuesField("foo", 65));
+ w.addDocument(doc);
+ // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
+ w.commit();
+
+ // missing
+ doc = new Document();
+ doc.add(new NumericDocValuesField("id", 3));
+ w.addDocument(doc);
+ w.commit();
+
+ doc = new Document();
+ doc.add(new NumericDocValuesField("id", 1));
+ doc.add(new SortedNumericDocValuesField("foo", 7));
+ doc.add(new SortedNumericDocValuesField("foo", 34));
+ doc.add(new SortedNumericDocValuesField("foo", 74));
+ w.addDocument(doc);
+ w.forceMerge(1);
+
+ DirectoryReader r = DirectoryReader.open(w);
+ LeafReader leaf = getOnlyLeafReader(r);
+ assertEquals(3, leaf.maxDoc());
+ NumericDocValues values = leaf.getNumericDocValues("id");
+ if (reverse) {
+ assertEquals(0, values.nextDoc());
+ assertEquals(3, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(2, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(1, values.longValue());
+ } else {
+ assertEquals(0, values.nextDoc());
+ assertEquals(1, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(2, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(3, values.longValue());
+ }
+ r.close();
+ w.close();
+ dir.close();
+ }
+ }
+
+ public void testBasicInt() throws Exception {
Directory dir = newDirectory();
IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- SortField sortField = new SortField("foo", SortField.Type.LONG);
- sortField.setMissingValue(Long.valueOf(Long.MIN_VALUE));
- Sort indexSort = new Sort(sortField);
+ Sort indexSort = new Sort(new SortField("foo", SortField.Type.INT));
iwc.setIndexSort(indexSort);
IndexWriter w = new IndexWriter(dir, iwc);
Document doc = new Document();
@@ -610,8 +852,9 @@ public class TestIndexSorting extends LuceneTestCase {
// so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
w.commit();
- // missing
- w.addDocument(new Document());
+ doc = new Document();
+ doc.add(new NumericDocValuesField("foo", -1));
+ w.addDocument(doc);
w.commit();
doc = new Document();
@@ -623,7 +866,8 @@ public class TestIndexSorting extends LuceneTestCase {
LeafReader leaf = getOnlyLeafReader(r);
assertEquals(3, leaf.maxDoc());
NumericDocValues values = leaf.getNumericDocValues("foo");
- // docID 0 has no value
+ assertEquals(0, values.nextDoc());
+ assertEquals(-1, values.longValue());
assertEquals(1, values.nextDoc());
assertEquals(7, values.longValue());
assertEquals(2, values.nextDoc());
@@ -633,195 +877,32 @@ public class TestIndexSorting extends LuceneTestCase {
dir.close();
}
- public void testMissingMultiValuedLongFirst() throws Exception {
+ public void testBasicMultiValuedInt() throws Exception {
Directory dir = newDirectory();
IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- SortField sortField = new SortedNumericSortField("foo", SortField.Type.LONG);
- sortField.setMissingValue(Long.valueOf(Long.MIN_VALUE));
- Sort indexSort = new Sort(sortField);
+ Sort indexSort = new Sort(new SortedNumericSortField("foo", SortField.Type.INT));
iwc.setIndexSort(indexSort);
IndexWriter w = new IndexWriter(dir, iwc);
Document doc = new Document();
doc.add(new NumericDocValuesField("id", 3));
doc.add(new SortedNumericDocValuesField("foo", 18));
- doc.add(new SortedNumericDocValuesField("foo", 27));
+ doc.add(new SortedNumericDocValuesField("foo", 34));
w.addDocument(doc);
// so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
w.commit();
- // missing
doc = new Document();
doc.add(new NumericDocValuesField("id", 1));
+ doc.add(new SortedNumericDocValuesField("foo", -1));
+ doc.add(new SortedNumericDocValuesField("foo", 34));
w.addDocument(doc);
w.commit();
doc = new Document();
doc.add(new NumericDocValuesField("id", 2));
doc.add(new SortedNumericDocValuesField("foo", 7));
- doc.add(new SortedNumericDocValuesField("foo", 24));
- w.addDocument(doc);
- w.forceMerge(1);
-
- DirectoryReader r = DirectoryReader.open(w);
- LeafReader leaf = getOnlyLeafReader(r);
- assertEquals(3, leaf.maxDoc());
- NumericDocValues values = leaf.getNumericDocValues("id");
- assertEquals(0, values.nextDoc());
- assertEquals(1, values.longValue());
- assertEquals(1, values.nextDoc());
- assertEquals(2, values.longValue());
- assertEquals(2, values.nextDoc());
- assertEquals(3, values.longValue());
- r.close();
- w.close();
- dir.close();
- }
-
- public void testMissingLongLast() throws Exception {
- Directory dir = newDirectory();
- IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- SortField sortField = new SortField("foo", SortField.Type.LONG);
- sortField.setMissingValue(Long.valueOf(Long.MAX_VALUE));
- Sort indexSort = new Sort(sortField);
- iwc.setIndexSort(indexSort);
- IndexWriter w = new IndexWriter(dir, iwc);
- Document doc = new Document();
- doc.add(new NumericDocValuesField("foo", 18));
- w.addDocument(doc);
- // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
- w.commit();
-
- // missing
- w.addDocument(new Document());
- w.commit();
-
- doc = new Document();
- doc.add(new NumericDocValuesField("foo", 7));
- w.addDocument(doc);
- w.forceMerge(1);
-
- DirectoryReader r = DirectoryReader.open(w);
- LeafReader leaf = getOnlyLeafReader(r);
- assertEquals(3, leaf.maxDoc());
- NumericDocValues values = leaf.getNumericDocValues("foo");
- assertEquals(0, values.nextDoc());
- assertEquals(7, values.longValue());
- assertEquals(1, values.nextDoc());
- assertEquals(18, values.longValue());
- assertEquals(NO_MORE_DOCS, values.nextDoc());
- r.close();
- w.close();
- dir.close();
- }
-
- public void testMissingMultiValuedLongLast() throws Exception {
- Directory dir = newDirectory();
- IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- SortField sortField = new SortedNumericSortField("foo", SortField.Type.LONG);
- sortField.setMissingValue(Long.valueOf(Long.MAX_VALUE));
- Sort indexSort = new Sort(sortField);
- iwc.setIndexSort(indexSort);
- IndexWriter w = new IndexWriter(dir, iwc);
- Document doc = new Document();
- doc.add(new NumericDocValuesField("id", 2));
- doc.add(new SortedNumericDocValuesField("foo", 18));
- doc.add(new SortedNumericDocValuesField("foo", 65));
- w.addDocument(doc);
- // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
- w.commit();
-
- // missing
- doc = new Document();
- doc.add(new NumericDocValuesField("id", 3));
- w.addDocument(doc);
- w.commit();
-
- doc = new Document();
- doc.add(new NumericDocValuesField("id", 1));
- doc.add(new SortedNumericDocValuesField("foo", 7));
- doc.add(new SortedNumericDocValuesField("foo", 34));
- doc.add(new SortedNumericDocValuesField("foo", 74));
- w.addDocument(doc);
- w.forceMerge(1);
-
- DirectoryReader r = DirectoryReader.open(w);
- LeafReader leaf = getOnlyLeafReader(r);
- assertEquals(3, leaf.maxDoc());
- NumericDocValues values = leaf.getNumericDocValues("id");
- assertEquals(0, values.nextDoc());
- assertEquals(1, values.longValue());
- assertEquals(1, values.nextDoc());
- assertEquals(2, values.longValue());
- assertEquals(2, values.nextDoc());
- assertEquals(3, values.longValue());
- r.close();
- w.close();
- dir.close();
- }
-
- public void testBasicInt() throws Exception {
- Directory dir = newDirectory();
- IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- Sort indexSort = new Sort(new SortField("foo", SortField.Type.INT));
- iwc.setIndexSort(indexSort);
- IndexWriter w = new IndexWriter(dir, iwc);
- Document doc = new Document();
- doc.add(new NumericDocValuesField("foo", 18));
- w.addDocument(doc);
- // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
- w.commit();
-
- doc = new Document();
- doc.add(new NumericDocValuesField("foo", -1));
- w.addDocument(doc);
- w.commit();
-
- doc = new Document();
- doc.add(new NumericDocValuesField("foo", 7));
- w.addDocument(doc);
- w.forceMerge(1);
-
- DirectoryReader r = DirectoryReader.open(w);
- LeafReader leaf = getOnlyLeafReader(r);
- assertEquals(3, leaf.maxDoc());
- NumericDocValues values = leaf.getNumericDocValues("foo");
- assertEquals(0, values.nextDoc());
- assertEquals(-1, values.longValue());
- assertEquals(1, values.nextDoc());
- assertEquals(7, values.longValue());
- assertEquals(2, values.nextDoc());
- assertEquals(18, values.longValue());
- r.close();
- w.close();
- dir.close();
- }
-
- public void testBasicMultiValuedInt() throws Exception {
- Directory dir = newDirectory();
- IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- Sort indexSort = new Sort(new SortedNumericSortField("foo", SortField.Type.INT));
- iwc.setIndexSort(indexSort);
- IndexWriter w = new IndexWriter(dir, iwc);
- Document doc = new Document();
- doc.add(new NumericDocValuesField("id", 3));
- doc.add(new SortedNumericDocValuesField("foo", 18));
- doc.add(new SortedNumericDocValuesField("foo", 34));
- w.addDocument(doc);
- // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
- w.commit();
-
- doc = new Document();
- doc.add(new NumericDocValuesField("id", 1));
- doc.add(new SortedNumericDocValuesField("foo", -1));
- doc.add(new SortedNumericDocValuesField("foo", 34));
- w.addDocument(doc);
- w.commit();
-
- doc = new Document();
- doc.add(new NumericDocValuesField("id", 2));
- doc.add(new SortedNumericDocValuesField("foo", 7));
- doc.add(new SortedNumericDocValuesField("foo", 22));
- doc.add(new SortedNumericDocValuesField("foo", 27));
+ doc.add(new SortedNumericDocValuesField("foo", 22));
+ doc.add(new SortedNumericDocValuesField("foo", 27));
w.addDocument(doc);
w.forceMerge(1);
@@ -841,332 +922,211 @@ public class TestIndexSorting extends LuceneTestCase {
}
public void testMissingIntFirst() throws Exception {
- Directory dir = newDirectory();
- IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- SortField sortField = new SortField("foo", SortField.Type.INT);
- sortField.setMissingValue(Integer.valueOf(Integer.MIN_VALUE));
- Sort indexSort = new Sort(sortField);
- iwc.setIndexSort(indexSort);
- IndexWriter w = new IndexWriter(dir, iwc);
- Document doc = new Document();
- doc.add(new NumericDocValuesField("foo", 18));
- w.addDocument(doc);
- // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
- w.commit();
+ for (boolean reverse : new boolean[] {true, false}) {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
+ SortField sortField = new SortField("foo", SortField.Type.INT, reverse);
+ sortField.setMissingValue(Integer.valueOf(Integer.MIN_VALUE));
+ Sort indexSort = new Sort(sortField);
+ iwc.setIndexSort(indexSort);
+ IndexWriter w = new IndexWriter(dir, iwc);
+ Document doc = new Document();
+ doc.add(new NumericDocValuesField("foo", 18));
+ w.addDocument(doc);
+ // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
+ w.commit();
- // missing
- w.addDocument(new Document());
- w.commit();
+ // missing
+ w.addDocument(new Document());
+ w.commit();
- doc = new Document();
- doc.add(new NumericDocValuesField("foo", 7));
- w.addDocument(doc);
- w.forceMerge(1);
+ doc = new Document();
+ doc.add(new NumericDocValuesField("foo", 7));
+ w.addDocument(doc);
+ w.forceMerge(1);
- DirectoryReader r = DirectoryReader.open(w);
- LeafReader leaf = getOnlyLeafReader(r);
- assertEquals(3, leaf.maxDoc());
- NumericDocValues values = leaf.getNumericDocValues("foo");
- assertEquals(1, values.nextDoc());
- assertEquals(7, values.longValue());
- assertEquals(2, values.nextDoc());
- assertEquals(18, values.longValue());
- r.close();
- w.close();
- dir.close();
+ DirectoryReader r = DirectoryReader.open(w);
+ LeafReader leaf = getOnlyLeafReader(r);
+ assertEquals(3, leaf.maxDoc());
+ NumericDocValues values = leaf.getNumericDocValues("foo");
+ if (reverse) {
+ assertEquals(0, values.nextDoc());
+ assertEquals(18, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(7, values.longValue());
+ } else {
+ assertEquals(1, values.nextDoc());
+ assertEquals(7, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(18, values.longValue());
+ }
+ r.close();
+ w.close();
+ dir.close();
+ }
}
public void testMissingMultiValuedIntFirst() throws Exception {
- Directory dir = newDirectory();
- IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- SortField sortField = new SortedNumericSortField("foo", SortField.Type.INT);
- sortField.setMissingValue(Integer.valueOf(Integer.MIN_VALUE));
- Sort indexSort = new Sort(sortField);
- iwc.setIndexSort(indexSort);
- IndexWriter w = new IndexWriter(dir, iwc);
- Document doc = new Document();
- doc.add(new NumericDocValuesField("id", 3));
- doc.add(new SortedNumericDocValuesField("foo", 18));
- doc.add(new SortedNumericDocValuesField("foo", 187667));
- w.addDocument(doc);
- // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
- w.commit();
+ for (boolean reverse : new boolean[] {true, false}) {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
+ SortField sortField = new SortedNumericSortField("foo", SortField.Type.INT, reverse);
+ sortField.setMissingValue(Integer.valueOf(Integer.MIN_VALUE));
+ Sort indexSort = new Sort(sortField);
+ iwc.setIndexSort(indexSort);
+ IndexWriter w = new IndexWriter(dir, iwc);
+ Document doc = new Document();
+ doc.add(new NumericDocValuesField("id", 3));
+ doc.add(new SortedNumericDocValuesField("foo", 18));
+ doc.add(new SortedNumericDocValuesField("foo", 187667));
+ w.addDocument(doc);
+ // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
+ w.commit();
- // missing
- doc = new Document();
- doc.add(new NumericDocValuesField("id", 1));
- w.addDocument(doc);
- w.commit();
+ // missing
+ doc = new Document();
+ doc.add(new NumericDocValuesField("id", 1));
+ w.addDocument(doc);
+ w.commit();
- doc = new Document();
- doc.add(new NumericDocValuesField("id", 2));
- doc.add(new SortedNumericDocValuesField("foo", 7));
- doc.add(new SortedNumericDocValuesField("foo", 34));
- w.addDocument(doc);
- w.forceMerge(1);
+ doc = new Document();
+ doc.add(new NumericDocValuesField("id", 2));
+ doc.add(new SortedNumericDocValuesField("foo", 7));
+ doc.add(new SortedNumericDocValuesField("foo", 34));
+ w.addDocument(doc);
+ w.forceMerge(1);
- DirectoryReader r = DirectoryReader.open(w);
- LeafReader leaf = getOnlyLeafReader(r);
- assertEquals(3, leaf.maxDoc());
- NumericDocValues values = leaf.getNumericDocValues("id");
- assertEquals(0, values.nextDoc());
- assertEquals(1, values.longValue());
- assertEquals(1, values.nextDoc());
- assertEquals(2, values.longValue());
- assertEquals(2, values.nextDoc());
- assertEquals(3, values.longValue());
- r.close();
- w.close();
- dir.close();
+ DirectoryReader r = DirectoryReader.open(w);
+ LeafReader leaf = getOnlyLeafReader(r);
+ assertEquals(3, leaf.maxDoc());
+ NumericDocValues values = leaf.getNumericDocValues("id");
+ if (reverse) {
+ assertEquals(0, values.nextDoc());
+ assertEquals(3, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(2, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(1, values.longValue());
+ } else {
+ assertEquals(0, values.nextDoc());
+ assertEquals(1, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(2, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(3, values.longValue());
+ }
+ r.close();
+ w.close();
+ dir.close();
+ }
}
public void testMissingIntLast() throws Exception {
- Directory dir = newDirectory();
- IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- SortField sortField = new SortField("foo", SortField.Type.INT);
- sortField.setMissingValue(Integer.valueOf(Integer.MAX_VALUE));
- Sort indexSort = new Sort(sortField);
- iwc.setIndexSort(indexSort);
- IndexWriter w = new IndexWriter(dir, iwc);
- Document doc = new Document();
- doc.add(new NumericDocValuesField("foo", 18));
- w.addDocument(doc);
- // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
- w.commit();
+ for (boolean reverse : new boolean[] {true, false}) {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
+ SortField sortField = new SortField("foo", SortField.Type.INT, reverse);
+ sortField.setMissingValue(Integer.valueOf(Integer.MAX_VALUE));
+ Sort indexSort = new Sort(sortField);
+ iwc.setIndexSort(indexSort);
+ IndexWriter w = new IndexWriter(dir, iwc);
+ Document doc = new Document();
+ doc.add(new NumericDocValuesField("foo", 18));
+ w.addDocument(doc);
+ // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
+ w.commit();
- // missing
- w.addDocument(new Document());
- w.commit();
+ // missing
+ w.addDocument(new Document());
+ w.commit();
- doc = new Document();
- doc.add(new NumericDocValuesField("foo", 7));
- w.addDocument(doc);
- w.forceMerge(1);
+ doc = new Document();
+ doc.add(new NumericDocValuesField("foo", 7));
+ w.addDocument(doc);
+ w.forceMerge(1);
- DirectoryReader r = DirectoryReader.open(w);
- LeafReader leaf = getOnlyLeafReader(r);
- assertEquals(3, leaf.maxDoc());
- NumericDocValues values = leaf.getNumericDocValues("foo");
- assertEquals(0, values.nextDoc());
- assertEquals(7, values.longValue());
- assertEquals(1, values.nextDoc());
- assertEquals(18, values.longValue());
- assertEquals(NO_MORE_DOCS, values.nextDoc());
- r.close();
- w.close();
- dir.close();
+ DirectoryReader r = DirectoryReader.open(w);
+ LeafReader leaf = getOnlyLeafReader(r);
+ assertEquals(3, leaf.maxDoc());
+ NumericDocValues values = leaf.getNumericDocValues("foo");
+ if (reverse) {
+ // docID 0 is missing
+ assertEquals(1, values.nextDoc());
+ assertEquals(18, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(7, values.longValue());
+ } else {
+ assertEquals(0, values.nextDoc());
+ assertEquals(7, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(18, values.longValue());
+ }
+ assertEquals(NO_MORE_DOCS, values.nextDoc());
+ r.close();
+ w.close();
+ dir.close();
+ }
}
public void testMissingMultiValuedIntLast() throws Exception {
- Directory dir = newDirectory();
- IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- SortField sortField = new SortedNumericSortField("foo", SortField.Type.INT);
- sortField.setMissingValue(Integer.valueOf(Integer.MAX_VALUE));
- Sort indexSort = new Sort(sortField);
- iwc.setIndexSort(indexSort);
- IndexWriter w = new IndexWriter(dir, iwc);
- Document doc = new Document();
- doc.add(new NumericDocValuesField("id", 2));
- doc.add(new SortedNumericDocValuesField("foo", 18));
- doc.add(new SortedNumericDocValuesField("foo", 6372));
- w.addDocument(doc);
- // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
- w.commit();
-
- // missing
- doc = new Document();
- doc.add(new NumericDocValuesField("id", 3));
- w.addDocument(doc);
- w.commit();
-
- doc = new Document();
- doc.add(new NumericDocValuesField("id", 1));
- doc.add(new SortedNumericDocValuesField("foo", 7));
- doc.add(new SortedNumericDocValuesField("foo", 8));
- w.addDocument(doc);
- w.forceMerge(1);
-
- DirectoryReader r = DirectoryReader.open(w);
- LeafReader leaf = getOnlyLeafReader(r);
- assertEquals(3, leaf.maxDoc());
- NumericDocValues values = leaf.getNumericDocValues("id");
- assertEquals(0, values.nextDoc());
- assertEquals(1, values.longValue());
- assertEquals(1, values.nextDoc());
- assertEquals(2, values.longValue());
- assertEquals(2, values.nextDoc());
- assertEquals(3, values.longValue());
- r.close();
- w.close();
- dir.close();
- }
-
- public void testBasicDouble() throws Exception {
- Directory dir = newDirectory();
- IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- Sort indexSort = new Sort(new SortField("foo", SortField.Type.DOUBLE));
- iwc.setIndexSort(indexSort);
- IndexWriter w = new IndexWriter(dir, iwc);
- Document doc = new Document();
- doc.add(new DoubleDocValuesField("foo", 18.0));
- w.addDocument(doc);
- // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
- w.commit();
-
- doc = new Document();
- doc.add(new DoubleDocValuesField("foo", -1.0));
- w.addDocument(doc);
- w.commit();
-
- doc = new Document();
- doc.add(new DoubleDocValuesField("foo", 7.0));
- w.addDocument(doc);
- w.forceMerge(1);
-
- DirectoryReader r = DirectoryReader.open(w);
- LeafReader leaf = getOnlyLeafReader(r);
- assertEquals(3, leaf.maxDoc());
- NumericDocValues values = leaf.getNumericDocValues("foo");
- assertEquals(0, values.nextDoc());
- assertEquals(-1.0, Double.longBitsToDouble(values.longValue()), 0.0);
- assertEquals(1, values.nextDoc());
- assertEquals(7.0, Double.longBitsToDouble(values.longValue()), 0.0);
- assertEquals(2, values.nextDoc());
- assertEquals(18.0, Double.longBitsToDouble(values.longValue()), 0.0);
- r.close();
- w.close();
- dir.close();
- }
-
- public void testBasicMultiValuedDouble() throws Exception {
- Directory dir = newDirectory();
- IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- Sort indexSort = new Sort(new SortedNumericSortField("foo", SortField.Type.DOUBLE));
- iwc.setIndexSort(indexSort);
- IndexWriter w = new IndexWriter(dir, iwc);
- Document doc = new Document();
- doc.add(new NumericDocValuesField("id", 3));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(7.54)));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(27.0)));
- w.addDocument(doc);
- // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
- w.commit();
-
- doc = new Document();
- doc.add(new NumericDocValuesField("id", 1));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(-1.0)));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(0.0)));
- w.addDocument(doc);
- w.commit();
-
- doc = new Document();
- doc.add(new NumericDocValuesField("id", 2));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(7.0)));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(7.67)));
- w.addDocument(doc);
- w.forceMerge(1);
-
- DirectoryReader r = DirectoryReader.open(w);
- LeafReader leaf = getOnlyLeafReader(r);
- assertEquals(3, leaf.maxDoc());
- NumericDocValues values = leaf.getNumericDocValues("id");
- assertEquals(0, values.nextDoc());
- assertEquals(1, values.longValue());
- assertEquals(1, values.nextDoc());
- assertEquals(2, values.longValue());
- assertEquals(2, values.nextDoc());
- assertEquals(3, values.longValue());
- r.close();
- w.close();
- dir.close();
- }
-
- public void testMissingDoubleFirst() throws Exception {
- Directory dir = newDirectory();
- IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- SortField sortField = new SortField("foo", SortField.Type.DOUBLE);
- sortField.setMissingValue(Double.NEGATIVE_INFINITY);
- Sort indexSort = new Sort(sortField);
- iwc.setIndexSort(indexSort);
- IndexWriter w = new IndexWriter(dir, iwc);
- Document doc = new Document();
- doc.add(new DoubleDocValuesField("foo", 18.0));
- w.addDocument(doc);
- // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
- w.commit();
-
- // missing
- w.addDocument(new Document());
- w.commit();
-
- doc = new Document();
- doc.add(new DoubleDocValuesField("foo", 7.0));
- w.addDocument(doc);
- w.forceMerge(1);
-
- DirectoryReader r = DirectoryReader.open(w);
- LeafReader leaf = getOnlyLeafReader(r);
- assertEquals(3, leaf.maxDoc());
- NumericDocValues values = leaf.getNumericDocValues("foo");
- assertEquals(1, values.nextDoc());
- assertEquals(7.0, Double.longBitsToDouble(values.longValue()), 0.0);
- assertEquals(2, values.nextDoc());
- assertEquals(18.0, Double.longBitsToDouble(values.longValue()), 0.0);
- r.close();
- w.close();
- dir.close();
- }
-
- public void testMissingMultiValuedDoubleFirst() throws Exception {
- Directory dir = newDirectory();
- IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- SortField sortField = new SortedNumericSortField("foo", SortField.Type.DOUBLE);
- sortField.setMissingValue(Double.NEGATIVE_INFINITY);
- Sort indexSort = new Sort(sortField);
- iwc.setIndexSort(indexSort);
- IndexWriter w = new IndexWriter(dir, iwc);
- Document doc = new Document();
- doc.add(new NumericDocValuesField("id", 3));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(18.0)));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(18.76)));
- w.addDocument(doc);
- // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
- w.commit();
+ for (boolean reverse : new boolean[] {true, false}) {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
+ SortField sortField = new SortedNumericSortField("foo", SortField.Type.INT, reverse);
+ sortField.setMissingValue(Integer.valueOf(Integer.MAX_VALUE));
+ Sort indexSort = new Sort(sortField);
+ iwc.setIndexSort(indexSort);
+ IndexWriter w = new IndexWriter(dir, iwc);
+ Document doc = new Document();
+ doc.add(new NumericDocValuesField("id", 2));
+ doc.add(new SortedNumericDocValuesField("foo", 18));
+ doc.add(new SortedNumericDocValuesField("foo", 6372));
+ w.addDocument(doc);
+ // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
+ w.commit();
- // missing
- doc = new Document();
- doc.add(new NumericDocValuesField("id", 1));
- w.addDocument(doc);
- w.commit();
+ // missing
+ doc = new Document();
+ doc.add(new NumericDocValuesField("id", 3));
+ w.addDocument(doc);
+ w.commit();
- doc = new Document();
- doc.add(new NumericDocValuesField("id", 2));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(7.0)));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(70.0)));
- w.addDocument(doc);
- w.forceMerge(1);
+ doc = new Document();
+ doc.add(new NumericDocValuesField("id", 1));
+ doc.add(new SortedNumericDocValuesField("foo", 7));
+ doc.add(new SortedNumericDocValuesField("foo", 8));
+ w.addDocument(doc);
+ w.forceMerge(1);
- DirectoryReader r = DirectoryReader.open(w);
- LeafReader leaf = getOnlyLeafReader(r);
- assertEquals(3, leaf.maxDoc());
- NumericDocValues values = leaf.getNumericDocValues("id");
- assertEquals(0, values.nextDoc());
- assertEquals(1, values.longValue());
- assertEquals(1, values.nextDoc());
- assertEquals(2, values.longValue());
- assertEquals(2, values.nextDoc());
- assertEquals(3, values.longValue());
- r.close();
- w.close();
- dir.close();
+ DirectoryReader r = DirectoryReader.open(w);
+ LeafReader leaf = getOnlyLeafReader(r);
+ assertEquals(3, leaf.maxDoc());
+ NumericDocValues values = leaf.getNumericDocValues("id");
+ if (reverse) {
+ assertEquals(0, values.nextDoc());
+ assertEquals(3, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(2, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(1, values.longValue());
+ } else {
+ assertEquals(0, values.nextDoc());
+ assertEquals(1, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(2, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(3, values.longValue());
+ }
+ r.close();
+ w.close();
+ dir.close();
+ }
}
- public void testMissingDoubleLast() throws Exception {
+ public void testBasicDouble() throws Exception {
Directory dir = newDirectory();
IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- SortField sortField = new SortField("foo", SortField.Type.DOUBLE);
- sortField.setMissingValue(Double.POSITIVE_INFINITY);
- Sort indexSort = new Sort(sortField);
+ Sort indexSort = new Sort(new SortField("foo", SortField.Type.DOUBLE));
iwc.setIndexSort(indexSort);
IndexWriter w = new IndexWriter(dir, iwc);
Document doc = new Document();
@@ -1175,8 +1135,9 @@ public class TestIndexSorting extends LuceneTestCase {
// so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
w.commit();
- // missing
- w.addDocument(new Document());
+ doc = new Document();
+ doc.add(new DoubleDocValuesField("foo", -1.0));
+ w.addDocument(doc);
w.commit();
doc = new Document();
@@ -1189,41 +1150,41 @@ public class TestIndexSorting extends LuceneTestCase {
assertEquals(3, leaf.maxDoc());
NumericDocValues values = leaf.getNumericDocValues("foo");
assertEquals(0, values.nextDoc());
- assertEquals(7.0, Double.longBitsToDouble(values.longValue()), 0.0);
+ assertEquals(-1.0, Double.longBitsToDouble(values.longValue()), 0.0);
assertEquals(1, values.nextDoc());
+ assertEquals(7.0, Double.longBitsToDouble(values.longValue()), 0.0);
+ assertEquals(2, values.nextDoc());
assertEquals(18.0, Double.longBitsToDouble(values.longValue()), 0.0);
- assertEquals(NO_MORE_DOCS, values.nextDoc());
r.close();
w.close();
dir.close();
}
- public void testMissingMultiValuedDoubleLast() throws Exception {
+ public void testBasicMultiValuedDouble() throws Exception {
Directory dir = newDirectory();
IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- SortField sortField = new SortedNumericSortField("foo", SortField.Type.DOUBLE);
- sortField.setMissingValue(Double.POSITIVE_INFINITY);
- Sort indexSort = new Sort(sortField);
+ Sort indexSort = new Sort(new SortedNumericSortField("foo", SortField.Type.DOUBLE));
iwc.setIndexSort(indexSort);
IndexWriter w = new IndexWriter(dir, iwc);
Document doc = new Document();
- doc.add(new NumericDocValuesField("id", 2));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(18.0)));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(8262.0)));
+ doc.add(new NumericDocValuesField("id", 3));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(7.54)));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(27.0)));
w.addDocument(doc);
// so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
w.commit();
- // missing
doc = new Document();
- doc.add(new NumericDocValuesField("id", 3));
+ doc.add(new NumericDocValuesField("id", 1));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(-1.0)));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(0.0)));
w.addDocument(doc);
w.commit();
doc = new Document();
- doc.add(new NumericDocValuesField("id", 1));
+ doc.add(new NumericDocValuesField("id", 2));
doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(7.0)));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(7.87)));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(7.67)));
w.addDocument(doc);
w.forceMerge(1);
@@ -1242,6 +1203,207 @@ public class TestIndexSorting extends LuceneTestCase {
dir.close();
}
+ public void testMissingDoubleFirst() throws Exception {
+ for (boolean reverse : new boolean[] {true, false}) {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
+ SortField sortField = new SortField("foo", SortField.Type.DOUBLE, reverse);
+ sortField.setMissingValue(Double.NEGATIVE_INFINITY);
+ Sort indexSort = new Sort(sortField);
+ iwc.setIndexSort(indexSort);
+ IndexWriter w = new IndexWriter(dir, iwc);
+ Document doc = new Document();
+ doc.add(new DoubleDocValuesField("foo", 18.0));
+ w.addDocument(doc);
+ // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
+ w.commit();
+
+ // missing
+ w.addDocument(new Document());
+ w.commit();
+
+ doc = new Document();
+ doc.add(new DoubleDocValuesField("foo", 7.0));
+ w.addDocument(doc);
+ w.forceMerge(1);
+
+ DirectoryReader r = DirectoryReader.open(w);
+ LeafReader leaf = getOnlyLeafReader(r);
+ assertEquals(3, leaf.maxDoc());
+ NumericDocValues values = leaf.getNumericDocValues("foo");
+ if (reverse) {
+ assertEquals(0, values.nextDoc());
+ assertEquals(18.0, Double.longBitsToDouble(values.longValue()), 0.0);
+ assertEquals(1, values.nextDoc());
+ assertEquals(7.0, Double.longBitsToDouble(values.longValue()), 0.0);
+ } else {
+ assertEquals(1, values.nextDoc());
+ assertEquals(7.0, Double.longBitsToDouble(values.longValue()), 0.0);
+ assertEquals(2, values.nextDoc());
+ assertEquals(18.0, Double.longBitsToDouble(values.longValue()), 0.0);
+ }
+ r.close();
+ w.close();
+ dir.close();
+ }
+ }
+
+ public void testMissingMultiValuedDoubleFirst() throws Exception {
+ for (boolean reverse : new boolean[] {true, false}) {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
+ SortField sortField = new SortedNumericSortField("foo", SortField.Type.DOUBLE, reverse);
+ sortField.setMissingValue(Double.NEGATIVE_INFINITY);
+ Sort indexSort = new Sort(sortField);
+ iwc.setIndexSort(indexSort);
+ IndexWriter w = new IndexWriter(dir, iwc);
+ Document doc = new Document();
+ doc.add(new NumericDocValuesField("id", 3));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(18.0)));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(18.76)));
+ w.addDocument(doc);
+ // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
+ w.commit();
+
+ // missing
+ doc = new Document();
+ doc.add(new NumericDocValuesField("id", 1));
+ w.addDocument(doc);
+ w.commit();
+
+ doc = new Document();
+ doc.add(new NumericDocValuesField("id", 2));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(7.0)));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(70.0)));
+ w.addDocument(doc);
+ w.forceMerge(1);
+
+ DirectoryReader r = DirectoryReader.open(w);
+ LeafReader leaf = getOnlyLeafReader(r);
+ assertEquals(3, leaf.maxDoc());
+ NumericDocValues values = leaf.getNumericDocValues("id");
+ if (reverse) {
+ assertEquals(0, values.nextDoc());
+ assertEquals(3, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(2, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(1, values.longValue());
+ } else {
+ assertEquals(0, values.nextDoc());
+ assertEquals(1, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(2, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(3, values.longValue());
+ }
+ r.close();
+ w.close();
+ dir.close();
+ }
+ }
+
+ public void testMissingDoubleLast() throws Exception {
+ for (boolean reverse : new boolean[] {true, false}) {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
+ SortField sortField = new SortField("foo", SortField.Type.DOUBLE, reverse);
+ sortField.setMissingValue(Double.POSITIVE_INFINITY);
+ Sort indexSort = new Sort(sortField);
+ iwc.setIndexSort(indexSort);
+ IndexWriter w = new IndexWriter(dir, iwc);
+ Document doc = new Document();
+ doc.add(new DoubleDocValuesField("foo", 18.0));
+ w.addDocument(doc);
+ // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
+ w.commit();
+
+ // missing
+ w.addDocument(new Document());
+ w.commit();
+
+ doc = new Document();
+ doc.add(new DoubleDocValuesField("foo", 7.0));
+ w.addDocument(doc);
+ w.forceMerge(1);
+
+ DirectoryReader r = DirectoryReader.open(w);
+ LeafReader leaf = getOnlyLeafReader(r);
+ assertEquals(3, leaf.maxDoc());
+ NumericDocValues values = leaf.getNumericDocValues("foo");
+ if (reverse) {
+ assertEquals(1, values.nextDoc());
+ assertEquals(18.0, Double.longBitsToDouble(values.longValue()), 0.0);
+ assertEquals(2, values.nextDoc());
+ assertEquals(7.0, Double.longBitsToDouble(values.longValue()), 0.0);
+ } else {
+ assertEquals(0, values.nextDoc());
+ assertEquals(7.0, Double.longBitsToDouble(values.longValue()), 0.0);
+ assertEquals(1, values.nextDoc());
+ assertEquals(18.0, Double.longBitsToDouble(values.longValue()), 0.0);
+ }
+ assertEquals(NO_MORE_DOCS, values.nextDoc());
+ r.close();
+ w.close();
+ dir.close();
+ }
+ }
+
+ public void testMissingMultiValuedDoubleLast() throws Exception {
+ for (boolean reverse : new boolean[] {true, false}) {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
+ SortField sortField = new SortedNumericSortField("foo", SortField.Type.DOUBLE, reverse);
+ sortField.setMissingValue(Double.POSITIVE_INFINITY);
+ Sort indexSort = new Sort(sortField);
+ iwc.setIndexSort(indexSort);
+ IndexWriter w = new IndexWriter(dir, iwc);
+ Document doc = new Document();
+ doc.add(new NumericDocValuesField("id", 2));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(18.0)));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(8262.0)));
+ w.addDocument(doc);
+ // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
+ w.commit();
+
+ // missing
+ doc = new Document();
+ doc.add(new NumericDocValuesField("id", 3));
+ w.addDocument(doc);
+ w.commit();
+
+ doc = new Document();
+ doc.add(new NumericDocValuesField("id", 1));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(7.0)));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(7.87)));
+ w.addDocument(doc);
+ w.forceMerge(1);
+
+ DirectoryReader r = DirectoryReader.open(w);
+ LeafReader leaf = getOnlyLeafReader(r);
+ assertEquals(3, leaf.maxDoc());
+ NumericDocValues values = leaf.getNumericDocValues("id");
+ if (reverse) {
+ assertEquals(0, values.nextDoc());
+ assertEquals(3, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(2, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(1, values.longValue());
+ } else {
+ assertEquals(0, values.nextDoc());
+ assertEquals(1, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(2, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(3, values.longValue());
+ }
+ r.close();
+ w.close();
+ dir.close();
+ }
+ }
+
public void testBasicFloat() throws Exception {
Directory dir = newDirectory();
IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
@@ -1322,164 +1484,204 @@ public class TestIndexSorting extends LuceneTestCase {
}
public void testMissingFloatFirst() throws Exception {
- Directory dir = newDirectory();
- IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- SortField sortField = new SortField("foo", SortField.Type.FLOAT);
- sortField.setMissingValue(Float.NEGATIVE_INFINITY);
- Sort indexSort = new Sort(sortField);
- iwc.setIndexSort(indexSort);
- IndexWriter w = new IndexWriter(dir, iwc);
- Document doc = new Document();
- doc.add(new FloatDocValuesField("foo", 18.0f));
- w.addDocument(doc);
- // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
- w.commit();
+ for (boolean reverse : new boolean[] {true, false}) {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
+ SortField sortField = new SortField("foo", SortField.Type.FLOAT, reverse);
+ sortField.setMissingValue(Float.NEGATIVE_INFINITY);
+ Sort indexSort = new Sort(sortField);
+ iwc.setIndexSort(indexSort);
+ IndexWriter w = new IndexWriter(dir, iwc);
+ Document doc = new Document();
+ doc.add(new FloatDocValuesField("foo", 18.0f));
+ w.addDocument(doc);
+ // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
+ w.commit();
- // missing
- w.addDocument(new Document());
- w.commit();
+ // missing
+ w.addDocument(new Document());
+ w.commit();
- doc = new Document();
- doc.add(new FloatDocValuesField("foo", 7.0f));
- w.addDocument(doc);
- w.forceMerge(1);
+ doc = new Document();
+ doc.add(new FloatDocValuesField("foo", 7.0f));
+ w.addDocument(doc);
+ w.forceMerge(1);
- DirectoryReader r = DirectoryReader.open(w);
- LeafReader leaf = getOnlyLeafReader(r);
- assertEquals(3, leaf.maxDoc());
- NumericDocValues values = leaf.getNumericDocValues("foo");
- assertEquals(1, values.nextDoc());
- assertEquals(7.0f, Float.intBitsToFloat((int) values.longValue()), 0.0f);
- assertEquals(2, values.nextDoc());
- assertEquals(18.0f, Float.intBitsToFloat((int) values.longValue()), 0.0f);
- r.close();
- w.close();
- dir.close();
+ DirectoryReader r = DirectoryReader.open(w);
+ LeafReader leaf = getOnlyLeafReader(r);
+ assertEquals(3, leaf.maxDoc());
+ NumericDocValues values = leaf.getNumericDocValues("foo");
+ if (reverse) {
+ assertEquals(0, values.nextDoc());
+ assertEquals(18.0f, Float.intBitsToFloat((int) values.longValue()), 0.0f);
+ assertEquals(1, values.nextDoc());
+ assertEquals(7.0f, Float.intBitsToFloat((int) values.longValue()), 0.0f);
+ } else {
+ assertEquals(1, values.nextDoc());
+ assertEquals(7.0f, Float.intBitsToFloat((int) values.longValue()), 0.0f);
+ assertEquals(2, values.nextDoc());
+ assertEquals(18.0f, Float.intBitsToFloat((int) values.longValue()), 0.0f);
+ }
+ r.close();
+ w.close();
+ dir.close();
+ }
}
public void testMissingMultiValuedFloatFirst() throws Exception {
- Directory dir = newDirectory();
- IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- SortField sortField = new SortedNumericSortField("foo", SortField.Type.FLOAT);
- sortField.setMissingValue(Float.NEGATIVE_INFINITY);
- Sort indexSort = new Sort(sortField);
- iwc.setIndexSort(indexSort);
- IndexWriter w = new IndexWriter(dir, iwc);
- Document doc = new Document();
- doc.add(new NumericDocValuesField("id", 3));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.floatToSortableInt(18.0f)));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.floatToSortableInt(726.0f)));
- w.addDocument(doc);
- // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
- w.commit();
+ for (boolean reverse : new boolean[] {true, false}) {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
+ SortField sortField = new SortedNumericSortField("foo", SortField.Type.FLOAT, reverse);
+ sortField.setMissingValue(Float.NEGATIVE_INFINITY);
+ Sort indexSort = new Sort(sortField);
+ iwc.setIndexSort(indexSort);
+ IndexWriter w = new IndexWriter(dir, iwc);
+ Document doc = new Document();
+ doc.add(new NumericDocValuesField("id", 3));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.floatToSortableInt(18.0f)));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.floatToSortableInt(726.0f)));
+ w.addDocument(doc);
+ // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
+ w.commit();
- // missing
- doc = new Document();
- doc.add(new NumericDocValuesField("id", 1));
- w.addDocument(doc);
- w.commit();
+ // missing
+ doc = new Document();
+ doc.add(new NumericDocValuesField("id", 1));
+ w.addDocument(doc);
+ w.commit();
- doc = new Document();
- doc.add(new NumericDocValuesField("id", 2));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.floatToSortableInt(7.0f)));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.floatToSortableInt(18.0f)));
- w.addDocument(doc);
- w.forceMerge(1);
+ doc = new Document();
+ doc.add(new NumericDocValuesField("id", 2));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.floatToSortableInt(7.0f)));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.floatToSortableInt(18.0f)));
+ w.addDocument(doc);
+ w.forceMerge(1);
- DirectoryReader r = DirectoryReader.open(w);
- LeafReader leaf = getOnlyLeafReader(r);
- assertEquals(3, leaf.maxDoc());
- NumericDocValues values = leaf.getNumericDocValues("id");
- assertEquals(0, values.nextDoc());
- assertEquals(1, values.longValue());
- assertEquals(1, values.nextDoc());
- assertEquals(2, values.longValue());
- assertEquals(2, values.nextDoc());
- assertEquals(3, values.longValue());
- r.close();
- w.close();
- dir.close();
+ DirectoryReader r = DirectoryReader.open(w);
+ LeafReader leaf = getOnlyLeafReader(r);
+ assertEquals(3, leaf.maxDoc());
+ NumericDocValues values = leaf.getNumericDocValues("id");
+ if (reverse) {
+ assertEquals(0, values.nextDoc());
+ assertEquals(3, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(2, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(1, values.longValue());
+ } else {
+ assertEquals(0, values.nextDoc());
+ assertEquals(1, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(2, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(3, values.longValue());
+ }
+ r.close();
+ w.close();
+ dir.close();
+ }
}
public void testMissingFloatLast() throws Exception {
- Directory dir = newDirectory();
- IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- SortField sortField = new SortField("foo", SortField.Type.FLOAT);
- sortField.setMissingValue(Float.POSITIVE_INFINITY);
- Sort indexSort = new Sort(sortField);
- iwc.setIndexSort(indexSort);
- IndexWriter w = new IndexWriter(dir, iwc);
- Document doc = new Document();
- doc.add(new FloatDocValuesField("foo", 18.0f));
- w.addDocument(doc);
- // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
- w.commit();
+ for (boolean reverse : new boolean[] {true, false}) {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
+ SortField sortField = new SortField("foo", SortField.Type.FLOAT, reverse);
+ sortField.setMissingValue(Float.POSITIVE_INFINITY);
+ Sort indexSort = new Sort(sortField);
+ iwc.setIndexSort(indexSort);
+ IndexWriter w = new IndexWriter(dir, iwc);
+ Document doc = new Document();
+ doc.add(new FloatDocValuesField("foo", 18.0f));
+ w.addDocument(doc);
+ // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
+ w.commit();
- // missing
- w.addDocument(new Document());
- w.commit();
+ // missing
+ w.addDocument(new Document());
+ w.commit();
- doc = new Document();
- doc.add(new FloatDocValuesField("foo", 7.0f));
- w.addDocument(doc);
- w.forceMerge(1);
+ doc = new Document();
+ doc.add(new FloatDocValuesField("foo", 7.0f));
+ w.addDocument(doc);
+ w.forceMerge(1);
- DirectoryReader r = DirectoryReader.open(w);
- LeafReader leaf = getOnlyLeafReader(r);
- assertEquals(3, leaf.maxDoc());
- NumericDocValues values = leaf.getNumericDocValues("foo");
- assertEquals(0, values.nextDoc());
- assertEquals(7.0f, Float.intBitsToFloat((int) values.longValue()), 0.0f);
- assertEquals(1, values.nextDoc());
- assertEquals(18.0f, Float.intBitsToFloat((int) values.longValue()), 0.0f);
- assertEquals(NO_MORE_DOCS, values.nextDoc());
- r.close();
- w.close();
- dir.close();
+ DirectoryReader r = DirectoryReader.open(w);
+ LeafReader leaf = getOnlyLeafReader(r);
+ assertEquals(3, leaf.maxDoc());
+ NumericDocValues values = leaf.getNumericDocValues("foo");
+ if (reverse) {
+ assertEquals(1, values.nextDoc());
+ assertEquals(18.0f, Float.intBitsToFloat((int) values.longValue()), 0.0f);
+ assertEquals(2, values.nextDoc());
+ assertEquals(7.0f, Float.intBitsToFloat((int) values.longValue()), 0.0f);
+ } else {
+ assertEquals(0, values.nextDoc());
+ assertEquals(7.0f, Float.intBitsToFloat((int) values.longValue()), 0.0f);
+ assertEquals(1, values.nextDoc());
+ assertEquals(18.0f, Float.intBitsToFloat((int) values.longValue()), 0.0f);
+ }
+ assertEquals(NO_MORE_DOCS, values.nextDoc());
+ r.close();
+ w.close();
+ dir.close();
+ }
}
public void testMissingMultiValuedFloatLast() throws Exception {
- Directory dir = newDirectory();
- IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- SortField sortField = new SortedNumericSortField("foo", SortField.Type.FLOAT);
- sortField.setMissingValue(Float.POSITIVE_INFINITY);
- Sort indexSort = new Sort(sortField);
- iwc.setIndexSort(indexSort);
- IndexWriter w = new IndexWriter(dir, iwc);
- Document doc = new Document();
- doc.add(new NumericDocValuesField("id", 2));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.floatToSortableInt(726.0f)));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.floatToSortableInt(18.0f)));
- w.addDocument(doc);
- // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
- w.commit();
+ for (boolean reverse : new boolean[] {true, false}) {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
+ SortField sortField = new SortedNumericSortField("foo", SortField.Type.FLOAT, reverse);
+ sortField.setMissingValue(Float.POSITIVE_INFINITY);
+ Sort indexSort = new Sort(sortField);
+ iwc.setIndexSort(indexSort);
+ IndexWriter w = new IndexWriter(dir, iwc);
+ Document doc = new Document();
+ doc.add(new NumericDocValuesField("id", 2));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.floatToSortableInt(726.0f)));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.floatToSortableInt(18.0f)));
+ w.addDocument(doc);
+ // so we get more than one segment, so that forceMerge actually does merge, since we only get a sorted segment by merging:
+ w.commit();
- // missing
- doc = new Document();
- doc.add(new NumericDocValuesField("id", 3));
- w.addDocument(doc);
- w.commit();
+ // missing
+ doc = new Document();
+ doc.add(new NumericDocValuesField("id", 3));
+ w.addDocument(doc);
+ w.commit();
- doc = new Document();
- doc.add(new NumericDocValuesField("id", 1));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.floatToSortableInt(12.67f)));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.floatToSortableInt(7.0f)));
- w.addDocument(doc);
- w.forceMerge(1);
+ doc = new Document();
+ doc.add(new NumericDocValuesField("id", 1));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.floatToSortableInt(12.67f)));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.floatToSortableInt(7.0f)));
+ w.addDocument(doc);
+ w.forceMerge(1);
- DirectoryReader r = DirectoryReader.open(w);
- LeafReader leaf = getOnlyLeafReader(r);
- assertEquals(3, leaf.maxDoc());
- NumericDocValues values = leaf.getNumericDocValues("id");
- assertEquals(0, values.nextDoc());
- assertEquals(1, values.longValue());
- assertEquals(1, values.nextDoc());
- assertEquals(2, values.longValue());
- assertEquals(2, values.nextDoc());
- assertEquals(3, values.longValue());
- r.close();
- w.close();
- dir.close();
+ DirectoryReader r = DirectoryReader.open(w);
+ LeafReader leaf = getOnlyLeafReader(r);
+ assertEquals(3, leaf.maxDoc());
+ NumericDocValues values = leaf.getNumericDocValues("id");
+ if (reverse) {
+ assertEquals(0, values.nextDoc());
+ assertEquals(3, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(2, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(1, values.longValue());
+ } else {
+ assertEquals(0, values.nextDoc());
+ assertEquals(1, values.longValue());
+ assertEquals(1, values.nextDoc());
+ assertEquals(2, values.longValue());
+ assertEquals(2, values.nextDoc());
+ assertEquals(3, values.longValue());
+ }
+ r.close();
+ w.close();
+ dir.close();
+ }
}
public void testRandom1() throws IOException {