Mongodb的逻辑优化过程

逻辑优化过程在关系型数据库里面， 是一个非常复杂的过程， 幸运的是， 在Mongodb里面， 到目前为止， 相对来说， 其实现还是比较简单的。该过程主要通过 CanonicalQuery 类来实现。

该过程主要包含三个方面的优化：

1、Normoralize tree；

2、sort tree；

3、 validate tree；

我们分别来看看这3个方面的优化的实现。

1. Normoralize tree

该过程主要是针对 AND， OR的子对象的类型也是AND， OR的情况， 把他们从子节点提升到父节点。

已如下的AND的为例子：

db.inventory.find( {
$and : [
{ $and : [ { price : 0.99 }, { count : 99 } ] },
{ $and : [ { sale : true }, { qty : 20} ] }
]
} )

此时的MatchExpression， 应该为如下的结构：



经过Normalize以后， 应该把AND of AND类型的节点提升到父节点的兄弟节点， 如下：



从上面两幅图的对比， 比较直观的看到， 节点数变少， 层数也变少了。 我们看一下代码：

MatchExpression* CanonicalQuery::normalizeTree(MatchExpression* root) {
// root->isLogical() is true now.  We care about AND, OR, and NOT. NOR currently scares us.
if (MatchExpression::AND == root->matchType() || MatchExpression::OR == root->matchType()) {
// We could have AND of AND of AND.  Make sure we clean up our children before merging
// them.
// UNITTEST 11738048
for (size_t i = 0; i < root->getChildVector()->size(); ++i) {
(*root->getChildVector())[i] = normalizeTree(root->getChild(i));
}

// If any of our children are of the same logical operator that we are, we remove the
// child's children and append them to ourselves after we examine all children.
std::vector<MatchExpression*> absorbedChildren;

for (size_t i = 0; i < root->numChildren();) {
MatchExpression* child = root->getChild(i);
if (child->matchType() == root->matchType()) {
// AND of an AND or OR of an OR.  Absorb child's children into ourself.
for (size_t j = 0; j < child->numChildren(); ++j) {
absorbedChildren.push_back(child->getChild(j));
}
// TODO(opt): this is possibly n^2-ish
root->getChildVector()->erase(root->getChildVector()->begin() + i);
child->getChildVector()->clear();
// Note that this only works because we cleared the child's children
delete child;
// Don't increment 'i' as the current child 'i' used to be child 'i+1'
} else {
++i;
}
}

root->getChildVector()->insert(
root->getChildVector()->end(), absorbedChildren.begin(), absorbedChildren.end());

// AND of 1 thing is the thing, OR of 1 thing is the thing.
if (1 == root->numChildren()) {
MatchExpression* ret = root->getChild(0);
root->getChildVector()->clear();
delete root;
return ret;
}
} else if (MatchExpression::NOT == root->matchType()) {
// Normalize the rest of the tree hanging off this NOT node.
NotMatchExpression* nme = static_cast<NotMatchExpression*>(root);
MatchExpression* child = nme->releaseChild();
// normalizeTree(...) takes ownership of 'child', and then
// transfers ownership of its return value to 'nme'.
nme->resetChild(normalizeTree(child));
} else if (MatchExpression::ELEM_MATCH_VALUE == root->matchType()) {
// Just normalize our children.
for (size_t i = 0; i < root->getChildVector()->size(); ++i) {
(*root->getChildVector())[i] = normalizeTree(root->getChild(i));
}
}

return root;
}

这里， 采用了递归的调用方式， 针对and,or, not,elemMatch 4中操作符进行， not和elemMatch 是针对其subnode 调用normalizeTree， and和or 递归的吧子节点提升为父节点的兄弟节点。

2. sort tree

sort tree 主要是对MatchExpression的各个子树进行排序， 排序之后的好处就是对于index查询， 如果某个字段的index被分成了几段， 我们的查询用到其中的2段， 就可以做到对于索引的查找只需要一次就能完成。其具体的排序的顺序：

1) operator type (MatchExpression::MatchType)

2) path name (MatchExpression::path())

3) sort order of children

4) number of children (MatchExpression::numChildren())

代码的实现就比较简单， 按照上面的4中比较方式以及优先级。

3. validate tree

主要是判断由MatchExpression产生的LiteParsedQuery 对象的设定是否有不正确的地方。