深入浅出jackrabbit之十三 查询之AST和QT

简介：在前面的文章中，ahuaxuan已经指出jackrabbit查询的主体流程，主体流程只能帮助大家稍微了解一下jackrabbit的query module，要深入理解还得深入探索主体流程中的每一步。在这篇文章中ahuaxuan将着重描述AST的生成和QT（querynode tree）的生成。

回顾上一篇文章，我们可以知道jackrabbit中的查询手段之一：xpath。下面我们还拿上一篇文章的xpath示例：

String queryPath2 =//hello/test3 [jcr:contains(@name, 'aa') and jcr:contains(@content, 'Maven') or @data1 = 'ahuaxuan'] order by jcr:score() descending, @name ascending  

这句话的意思是：得到在world节点中包含Maven这个字符串的节点，并且按照jcr:score()降序，name这个property升序。和sql语句非常类似。

我们知道jackrabbit是通过lucene来执行查询任务，那么lucene是怎么知道这个语句中包含什么信息的呢。

要得到这个答案，我们不得不捡起我们的基础学科，编译原理。编译的目的是把一种语言翻译成另外一种语言，比如java的源代码需要编译成字节码，这个就是通过编译技术实现，很遗憾，字节码并不是机器语言，不能直接执行，所以字节码会被再次编译，生成机器语言。运行过程中，这些编译之后的代码也有可能再次被重新优化编译。所以天天使用java的同志们，还是要了解一下编译的作用。

有点偏题了，那么现在我们的目的是什么，就是把这个xpath语言翻译成另外一种语言。翻译成java中的数据结构，然后用户可以通过开发处理这些数据结构的代码来解析和使用这些数据结构，这里讲到的数据结构就是QT（其实QT也是一个语法树，只是这颗语法树能够让程序直接识别）。

在jackrabbit中，使用了javacc来生成AST，关于javacc的使用请google之，它的词法文件在源码中可以找到，XPath.jj。

AST在生成之后，是怎么转换成QT的呢？要回答这个问题，我们必须要理解一个设计模式，vistor模式

因为在AST转换成QT，以及从QT转成lucene的query对象时都使用了vistor，在asm中也是使用vistor，emma中也是使用vistor，看来它很火，口说无凭，有图为证：


从上图中可以看到在处理SimpleNode的时候使用了XPathVisitor，而在处理QueryNode的时候使用QueryNodeVistor.

一个简单的vistor模式如下： 

1.package org.apache.jackrabbit.core.query.xpath;  
2.  
3.public interface XPathVisitor  
4.{  
5.  public Object visit(SimpleNode node, Object data);  
6.}  
7.  
8.public class SimpleNode implements Node {  
9.    protected Node parent;  
10.    protected Node[] children;  
11.    protected int id;  
12.    protected XPath parser;  
13.  
14.    /** 
15.     * Accept the visitor. * 
16.     */  
17.    public Object jjtAccept(XPathVisitor visitor, Object data) {  
18.        return visitor.visit(this, data);  
19.    }  
20.  
21.    /** 
22.     * Accept the visitor. * 
23.     */  
24.    public Object childrenAccept(XPathVisitor visitor, Object data) {  
25.        if (children != null) {  
26.            for (int i = 0; i < children.length; ++i) {  
27.                data = children[i].jjtAccept(visitor, data);  
28.            }  
29.        }  
30.        return data;  
31.    }  
32.}  

从这两个简单的类的关系中，我们可以看到如下事实：SimpleNode类接受一个Vistor，然后在vistor的vist方法中，会处理该SimpleNode，换句话说，一个domain对象会拿另外一个process对象来处理自己。

另外一个值得注意的是SimpleNode其实就是AST上的节点。下面一个主要工作就是处理AST上的节点，并且生成QueryNode Tree。

在visitor模式中，处理数据结构的主要逻辑在是visit方法，那么下面我们就来看看XPathVisitor实现类XPathQueryBuilder的visit方法，该方法中集中了AST转成QT的关键逻辑。代码如下： 

