Solr 查询中fq参数的解析原理

原文地址：https://blog.csdn.net/rongdmmap/article/details/84168071 觉得分析的不错，记录下免得以后找不到。

首先看Lucene进行索引查询的一个核心方法：IndexSearcher.java
public void search(Weight weight, Filter filter, Collector collector)

其中 Weight是用来计算查询的权重并生成Scorer（这是一个集合迭代器），它一般由顶层的Query对象使用一个Seacher对象来创建（Query.createWeight(Searcher)），
Filter的作用是得到一个文档集，只有在这个集合内的文档才会返回，
Collector是原始查询结果的收集器。
Solr的查询就是基于Lucene的查询方式的，因此进行一次查询时就需要的对象与上面列出的相同。
核心的查询对象由Solr扩展为SolrIndexSearcher，但最终查询依然是调用IndexSearcher的search方法。

1、fq参数解析
QueryComponent.java的prepare方法中对参数进行解析

String[] fqs = req.getParams().getParams(CommonParams.FQ);
if (fqs!=null && fqs.length!=0) {
  List filters = rb.getFilters();
  if (filters==null) {
      filters = new ArrayList();
      rb.setFilters( filters );
  }
  for (String fq : fqs) {
      if (fq != null && fq.trim().length()!=0) {
          QParser fqp = QParser.getParser(fq, null, req);
          filters.add(fqp.getQuery());
      }
  }
}

2、获取解析对象

由上面的代码可以看到filters这个集合中存放着所有fq参数解析得到的Query对象，哪一种QParser由fq的具体内容决定
QParserPlugin.java中可以看到所有的

public static final Object[] standardPlugins = {
     LuceneQParserPlugin.NAME, LuceneQParserPlugin.class,
     OldLuceneQParserPlugin.NAME, OldLuceneQParserPlugin.class,
     FunctionQParserPlugin.NAME, FunctionQParserPlugin.class,
     PrefixQParserPlugin.NAME, PrefixQParserPlugin.class,
     BoostQParserPlugin.NAME, BoostQParserPlugin.class,
     DisMaxQParserPlugin.NAME, DisMaxQParserPlugin.class,
     ExtendedDismaxQParserPlugin.NAME, ExtendedDismaxQParserPlugin.class,
     FieldQParserPlugin.NAME, FieldQParserPlugin.class,
     RawQParserPlugin.NAME, RawQParserPlugin.class,
     NestedQParserPlugin.NAME, NestedQParserPlugin.class,
     FunctionRangeQParserPlugin.NAME, FunctionRangeQParserPlugin.class,
};

这里fq中使用frange本地参数的情况由FunctionRangeQParserPlugin来进行解析，在这个类中可以看到：

fq 的参数格式是这样的：{!frange l=1000 u=50000}

public QParser createParser(String qstr, SolrParams localParams, SolrParams params, SolrQueryRequest req) {
     return new QParser(qstr, localParams, params, req) {
         ValueSource vs;
         String funcStr;
         public Query parse() throws ParseException {
             funcStr = localParams.get(QueryParsing.V, null);
             Query funcQ = subQuery(funcStr, FunctionQParserPlugin.NAME).parse();
             if (funcQ instanceof FunctionQuery) {
                 vs = ((FunctionQuery)funcQ).getValueSource();
             } else {
                 vs = new QueryValueSource(funcQ, 0.0f);
             }
 
             String l = localParams.get("l"); // l 表示小值的一端，API是这样说明的：the lower bound, optional
             String u = localParams.get("u"); // u表示大的一端 API: the upper bound, optional)
             boolean includeLower = localParams.getBool("incl",true); //如果incl为TRUE,则包含值I
             boolean includeUpper = localParams.getBool("incu",true); //如果为TRUE，则包含值u
 
             // TODO: add a score=val option to allow score to be the value
             ValueSourceRangeFilter rf = new ValueSourceRangeFilter(vs, l, u, includeLower, includeUpper);
             SolrConstantScoreQuery csq = new SolrConstantScoreQuery(rf);
             return csq;
         }
     };
}

由此可以知道使用fq进行范围查询时所得到具体Query对象是SolrConstantScoreQuery的对象。

