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:34 UTC
[05/47] lucene-solr:jira/http2: Revert "Add the ability to set the
number of hits to track accurately"
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/da7919f7/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 5bfd9d5..3857a97 100644
--- a/lucene/core/src/test/org/apache/lucene/index/TestIndexSorting.java
+++ b/lucene/core/src/test/org/apache/lucene/index/TestIndexSorting.java
@@ -355,206 +355,166 @@ public class TestIndexSorting extends LuceneTestCase {
}
public void testMissingStringFirst() 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.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();
+ 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();
- // 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");
- 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();
- }
+ 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();
}
public void testMissingMultiValuedStringFirst() throws Exception {
- 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();
+ 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();
- // 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");
- 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();
- }
+ 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();
}
public void testMissingStringLast() 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.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();
+ 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();
- // 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");
- 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();
- }
+ 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();
}
public void testMissingMultiValuedStringLast() throws Exception {
- 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();
+ 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();
- // 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");
- 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();
- }
+ 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();
}
public void testBasicLong() throws Exception {
@@ -637,213 +597,11 @@ 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()));
- Sort indexSort = new Sort(new SortField("foo", SortField.Type.INT));
+ SortField sortField = new SortField("foo", SortField.Type.LONG);
+ 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();
@@ -852,9 +610,8 @@ 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();
- doc = new Document();
- doc.add(new NumericDocValuesField("foo", -1));
- w.addDocument(doc);
+ // missing
+ w.addDocument(new Document());
w.commit();
doc = new Document();
@@ -866,8 +623,7 @@ public class TestIndexSorting extends LuceneTestCase {
LeafReader leaf = getOnlyLeafReader(r);
assertEquals(3, leaf.maxDoc());
NumericDocValues values = leaf.getNumericDocValues("foo");
- assertEquals(0, values.nextDoc());
- assertEquals(-1, values.longValue());
+ // docID 0 has no value
assertEquals(1, values.nextDoc());
assertEquals(7, values.longValue());
assertEquals(2, values.nextDoc());
@@ -877,32 +633,32 @@ public class TestIndexSorting extends LuceneTestCase {
dir.close();
}
- public void testBasicMultiValuedInt() throws Exception {
+ public void testMissingMultiValuedLongFirst() throws Exception {
Directory dir = newDirectory();
IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- Sort indexSort = new Sort(new SortedNumericSortField("foo", SortField.Type.INT));
+ SortField sortField = new SortedNumericSortField("foo", SortField.Type.LONG);
+ 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", 34));
+ 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));
- 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", 24));
w.addDocument(doc);
w.forceMerge(1);
@@ -921,212 +677,496 @@ public class TestIndexSorting extends LuceneTestCase {
dir.close();
}
- public void testMissingIntFirst() 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.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();
-
- doc = new Document();
- doc.add(new NumericDocValuesField("foo", 7));
- w.addDocument(doc);
- w.forceMerge(1);
+ 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();
- 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();
- }
+ // 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));
+ 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 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();
+
+ // 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(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 {
- 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();
+ 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();
- // 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");
- 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();
- }
+ 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 testMissingIntLast() 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.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();
+ 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();
- // 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");
- 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();
- }
+ 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 testMissingMultiValuedIntLast() 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.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();
+ 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();
+ // 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);
+ 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");
- 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();
- }
+ 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();
+
+ // 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");
+ 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 {
+ public void testMissingDoubleLast() throws Exception {
Directory dir = newDirectory();
IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- Sort indexSort = new Sort(new SortField("foo", SortField.Type.DOUBLE));
+ SortField sortField = new SortField("foo", SortField.Type.DOUBLE);
+ sortField.setMissingValue(Double.POSITIVE_INFINITY);
+ Sort indexSort = new Sort(sortField);
iwc.setIndexSort(indexSort);
IndexWriter w = new IndexWriter(dir, iwc);
Document doc = new Document();
@@ -1135,9 +1175,8 @@ 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();
- doc = new Document();
- doc.add(new DoubleDocValuesField("foo", -1.0));
- w.addDocument(doc);
+ // missing
+ w.addDocument(new Document());
w.commit();
doc = new Document();
@@ -1150,41 +1189,41 @@ public class TestIndexSorting extends LuceneTestCase {
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(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 testBasicMultiValuedDouble() throws Exception {
+ public void testMissingMultiValuedDoubleLast() throws Exception {
Directory dir = newDirectory();
IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
- Sort indexSort = new Sort(new SortedNumericSortField("foo", SortField.Type.DOUBLE));
+ SortField sortField = new SortedNumericSortField("foo", SortField.Type.DOUBLE);
+ 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", 3));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(7.54)));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(27.0)));
+ 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", 1));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(-1.0)));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(0.0)));
+ doc.add(new NumericDocValuesField("id", 3));
w.addDocument(doc);
w.commit();
doc = new Document();
- doc.add(new NumericDocValuesField("id", 2));
+ doc.add(new NumericDocValuesField("id", 1));
doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(7.0)));
- doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(7.67)));
+ doc.add(new SortedNumericDocValuesField("foo", NumericUtils.doubleToSortableLong(7.87)));
w.addDocument(doc);
w.forceMerge(1);
@@ -1203,207 +1242,6 @@ 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()));
@@ -1484,204 +1322,164 @@ public class TestIndexSorting extends LuceneTestCase {
}
public void testMissingFloatFirst() 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.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();
+ 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();
- // 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");
- 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();
- }
+ 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();
}
public void testMissingMultiValuedFloatFirst() 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.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();
+ 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();
- // 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");
- 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();
- }
+ 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 testMissingFloatLast() 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.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();
+ 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();
- // 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");
- 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();
- }
+ 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();
}
public void testMissingMultiValuedFloatLast() 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.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();
+ 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();
- // 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");
- 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();
- }
+ 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 testRandom1() throws IOException {