下面列出了org.apache.lucene.search.SortedSetSortField#org.apache.lucene.search.SortedNumericSortField 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
private void resetField(JComboBox<String> fieldCombo, JComboBox<String> typeCombo, JComboBox<String> orderCombo) {
typeCombo.removeAllItems();
if (StringUtils.isNullOrEmpty((String) fieldCombo.getSelectedItem())) {
typeCombo.addItem("");
typeCombo.setEnabled(false);
orderCombo.setEnabled(false);
} else {
List<SortField> sortFields = searchModel.guessSortTypes((String) fieldCombo.getSelectedItem());
sortFields.stream()
.map(sf -> {
if (sf instanceof SortedNumericSortField) {
return ((SortedNumericSortField) sf).getNumericType().name();
} else {
return sf.getType().name();
}
}).forEach(typeCombo::addItem);
typeCombo.setEnabled(true);
orderCombo.setEnabled(true);
}
}
private LuceneOrderedDocCollector createOrderedCollector(IndexSearcher searcher, int shardId) {
CollectorContext collectorContext = new CollectorContext();
List<LuceneCollectorExpression<?>> expressions = Collections.singletonList(
new OrderByCollectorExpression(reference, orderBy, o -> o));
return new LuceneOrderedDocCollector(
new ShardId("dummy", UUIDs.randomBase64UUID(), shardId),
searcher,
new MatchAllDocsQuery(),
null,
false,
5, // batchSize < 10 to have at least one searchMore call.
RamAccounting.NO_ACCOUNTING,
collectorContext,
f -> null,
new Sort(new SortedNumericSortField(columnName, SortField.Type.LONG, reverseFlags[0])),
expressions,
expressions
);
}
@Test
public void testGetSortType() {
SearchImpl search = new SearchImpl(reader);
assertFalse(search.getSortType("f1", "STRING", false).isPresent());
assertEquals(new SortField("f2", SortField.Type.STRING, false),
search.getSortType("f2", "STRING", false).get());
assertFalse(search.getSortType("f2", "INT", false).isPresent());
assertEquals(new SortedSetSortField("f3", false),
search.getSortType("f3", "CUSTOM", false).get());
assertEquals(new SortField("f4", SortField.Type.LONG, false),
search.getSortType("f4", "LONG", false).get());
assertFalse(search.getSortType("f4", "STRING", false).isPresent());
assertEquals(new SortField("f5", SortField.Type.FLOAT, false),
search.getSortType("f5", "FLOAT", false).get());
assertFalse(search.getSortType("f5", "STRING", false).isPresent());
assertEquals(new SortField("f6", SortField.Type.DOUBLE, false),
search.getSortType("f6", "DOUBLE", false).get());
assertFalse(search.getSortType("f6", "STRING", false).isPresent());
assertEquals(new SortedNumericSortField("f7", SortField.Type.LONG, false),
search.getSortType("f7", "LONG", false).get());
assertFalse(search.getSortType("f7", "STRING", false).isPresent());
}
public void testWrongSortFieldType() throws Exception {
Directory dir = newDirectory();
List<Field> dvs = new ArrayList<>();
dvs.add(new SortedDocValuesField("field", new BytesRef("")));
dvs.add(new SortedSetDocValuesField("field", new BytesRef("")));
dvs.add(new NumericDocValuesField("field", 42));
dvs.add(new SortedNumericDocValuesField("field", 42));
List<SortField> sortFields = new ArrayList<>();
sortFields.add(new SortField("field", SortField.Type.STRING));
sortFields.add(new SortedSetSortField("field", false));
sortFields.add(new SortField("field", SortField.Type.INT));
sortFields.add(new SortedNumericSortField("field", SortField.Type.INT));
for (int i = 0; i < sortFields.size(); i++) {
for (int j = 0; j < dvs.size(); j++) {
if (i == j) {
continue;
}
Sort indexSort = new Sort(sortFields.get(i));
IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
iwc.setIndexSort(indexSort);
IndexWriter w = new IndexWriter(dir, iwc);
Document doc = new Document();
doc.add(dvs.get(j));
IllegalArgumentException exc = expectThrows(IllegalArgumentException.class, () -> w.addDocument(doc));
assertThat(exc.getMessage(), containsString("expected field [field] to be "));
doc.clear();
doc.add(dvs.get(i));
w.addDocument(doc);
doc.add(dvs.get(j));
exc = expectThrows(IllegalArgumentException.class, () -> w.addDocument(doc));
assertThat(exc.getMessage(), containsString("cannot change DocValues type"));
w.rollback();
IOUtils.close(w);
}
}
IOUtils.close(dir);
}
/**
* Same as {@link #getSortField} but using {@link SortedNumericSortField}.
*/
protected static SortField getSortedNumericSortField(SchemaField field, SortField.Type sortType,
SortedNumericSelector.Type selector,
boolean reverse, Object missingLow, Object missingHigh) {
field.checkSortability();
SortField sf = new SortedNumericSortField(field.getName(), sortType, reverse, selector);
applySetMissingValue(field, sf, missingLow, missingHigh);
return sf;
}
@Override
public List<SortField> guessSortTypes(String name) {
FieldInfo finfo = IndexUtils.getFieldInfo(reader, name);
if (finfo == null) {
throw new LukeException("No such field: " + name, new IllegalArgumentException());
}
DocValuesType dvType = finfo.getDocValuesType();
switch (dvType) {
case NONE:
return Collections.emptyList();
case NUMERIC:
return Arrays.stream(new SortField[]{
new SortField(name, SortField.Type.INT),
new SortField(name, SortField.Type.LONG),
new SortField(name, SortField.Type.FLOAT),
new SortField(name, SortField.Type.DOUBLE)
}).collect(Collectors.toList());
case SORTED_NUMERIC:
return Arrays.stream(new SortField[]{
new SortedNumericSortField(name, SortField.Type.INT),
new SortedNumericSortField(name, SortField.Type.LONG),
new SortedNumericSortField(name, SortField.Type.FLOAT),
new SortedNumericSortField(name, SortField.Type.DOUBLE)
}).collect(Collectors.toList());
case SORTED:
return Arrays.stream(new SortField[] {
new SortField(name, SortField.Type.STRING),
new SortField(name, SortField.Type.STRING_VAL)
}).collect(Collectors.toList());
case SORTED_SET:
return Collections.singletonList(new SortedSetSortField(name, false));
default:
return Collections.singletonList(new SortField(name, SortField.Type.DOC));
}
}
@Test
public void testGuessSortTypes() {
SearchImpl search = new SearchImpl(reader);
assertTrue(search.guessSortTypes("f1").isEmpty());
assertArrayEquals(
new SortField[]{
new SortField("f2", SortField.Type.STRING),
new SortField("f2", SortField.Type.STRING_VAL)},
search.guessSortTypes("f2").toArray());
assertArrayEquals(
new SortField[]{new SortedSetSortField("f3", false)},
search.guessSortTypes("f3").toArray());
assertArrayEquals(
new SortField[]{
new SortField("f4", SortField.Type.INT),
new SortField("f4", SortField.Type.LONG),
new SortField("f4", SortField.Type.FLOAT),
new SortField("f4", SortField.Type.DOUBLE)},
search.guessSortTypes("f4").toArray());
assertArrayEquals(
new SortField[]{
new SortField("f5", SortField.Type.INT),
new SortField("f5", SortField.Type.LONG),
new SortField("f5", SortField.Type.FLOAT),
new SortField("f5", SortField.Type.DOUBLE)},
search.guessSortTypes("f5").toArray());
assertArrayEquals(
new SortField[]{
new SortField("f6", SortField.Type.INT),
new SortField("f6", SortField.Type.LONG),
new SortField("f6", SortField.Type.FLOAT),
new SortField("f6", SortField.Type.DOUBLE)},
search.guessSortTypes("f6").toArray());
assertArrayEquals(
new SortField[]{
new SortedNumericSortField("f7", SortField.Type.INT),
new SortedNumericSortField("f7", SortField.Type.LONG),
new SortedNumericSortField("f7", SortField.Type.FLOAT),
new SortedNumericSortField("f7", SortField.Type.DOUBLE)},
search.guessSortTypes("f7").toArray());
}
@Override
public SortField getSortField(boolean reverse) {
return new SortedNumericSortField(field, SortField.Type.LONG, reverse, selector);
}
@Override
public SortField getSortField(boolean reverse) {
return new SortedNumericSortField(field, SortField.Type.INT, reverse, selector);
}
@Override
public SortField getSortField(boolean reverse) {
return new SortedNumericSortField(field, SortField.Type.DOUBLE, reverse, selector);
}
@Override
public SortField getSortField(boolean reverse) {
return new SortedNumericSortField(field, SortField.Type.FLOAT, reverse, selector);
}
public void testMultiValuedRandom1() throws IOException {
boolean withDeletes = random().nextBoolean();
Directory dir = newDirectory();
IndexWriterConfig iwc = new IndexWriterConfig(new MockAnalyzer(random()));
Sort indexSort = new Sort(new SortedNumericSortField("foo", SortField.Type.LONG));
iwc.setIndexSort(indexSort);
IndexWriter w = new IndexWriter(dir, iwc);
final int numDocs = atLeast(200);
final FixedBitSet deleted = new FixedBitSet(numDocs);
for (int i = 0; i < numDocs; ++i) {
Document doc = new Document();
int num = random().nextInt(10);
for (int j = 0; j < num; j++) {
doc.add(new SortedNumericDocValuesField("foo", random().nextInt(2000)));
}
doc.add(new StringField("id", Integer.toString(i), Store.YES));
doc.add(new NumericDocValuesField("id", i));
w.addDocument(doc);
if (random().nextInt(5) == 0) {
w.getReader().close();
} else if (random().nextInt(30) == 0) {
w.forceMerge(2);
} else if (random().nextInt(4) == 0) {
final int id = TestUtil.nextInt(random(), 0, i);
deleted.set(id);
w.deleteDocuments(new Term("id", Integer.toString(id)));
}
}
DirectoryReader reader = w.getReader();
// Now check that the index is consistent
IndexSearcher searcher = newSearcher(reader);
for (int i = 0; i < numDocs; ++i) {
TermQuery termQuery = new TermQuery(new Term("id", Integer.toString(i)));
final TopDocs topDocs = searcher.search(termQuery, 1);
if (deleted.get(i)) {
assertEquals(0, topDocs.totalHits.value);
} else {
assertEquals(1, topDocs.totalHits.value);
NumericDocValues values = MultiDocValues.getNumericValues(reader, "id");
assertEquals(topDocs.scoreDocs[0].doc, values.advance(topDocs.scoreDocs[0].doc));
assertEquals(i, values.longValue());
Document document = reader.document(topDocs.scoreDocs[0].doc);
assertEquals(Integer.toString(i), document.get("id"));
}
}
reader.close();
w.close();
dir.close();
}