Java SortField.setMissingValue方法代码示例

import org.apache.lucene.search.SortField; //导入方法依赖的package包/类
/**
 * Comes from Sorting of Solr
 * 
 * Returns a {@link SortField} for a string field.
 *  If nullLast and nullFirst are both false, then default lucene string sorting is used where
 *  null strings sort first in an ascending sort, and last in a descending sort.
 *
 * @param fieldName   the name of the field to sort on
 * @param reverse     true for a reverse (desc) sort
 * @param nullLast    true if null should come last, regardless of sort order
 * @param nullFirst   true if null should come first, regardless of sort order
 * @return SortField
 */
public static SortField getStringSortField(String fieldName, boolean reverse, boolean nullLast, boolean nullFirst) {
	if (nullFirst && nullLast) {
		throw new IllegalArgumentException("Cannot specify missing values as both first and last");
	}

	SortField sortField = new SortField(fieldName, SortField.Type.STRING, reverse);

	// 4 cases:
	// missingFirst / forward: default lucene behavior
	// missingFirst / reverse: set sortMissingLast
	// missingLast / forward: set sortMissingLast
	// missingLast / reverse: default lucene behavior

	if (nullFirst && reverse) {
		sortField.setMissingValue(SortField.STRING_LAST);
	} else if (nullLast && !reverse) {
		sortField.setMissingValue(SortField.STRING_LAST);
	}

	return sortField;
}
 

import org.apache.lucene.search.SortField; //导入方法依赖的package包/类
public static SortField getLongSortField(String fieldName, boolean reverse, boolean nullLast, boolean nullFirst) {
	if (nullFirst && nullLast) {
		throw new IllegalArgumentException("Cannot specify missing values as both first and last");
	}

	SortField sortField = new SortField(fieldName, SortField.Type.LONG, reverse);

	// 4 cases:
	// missingFirst / forward: default lucene behavior
	// missingFirst / reverse: set sortMissingLast
	// missingLast / forward: set sortMissingLast
	// missingLast / reverse: default lucene behavior

	if (nullFirst && reverse) {
		sortField.setMissingValue(Long.MAX_VALUE);
	} else if (nullLast && !reverse) {
		sortField.setMissingValue(Long.MAX_VALUE);
	}

	return sortField;
}
 

import org.apache.lucene.search.SortField; //导入方法依赖的package包/类
public static SortField readSortField(StreamInput in) throws IOException {
    String field = null;
    if (in.readBoolean()) {
        field = in.readString();
    }
    SortField.Type sortType = readSortType(in);
    Object missingValue = readMissingValue(in);
    boolean reverse = in.readBoolean();
    SortField sortField = new SortField(field, sortType, reverse);
    if (missingValue != null) {
        sortField.setMissingValue(missingValue);
    }
    return sortField;
}
 

import org.apache.lucene.search.SortField; //导入方法依赖的package包/类
public static void writeSortField(StreamOutput out, SortField sortField) throws IOException {
    if (sortField.getClass() == GEO_DISTANCE_SORT_TYPE_CLASS) {
        // for geo sorting, we replace the SortField with a SortField that assumes a double field.
        // this works since the SortField is only used for merging top docs
        SortField newSortField = new SortField(sortField.getField(), SortField.Type.DOUBLE);
        newSortField.setMissingValue(sortField.getMissingValue());
        sortField = newSortField;
    }
    if (sortField.getClass() != SortField.class) {
        throw new IllegalArgumentException("Cannot serialize SortField impl [" + sortField + "]");
    }
    if (sortField.getField() == null) {
        out.writeBoolean(false);
    } else {
        out.writeBoolean(true);
        out.writeString(sortField.getField());
    }
    if (sortField.getComparatorSource() != null) {
        IndexFieldData.XFieldComparatorSource comparatorSource = (IndexFieldData.XFieldComparatorSource) sortField.getComparatorSource();
        writeSortType(out, comparatorSource.reducedType());
        writeMissingValue(out, comparatorSource.missingValue(sortField.getReverse()));
    } else {
        writeSortType(out, sortField.getType());
        writeMissingValue(out, sortField.getMissingValue());
    }
    out.writeBoolean(sortField.getReverse());
}
 

