155 lines
5.1 KiB
Java
155 lines
5.1 KiB
Java
package it.cavallium.dbengine.lucene.searcher;
|
|
|
|
import static java.util.Objects.requireNonNull;
|
|
|
|
import it.cavallium.dbengine.client.query.current.data.TotalHitsCount;
|
|
import it.cavallium.dbengine.database.LLKeyScore;
|
|
import it.cavallium.dbengine.database.LLUtils;
|
|
import it.cavallium.dbengine.database.disk.LLIndexSearchers;
|
|
import it.cavallium.dbengine.lucene.LuceneCloseable;
|
|
import it.cavallium.dbengine.lucene.LuceneUtils;
|
|
import it.cavallium.dbengine.utils.DBException;
|
|
import java.io.IOException;
|
|
import java.util.Collection;
|
|
import java.util.List;
|
|
import java.util.stream.Stream;
|
|
import org.apache.logging.log4j.LogManager;
|
|
import org.apache.logging.log4j.Logger;
|
|
import org.apache.lucene.search.CollectorManager;
|
|
import org.apache.lucene.search.IndexSearcher;
|
|
import org.apache.lucene.search.ScoreDoc;
|
|
import org.apache.lucene.search.TopDocs;
|
|
import org.apache.lucene.search.TopDocsCollector;
|
|
import org.apache.lucene.search.TopFieldCollector;
|
|
import org.apache.lucene.search.TopFieldDocs;
|
|
import org.apache.lucene.search.TopScoreDocCollector;
|
|
import org.jetbrains.annotations.Nullable;
|
|
|
|
public class StandardSearcher implements MultiSearcher {
|
|
|
|
protected static final Logger LOG = LogManager.getLogger(StandardSearcher.class);
|
|
|
|
public StandardSearcher() {
|
|
}
|
|
|
|
@Override
|
|
public LuceneSearchResult collectMulti(LLIndexSearchers indexSearchers,
|
|
LocalQueryParams queryParams,
|
|
@Nullable String keyFieldName,
|
|
GlobalQueryRewrite transformer) {
|
|
if (transformer != GlobalQueryRewrite.NO_REWRITE) {
|
|
return LuceneUtils.rewriteMulti(this, indexSearchers, queryParams, keyFieldName, transformer);
|
|
}
|
|
// Search results
|
|
var fullDocs = this.search(indexSearchers.shards(), queryParams);
|
|
// Compute the results
|
|
return this.computeResults(fullDocs, indexSearchers, keyFieldName, queryParams);
|
|
}
|
|
|
|
/**
|
|
* Search effectively the raw results
|
|
*/
|
|
@SuppressWarnings({"rawtypes"})
|
|
private TopDocs search(Collection<IndexSearcher> indexSearchers, LocalQueryParams queryParams) {
|
|
var totalHitsThreshold = queryParams.getTotalHitsThresholdInt();
|
|
CollectorManager<? extends TopDocsCollector<?>, ? extends TopDocs> sharedManager;
|
|
if (queryParams.isSorted() && !queryParams.isSortedByScore()) {
|
|
sharedManager = TopFieldCollector.createSharedManager(queryParams.sort(),
|
|
queryParams.limitInt(), null, totalHitsThreshold);
|
|
} else {
|
|
sharedManager = TopScoreDocCollector.createSharedManager(queryParams.limitInt(), null, totalHitsThreshold);
|
|
};
|
|
var collectors = indexSearchers.stream().map(shard -> {
|
|
try {
|
|
TopDocsCollector<?> collector;
|
|
collector = sharedManager.newCollector();
|
|
assert queryParams.computePreciseHitsCount() == null || (queryParams.computePreciseHitsCount() == collector
|
|
.scoreMode()
|
|
.isExhaustive());
|
|
|
|
shard.search(queryParams.query(), LuceneUtils.withTimeout(collector, queryParams.timeout()));
|
|
return collector;
|
|
} catch (IOException e) {
|
|
throw new DBException(e);
|
|
}
|
|
}).toList();
|
|
|
|
try {
|
|
if (collectors.size() <= 1) {
|
|
//noinspection unchecked
|
|
return sharedManager.reduce((List) collectors);
|
|
} else if (queryParams.isSorted() && !queryParams.isSortedByScore()) {
|
|
final TopFieldDocs[] topDocs = new TopFieldDocs[collectors.size()];
|
|
int i = 0;
|
|
for (var collector : collectors) {
|
|
var topFieldDocs = ((TopFieldCollector) collector).topDocs();
|
|
for (ScoreDoc scoreDoc : topFieldDocs.scoreDocs) {
|
|
scoreDoc.shardIndex = i;
|
|
}
|
|
topDocs[i++] = topFieldDocs;
|
|
}
|
|
return TopDocs.merge(requireNonNull(queryParams.sort()), 0, queryParams.limitInt(), topDocs);
|
|
} else {
|
|
final TopDocs[] topDocs = new TopDocs[collectors.size()];
|
|
int i = 0;
|
|
for (var collector : collectors) {
|
|
var topScoreDocs = collector.topDocs();
|
|
for (ScoreDoc scoreDoc : topScoreDocs.scoreDocs) {
|
|
scoreDoc.shardIndex = i;
|
|
}
|
|
topDocs[i++] = topScoreDocs;
|
|
}
|
|
return TopDocs.merge(0, queryParams.limitInt(), topDocs);
|
|
}
|
|
} catch (IOException ex) {
|
|
throw new DBException(ex);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Compute the results, extracting useful data
|
|
*/
|
|
private LuceneSearchResult computeResults(TopDocs data,
|
|
LLIndexSearchers indexSearchers,
|
|
String keyFieldName,
|
|
LocalQueryParams queryParams) {
|
|
var totalHitsCount = LuceneUtils.convertTotalHitsCount(data.totalHits);
|
|
|
|
Stream<LLKeyScore> hitsStream = LuceneUtils
|
|
.convertHits(Stream.of(data.scoreDocs),
|
|
indexSearchers.shards(), keyFieldName
|
|
)
|
|
.skip(queryParams.offsetLong())
|
|
.limit(queryParams.limitLong());
|
|
|
|
return new MyLuceneSearchResult(totalHitsCount, hitsStream, indexSearchers);
|
|
}
|
|
|
|
@Override
|
|
public String getName() {
|
|
return "standard";
|
|
}
|
|
|
|
private static class MyLuceneSearchResult extends LuceneSearchResult implements LuceneCloseable {
|
|
|
|
private final LLIndexSearchers indexSearchers;
|
|
|
|
public MyLuceneSearchResult(TotalHitsCount totalHitsCount,
|
|
Stream<LLKeyScore> hitsStream,
|
|
LLIndexSearchers indexSearchers) {
|
|
super(totalHitsCount, hitsStream);
|
|
this.indexSearchers = indexSearchers;
|
|
}
|
|
|
|
@Override
|
|
protected void onClose() {
|
|
try {
|
|
indexSearchers.close();
|
|
} catch (Throwable e) {
|
|
LOG.error("Can't close index searchers", e);
|
|
}
|
|
super.onClose();
|
|
}
|
|
}
|
|
}
|