SolrConstantScoreQuery类相关问题,创建Scorer对象：
public Scorer scorer(IndexReader reader, boolean scoreDocsInOrder, boolean topScorer) throws IOException {
    return new ConstantScorer(similarity, reader, this);
}
其中 ConstantScorer是内部类
ConstantScorer的迭代基础：
在其构造函数中：

DocIdSet docIdSet = filter instanceof SolrFilter ? ((SolrFilter)filter).getDocIdSet(w.context, reader) : filter.getDocIdSet(reader);
if (docIdSet == null) {
    docIdSetIterator = DocIdSet.EMPTY_DOCIDSET.iterator();
} else {
    DocIdSetIterator iter = docIdSet.iterator();
    if (iter == null) {
        docIdSetIterator = DocIdSet.EMPTY_DOCIDSET.iterator();
    } else {
        docIdSetIterator = iter;
    }
}

由此可以ConstantScorer的迭代器起始就是这里的docIdSet的迭代器

docIdSet的迭代器有SolrFilter进行获取，之前已经看到这个SolrFilter起始就是ValueSourceRangeFilter
它的方法：

public DocIdSet getDocIdSet(final Map context, final IndexReader reader) throws IOException {
    return new DocIdSet() {
        public DocIdSetIterator iterator() throws IOException {
            return valueSource.getValues(context, reader).getRangeScorer(reader, lowerVal, upperVal, includeLower, includeUpper);
        }
    };
}

实际的Scorer由DocValues来创建：

public ValueSourceScorer getRangeScorer(IndexReader reader, String lowerVal, String upperVal, boolean includeLower, boolean includeUpper)

它实际返回的是重写了matchesValue方法的ValueSourceScorer的一子类：

return new ValueSourceScorer(reader, this) {
    @Override
    public boolean matchesValue(int doc) {
        float docVal = floatVal(doc);
        System.out.println("Document id '" + doc + "' score = " + docVal);
        return docVal >= l && docVal <= u;
    }
};

回到ValueSourceScorer，我们可以发现这个迭代器是如何工作的：

private int doc = -1;
protected final int maxDoc;
public int nextDoc() throws IOException {
    for (; ; ){
        doc++;
        if (doc >= maxDoc) return doc = NO_MORE_DOCS;
        if (matches(doc)) return doc;
    }
}

也就是这个迭代器默认是匹配所有文档的，只是由重写它的部分方法来实现文档过滤。

3、使用解析到的Query对象
具体的查询时在SolrIndexSearcher中进行的，由以下方法开始：
public QueryResult search(QueryResult qr, QueryCommand cmd)
其中QueryResult和QueryCommand都是SolrIndexSearcher的内部类，分别包装了查询结果和查询条件相关内容。
fq 解析得到的Query对象的List在QueryCommand中作为filterList成员变量来保存：
private List filterList;

具体到实际查询时（如果结果缓存中没有），Solr会先根据filter或filterList（filter和filterList不能同时都存在，否则报错）来先查询到一个文档集合作为过滤器：
DocSet filter = cmd.getFilter()!=null ? cmd.getFilter() : getDocSet(cmd.getFilterList());
其中getDocSet()方法负责根据fq的查询条件来查询到一个文档集，查询方式与普通的查询类似

该过滤器如果存在，那么就能到一个Lucene可用的Filter对象：
final Filter luceneFilter = filter==null ? null : filter.getTopFilter();

最后使用这个对象来进行查询：
super.search(query, luceneFilter, collector);
这个里面的query是查询参数中q以及其他相关参数（不包括fq）解析得到的Query对象

处理collector收集到的文档：
TopDocs topDocs = topCollector.topDocs(0, len);
maxScore = totalHits>0 ? topDocs.getMaxScore() : 0.0f;
nDocsReturned = topDocs.scoreDocs.length;

ids = new int[nDocsReturned];
scores = (cmd.getFlags()&GET_SCORES)!=0 ? new float[nDocsReturned] : null;
for (int i=0; i
ScoreDoc scoreDoc = topDocs.scoreDocs[i];
ids[i] = scoreDoc.doc;
if (scores != null) scores[i] = scoreDoc.score;
}

注：最后这点代码好像有些问题，我还没有去看源代码
————————————————
版权声明：本文为CSDN博主「rongdmmap」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/rongdmmap/article/details/84168071