import org.apache.lucene.search.SortField; //导入方法依赖的package包/类
public void testEmptyNumericSegment() throws Exception {
    final Directory dir = newDirectory();
    final RandomIndexWriter w = new RandomIndexWriter(random(), dir);
    Document doc = new Document();
    doc.add(new NumericDocValuesField("group", 0));
    w.addDocument(doc);
    doc.clear();
    doc.add(new NumericDocValuesField("group", 1));
    w.addDocument(doc);
    w.commit();
    doc.clear();
    doc.add(new NumericDocValuesField("group", 10));
    w.addDocument(doc);
    w.commit();
    doc.clear();
    doc.add(new NumericDocValuesField("category", 0));
    w.addDocument(doc);
    w.commit();
    final IndexReader reader = w.getReader();
    final IndexSearcher searcher = newSearcher(reader);
    SortField sortField = new SortField("group", SortField.Type.LONG);
    sortField.setMissingValue(Long.MAX_VALUE);
    Sort sort = new Sort(sortField);
    final CollapsingTopDocsCollector collapsingCollector =
            CollapsingTopDocsCollector.createNumeric("group", sort, 10, false);
    searcher.search(new MatchAllDocsQuery(), collapsingCollector);
    CollapseTopFieldDocs collapseTopFieldDocs = collapsingCollector.getTopDocs();
    assertEquals(4, collapseTopFieldDocs.scoreDocs.length);
    assertEquals(4, collapseTopFieldDocs.collapseValues.length);
    assertEquals(0L, collapseTopFieldDocs.collapseValues[0]);
    assertEquals(1L, collapseTopFieldDocs.collapseValues[1]);
    assertEquals(10L, collapseTopFieldDocs.collapseValues[2]);
    assertNull(collapseTopFieldDocs.collapseValues[3]);
    w.close();
    reader.close();
    dir.close();
}
 

import org.apache.lucene.search.SortField; //导入方法依赖的package包/类
private void setMissingValuesOrder(SortField sf, SortField.Type type, boolean desc) {
    switch (type) {
        case STRING:
            sf.setMissingValue(desc ? SortField.STRING_FIRST : SortField.STRING_LAST);
            break;
        case FLOAT:
            sf.setMissingValue(Float.MIN_VALUE);
            break;
        case INT:
            sf.setMissingValue(Integer.MIN_VALUE);
            break;
        default:
            throw new IllegalArgumentException("Unexpected sort type: " + type);
    }
}
 

import org.apache.lucene.search.SortField; //导入方法依赖的package包/类
public void testMissingFirst() throws Exception {
  Directory dir = newDirectory();
  RandomIndexWriter writer = new RandomIndexWriter(random(), dir);
  Document doc = new Document();
  doc.add(new SortedSetDocValuesField("value", new BytesRef("baz")));
  doc.add(newStringField("id", "2", Field.Store.YES));
  writer.addDocument(doc);
  doc = new Document();
  doc.add(new SortedSetDocValuesField("value", new BytesRef("foo")));
  doc.add(new SortedSetDocValuesField("value", new BytesRef("bar")));
  doc.add(newStringField("id", "1", Field.Store.YES));
  writer.addDocument(doc);
  doc = new Document();
  doc.add(newStringField("id", "3", Field.Store.YES));
  writer.addDocument(doc);
  IndexReader ir = writer.getReader();
  writer.close();
  
  IndexSearcher searcher = newSearcher(ir);
  SortField sortField = new SortedSetSortField("value", false);
  sortField.setMissingValue(SortField.STRING_FIRST);
  Sort sort = new Sort(sortField);

  TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
  assertEquals(3, td.totalHits);
  // 'bar' comes before 'baz'
  // null comes first
  assertEquals("3", searcher.doc(td.scoreDocs[0].doc).get("id"));
  assertEquals("1", searcher.doc(td.scoreDocs[1].doc).get("id"));
  assertEquals("2", searcher.doc(td.scoreDocs[2].doc).get("id"));
  assertNoFieldCaches();

  ir.close();
  dir.close();
}
 