1.public Object visit(SimpleNode node, Object data) {  
2.        QueryNode queryNode = (QueryNode) data;  
3.        switch (node.getId()) {  
4.            case JJTXPATH2:  
5.                queryNode = createPathQueryNode(node);  
6.                break;  
7.            case JJTROOT:  
8.            case JJTROOTDESCENDANTS:  
9.                if (queryNode instanceof PathQueryNode) {  
10.                    ((PathQueryNode) queryNode).setAbsolute(true);  
11.                } else {  
12.                    exceptions.add(new InvalidQueryException(  
13.                            "Unsupported root level query node: " + queryNode));  
14.                }  
15.                break;  
16.            case JJTSTEPEXPR:  
17.                ………………………..  
18.        return queryNode;  
19.    }  

一段很长的代码，这段代码的主要作用是将AST，也就是SimpleNode组成的tree转换成QueryNodeTree， 原来节点的类型在simplenode中是以id来表示，而在转换之后的QueryNodeTree中，则是以QueryNode的类型来决定。

综上所述，在这个部分中，通过vistor的模式，不停的自顶向下遍历AST上的节点，同时根据节点的类型来生成QT上的节点。

这样AST遍历完成之后，我们也得到了我们需要的QT，接下来就是这么使用QT的问题了。
我们来仔细审视一下QT的结构，如下图所示（该QT对应的xpath语句是：//hello/test3 

1.[jcr:contains(@name, 'aa') and jcr:contains(@content, 'Maven') or @data1 = 'ahuaxuan'] order by jcr:score() descending, @name ascending  
2.）:  

从上图看出，一条xpath语句最终被解析成一颗树，而这颗树代表着查询的条件，排序信息等等。
最重要的一个节点QueryRootNode，它连同它的children代表着一条xpath语句，这个时候，xpath语句的语义已经被清晰的划分开。接下来，就是QueryNode的Visitor上场了。我们来看看它的Visitor： 

1.public interface QueryNodeVisitor {  
2.  
3.    Object visit(QueryRootNode node, Object data);  
4.  
5.    Object visit(OrQueryNode node, Object data);  
6.  
7.    Object visit(AndQueryNode node, Object data);  
8.  
9.    Object visit(NotQueryNode node, Object data);  
10.  
11.    Object visit(ExactQueryNode node, Object data);  
12.  
13.    Object visit(NodeTypeQueryNode node, Object data);  
14.  
15.    Object visit(TextsearchQueryNode node, Object data);  
16.  
17.    Object visit(PathQueryNode node, Object data);  
18.  
19.    Object visit(LocationStepQueryNode node, Object data);  
20.  
21.    Object visit(RelationQueryNode node, Object data);  
22.  
23.    Object visit(OrderQueryNode node, Object data);  
24.  
25.    Object visit(DerefQueryNode node, Object data);  
26.  
27.    Object visit(PropertyFunctionQueryNode node, Object data);  
28.}  

它的实现类中需要定义每一种QueryNode的处理逻辑，显然和SimpleNode的XPathVisitor有一点不一样，因为在XPathVisitor中，是通过switch来决定如何处理node的，而这里变成了多个方法来处理，看上去更加直观，只是如果再加一个QueryNode的子类，那么接口就需要改动（从这一点来看vistor比较适合数据结构不易变更的场景，比如asm中，字节码结构一般是不会变更的，所以用visitor模式是比较适合的），不过总的来说，SimpleNode和XpathVisitor的关系就如同QueryNode和QueryNodeVisitor一样，连续两个关键步骤都使用了visitor模式。

看过接口之后，就是看它的主实现类，LuceneQueryBuilder，这个类相当重要，所有的query对象就是在这个类中构造出来的，很显然，构造query对象所需要的条件就藏在QT中。我们只要稍稍的查看一个方法，就可以得到证据： 

1.public Object visit(QueryRootNode node, Object data) {  
2.        BooleanQuery root = new BooleanQuery();  
3.  
4.        Query wrapped = root;  
5.        if (node.getLocationNode() != null) {  
6.            wrapped = (Query) node.getLocationNode().accept(this, root);  
7.        }  
8.  
9.        return wrapped;  
10.    }  

显然，从这段代码里，开始了便利QT的旅程，因为QueryRootNode是QT的root，所以这里也是自顶向下遍历，比如，在创建了root之后，接着去处理QT上的LocationNode（也就是PathQueryNode节点），于是方法就跳到了：

1.public Object visit(PathQueryNode node, Object data) {  
2.        Query context = null;  
3.        LocationStepQueryNode[] steps = node.getPathSteps();  
4.        if (steps.length > 0) {  
5.            if (node.isAbsolute() && !steps[0].getIncludeDescendants()) {  
6.                // eat up first step  
7.                Name nameTest = steps[0].getNameTest();  
8.                if (nameTest == null) {  
9.                    // this is equivalent to the root node  
10.                    context = new TermQuery(new Term(FieldNames.PARENT, ""));  
11.                } else if (nameTest.getLocalName().length() == 0) {  
12.                    // root node  
13.                    context = new TermQuery(new Term(FieldNames.PARENT, ""));  
14.                } else {  
15.                    // then this is a node != the root node  
16.                    // will never match anything!  
17.                    String name = "";  
18.                    try {  
19.                        name = resolver.getJCRName(nameTest);  
20.                    } catch (NamespaceException e) {  
21.                        exceptions.add(e);  
22.                    }  
23.                    BooleanQuery and = new BooleanQuery();  
24.                    and.add(new TermQuery(new Term(FieldNames.PARENT, "")), Occur.MUST);  
25.                    and.add(new TermQuery(new Term(FieldNames.LABEL, name)), Occur.MUST);  
26.                    context = and;  
27.                }  
28.                LocationStepQueryNode[] tmp = new LocationStepQueryNode[steps.length - 1];  
29.                System.arraycopy(steps, 1, tmp, 0, steps.length - 1);  
30.                steps = tmp;  
31.            } else {  
32.                // path is 1) relative or 2) descendant-or-self  
33.                // use root node as context  
34.                context = new TermQuery(new Term(FieldNames.PARENT, ""));  
35.            }  
36.        } else {  
37.            exceptions.add(new InvalidQueryException("Number of location steps must be > 0"));  
38.        }  
39.        // loop over steps  
40.        for (int i = 0; i < steps.length; i++) {  
41.            context = (Query) steps[i].accept(this, context);  
42.        }  
43.        if (data instanceof BooleanQuery) {  
44.            BooleanQuery constraint = (BooleanQuery) data;  
45.            if (constraint.getClauses().length > 0) {  
46.                constraint.add(context, Occur.MUST);  
47.                context = constraint;  
48.            }  
49.        }  
50.        return context;  
51.    }  

如此下去，整个QT会被遍历，并生成lucene的query对象，但是如果有同学也去读源码，那么可能会发现在处理Order这个语义时，visitor直接跳过了： 

1.public Object visit(OrderQueryNode node, Object data) {  
2.        return data;  
3.    } 

没错，它是故意的，因为order的语义在jackrabbit里被独立拿来出来，生成需要排序的field。

生成lucene的query对象之后，就可以名正言顺的调用下面这段代码了：
searcher.search(query, new Sort(sortFields))

其中的sortFields是在queryimpl的execute方法里独立拿出来，并生成了sortfields：

1.OrderQueryNode orderNode = root.getOrderNode();  
2.  
3.        OrderQueryNode.OrderSpec[] orderSpecs;  
4.        if (orderNode != null) {  
5.            orderSpecs = orderNode.getOrderSpecs();  
6.        } else {  
7.            orderSpecs = new OrderQueryNode.OrderSpec[0];  
8.        }  
9.        Name[] orderProperties = new Name[orderSpecs.length];  
10.        boolean[] ascSpecs = new boolean[orderSpecs.length];  
11.        for (int i = 0; i < orderSpecs.length; i++) {  
12.            orderProperties[i] = orderSpecs[i].getProperty();  
13.            ascSpecs[i] = orderSpecs[i].isAscending();  
14.        }  

那么说到这里，jackrabbit在查询时候的一些关键流程就告一段落了，唯一不足的是本文只是描述了一条xpath语句从字符串到QT，再到lucene的query对象这样一个概要流程，在下一篇文章中，我们将会来着重看一下lucene是怎么使用这颗QT的。

to be continue