import org.apache.lucene.search.SortField; //导入方法依赖的package包/类
public void testMissingLast() throws Exception {
  Directory dir = newDirectory();
  RandomIndexWriter writer = new RandomIndexWriter(random(), dir);
  Document doc = new Document();
  doc.add(new SortedSetDocValuesField("value", new BytesRef("baz")));
  doc.add(newStringField("id", "2", Field.Store.YES));
  writer.addDocument(doc);
  doc = new Document();
  doc.add(new SortedSetDocValuesField("value", new BytesRef("foo")));
  doc.add(new SortedSetDocValuesField("value", new BytesRef("bar")));
  doc.add(newStringField("id", "1", Field.Store.YES));
  writer.addDocument(doc);
  doc = new Document();
  doc.add(newStringField("id", "3", Field.Store.YES));
  writer.addDocument(doc);
  IndexReader ir = writer.getReader();
  writer.close();
  
  IndexSearcher searcher = newSearcher(ir);
  SortField sortField = new SortedSetSortField("value", false);
  sortField.setMissingValue(SortField.STRING_LAST);
  Sort sort = new Sort(sortField);

  TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
  assertEquals(3, td.totalHits);
  // 'bar' comes before 'baz'
  assertEquals("1", searcher.doc(td.scoreDocs[0].doc).get("id"));
  assertEquals("2", searcher.doc(td.scoreDocs[1].doc).get("id"));
  // null comes last
  assertEquals("3", searcher.doc(td.scoreDocs[2].doc).get("id"));
  assertNoFieldCaches();

  ir.close();
  dir.close();
}
 

import org.apache.lucene.search.SortField; //导入方法依赖的package包/类
public void testMaxMissingFirst() throws Exception {
  Directory dir = newDirectory();
  RandomIndexWriter writer = new RandomIndexWriter(random(), dir);
  Document doc = new Document();
  doc.add(newStringField("id", "1", Field.Store.YES));
  writer.addDocument(doc);
  doc = new Document();
  doc.add(new SortedSetDocValuesField("value", new BytesRef("foo")));
  doc.add(new SortedSetDocValuesField("value", new BytesRef("bar")));
  doc.add(newStringField("id", "2", Field.Store.YES));
  writer.addDocument(doc);
  doc = new Document();
  doc.add(new SortedSetDocValuesField("value", new BytesRef("baz")));
  doc.add(newStringField("id", "3", Field.Store.YES));
  writer.addDocument(doc);
  IndexReader ir = writer.getReader();
  writer.close();

  // slow wrapper does not support random access ordinals (there is no need for that!)
  IndexSearcher searcher = newSearcher(ir, false);
  
  SortField sortField = new SortedSetSortField("value", false, SortedSetSortField.Selector.MAX);
  sortField.setMissingValue(SortField.STRING_FIRST);
  Sort sort = new Sort(sortField);

  TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
  assertEquals(3, td.totalHits);
  // null comes first
  assertEquals("1", searcher.doc(td.scoreDocs[0].doc).get("id"));
  // 'baz' comes before 'foo'
  assertEquals("3", searcher.doc(td.scoreDocs[1].doc).get("id"));
  assertEquals("2", searcher.doc(td.scoreDocs[2].doc).get("id"));
  assertNoFieldCaches();
  
  ir.close();
  dir.close();
}
 

import org.apache.lucene.search.SortField; //导入方法依赖的package包/类
public void testMaxMissingLast() throws Exception {
  Directory dir = newDirectory();
  RandomIndexWriter writer = new RandomIndexWriter(random(), dir);
  Document doc = new Document();
  doc.add(newStringField("id", "1", Field.Store.YES));
  writer.addDocument(doc);
  doc = new Document();
  doc.add(new SortedSetDocValuesField("value", new BytesRef("foo")));
  doc.add(new SortedSetDocValuesField("value", new BytesRef("bar")));
  doc.add(newStringField("id", "2", Field.Store.YES));
  writer.addDocument(doc);
  doc = new Document();
  doc.add(new SortedSetDocValuesField("value", new BytesRef("baz")));
  doc.add(newStringField("id", "3", Field.Store.YES));
  writer.addDocument(doc);
  IndexReader ir = writer.getReader();
  writer.close();

  // slow wrapper does not support random access ordinals (there is no need for that!)
  IndexSearcher searcher = newSearcher(ir, false);
  
  SortField sortField = new SortedSetSortField("value", false, SortedSetSortField.Selector.MAX);
  sortField.setMissingValue(SortField.STRING_LAST);
  Sort sort = new Sort(sortField);

  TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
  assertEquals(3, td.totalHits);
  // 'baz' comes before 'foo'
  assertEquals("3", searcher.doc(td.scoreDocs[0].doc).get("id"));
  assertEquals("2", searcher.doc(td.scoreDocs[1].doc).get("id"));
  // null comes last
  assertEquals("1", searcher.doc(td.scoreDocs[2].doc).get("id"));
  assertNoFieldCaches();
  
  ir.close();
  dir.close();
}
 

import org.apache.lucene.search.SortField; //导入方法依赖的package包/类
public void testMiddleMinMissingFirst() throws Exception {
  Directory dir = newDirectory();
  RandomIndexWriter writer = new RandomIndexWriter(random(), dir);
  Document doc = new Document();
  doc.add(newStringField("id", "3", Field.Store.YES));
  writer.addDocument(doc);
  doc = new Document();
  doc.add(new SortedSetDocValuesField("value", new BytesRef("c")));
  doc.add(newStringField("id", "2", Field.Store.YES));
  writer.addDocument(doc);
  doc = new Document();
  doc.add(new SortedSetDocValuesField("value", new BytesRef("a")));
  doc.add(new SortedSetDocValuesField("value", new BytesRef("b")));
  doc.add(new SortedSetDocValuesField("value", new BytesRef("c")));
  doc.add(new SortedSetDocValuesField("value", new BytesRef("d")));
  doc.add(newStringField("id", "1", Field.Store.YES));
  writer.addDocument(doc);
  IndexReader ir = writer.getReader();
  writer.close();
  
  // slow wrapper does not support random access ordinals (there is no need for that!)
  IndexSearcher searcher = newSearcher(ir, false);
  SortField sortField = new SortedSetSortField("value", false, SortedSetSortField.Selector.MIDDLE_MIN);
  sortField.setMissingValue(SortField.STRING_FIRST);
  Sort sort = new Sort(sortField);

  TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
  assertEquals(3, td.totalHits);
  // null comes first
  assertEquals("3", searcher.doc(td.scoreDocs[0].doc).get("id"));
  // 'b' comes before 'c'
  assertEquals("1", searcher.doc(td.scoreDocs[1].doc).get("id"));
  assertEquals("2", searcher.doc(td.scoreDocs[2].doc).get("id"));
  assertNoFieldCaches();
  
  ir.close();
  dir.close();
}
 

import org.apache.lucene.search.SortField; //导入方法依赖的package包/类
public void testMiddleMinMissingLast() throws Exception {
  Directory dir = newDirectory();
  RandomIndexWriter writer = new RandomIndexWriter(random(), dir);
  Document doc = new Document();
  doc.add(newStringField("id", "3", Field.Store.YES));
  writer.addDocument(doc);
  doc = new Document();
  doc.add(new SortedSetDocValuesField("value", new BytesRef("c")));
  doc.add(newStringField("id", "2", Field.Store.YES));
  writer.addDocument(doc);
  doc = new Document();
  doc.add(new SortedSetDocValuesField("value", new BytesRef("a")));
  doc.add(new SortedSetDocValuesField("value", new BytesRef("b")));
  doc.add(new SortedSetDocValuesField("value", new BytesRef("c")));
  doc.add(new SortedSetDocValuesField("value", new BytesRef("d")));
  doc.add(newStringField("id", "1", Field.Store.YES));
  writer.addDocument(doc);
  IndexReader ir = writer.getReader();
  writer.close();
  
  // slow wrapper does not support random access ordinals (there is no need for that!)
  IndexSearcher searcher = newSearcher(ir, false);
  SortField sortField = new SortedSetSortField("value", false, SortedSetSortField.Selector.MIDDLE_MIN);
  sortField.setMissingValue(SortField.STRING_LAST);
  Sort sort = new Sort(sortField);

  TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
  assertEquals(3, td.totalHits);
  // 'b' comes before 'c'
  assertEquals("1", searcher.doc(td.scoreDocs[0].doc).get("id"));
  assertEquals("2", searcher.doc(td.scoreDocs[1].doc).get("id"));
  // null comes last
  assertEquals("3", searcher.doc(td.scoreDocs[2].doc).get("id"));
  assertNoFieldCaches();
  
  ir.close();
  dir.close();
}
 

import org.apache.lucene.search.SortField; //导入方法依赖的package包/类
public void testMiddleMaxMissingFirst() throws Exception {
  Directory dir = newDirectory();
  RandomIndexWriter writer = new RandomIndexWriter(random(), dir);
  Document doc = new Document();
  doc.add(newStringField("id", "3", Field.Store.YES));
  writer.addDocument(doc);
  doc = new Document();
  doc.add(new SortedSetDocValuesField("value", new BytesRef("a")));
  doc.add(new SortedSetDocValuesField("value", new BytesRef("b")));
  doc.add(new SortedSetDocValuesField("value", new BytesRef("c")));
  doc.add(new SortedSetDocValuesField("value", new BytesRef("d")));
  doc.add(newStringField("id", "1", Field.Store.YES));
  writer.addDocument(doc);
  doc = new Document();
  doc.add(new SortedSetDocValuesField("value", new BytesRef("b")));
  doc.add(newStringField("id", "2", Field.Store.YES));
  writer.addDocument(doc);
  IndexReader ir = writer.getReader();
  writer.close();
  
  // slow wrapper does not support random access ordinals (there is no need for that!)
  IndexSearcher searcher = newSearcher(ir, false);
  SortField sortField = new SortedSetSortField("value", false, SortedSetSortField.Selector.MIDDLE_MAX);
  sortField.setMissingValue(SortField.STRING_FIRST);
  Sort sort = new Sort(sortField);

  TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
  assertEquals(3, td.totalHits);
  // null comes first
  assertEquals("3", searcher.doc(td.scoreDocs[0].doc).get("id"));
  // 'b' comes before 'c'
  assertEquals("2", searcher.doc(td.scoreDocs[1].doc).get("id"));
  assertEquals("1", searcher.doc(td.scoreDocs[2].doc).get("id"));
  assertNoFieldCaches();
  
  ir.close();
  dir.close();
}
 

import org.apache.lucene.search.SortField; //导入方法依赖的package包/类
public void testMiddleMaxMissingLast() throws Exception {
  Directory dir = newDirectory();
  RandomIndexWriter writer = new RandomIndexWriter(random(), dir);
  Document doc = new Document();
  doc.add(newStringField("id", "3", Field.Store.YES));
  writer.addDocument(doc);
  doc = new Document();
  doc.add(new SortedSetDocValuesField("value", new BytesRef("a")));
  doc.add(new SortedSetDocValuesField("value", new BytesRef("b")));
  doc.add(new SortedSetDocValuesField("value", new BytesRef("c")));
  doc.add(new SortedSetDocValuesField("value", new BytesRef("d")));
  doc.add(newStringField("id", "1", Field.Store.YES));
  writer.addDocument(doc);
  doc = new Document();
  doc.add(new SortedSetDocValuesField("value", new BytesRef("b")));
  doc.add(newStringField("id", "2", Field.Store.YES));
  writer.addDocument(doc);
  IndexReader ir = writer.getReader();
  writer.close();
  
  // slow wrapper does not support random access ordinals (there is no need for that!)
  IndexSearcher searcher = newSearcher(ir, false);
  SortField sortField = new SortedSetSortField("value", false, SortedSetSortField.Selector.MIDDLE_MAX);
  sortField.setMissingValue(SortField.STRING_LAST);
  Sort sort = new Sort(sortField);

  TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
  assertEquals(3, td.totalHits);
  // 'b' comes before 'c'
  assertEquals("2", searcher.doc(td.scoreDocs[0].doc).get("id"));
  assertEquals("1", searcher.doc(td.scoreDocs[1].doc).get("id"));
  // null comes last
  assertEquals("3", searcher.doc(td.scoreDocs[2].doc).get("id"));
  assertNoFieldCaches();
  
  ir.close();
  dir.close();
}
 

import org.apache.lucene.search.SortField; //导入方法依赖的package包/类
public void testMissingFirst() throws Exception {
  Directory dir = newDirectory();
  RandomIndexWriter writer = new RandomIndexWriter(random(), dir);
  Document doc = new Document();
  doc.add(newStringField("value", "baz", Field.Store.NO));
  doc.add(newStringField("id", "2", Field.Store.YES));
  writer.addDocument(doc);
  doc = new Document();
  doc.add(newStringField("value", "foo", Field.Store.NO));
  doc.add(newStringField("value", "bar", Field.Store.NO));
  doc.add(newStringField("id", "1", Field.Store.YES));
  writer.addDocument(doc);
  doc = new Document();
  doc.add(newStringField("id", "3", Field.Store.YES));
  writer.addDocument(doc);
  IndexReader ir = writer.getReader();
  writer.close();
  
  IndexSearcher searcher = newSearcher(ir);
  SortField sortField = new SortedSetSortField("value", false);
  sortField.setMissingValue(SortField.STRING_FIRST);
  Sort sort = new Sort(sortField);

  TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
  assertEquals(3, td.totalHits);
  // 'bar' comes before 'baz'
  // null comes first
  assertEquals("3", searcher.doc(td.scoreDocs[0].doc).get("id"));
  assertEquals("1", searcher.doc(td.scoreDocs[1].doc).get("id"));
  assertEquals("2", searcher.doc(td.scoreDocs[2].doc).get("id"));
  
  ir.close();
  dir.close();
}