这里把规范谓词表达式的部分就整理完了。阅读的顺序例如以下：
一、PostgreSQL代码分析，查询优化部分，canonicalize_qual
二、PostgreSQL代码分析，查询优化部分，pull_ands()和pull_ors()
三、 PostgreSQL代码分析。查询优化部分。process_duplicate_ors
/*
* canonicalize_qual
* Convert a qualification expression to the most useful form.
*
* The name of this routine is a holdover from a time when it would try to
* force the expression into canonical AND-of-ORs or OR-of-ANDs form.
* Eventually, we recognized that that had more theoretical purity than
* actual usefulness, and so now the transformation doesn't involve any
* notion of reaching a canonical form.
*
* NOTE: we assume the input has already been through eval_const_expressions
* and therefore possesses AND/OR flatness. Formerly this function included
* its own flattening logic, but that requires a useless extra pass over the
* tree.
*
* Returns the modified qualification.
*/
/*
* 对WHERE语句或ON语句中的条件进行规范化，从集合的角度对AND和OR两个操作做合并分解。 */
Expr *
canonicalize_qual(Expr *qual)
{
Expr *newqual; /* Quick exit for empty qual */
if (qual == NULL)
return NULL; /*
* Pull up redundant subclauses in OR-of-AND trees. We do this only
* within the top-level AND/OR structure; there's no point in looking
* deeper.
*/
/*
* 查找反复的OR操作。即化简条件语句。 * 假设WHERE条件为：
* (A=1 AND B=1) OR (A=1 AND C=1)
* 能够化简为：
* A=1 AND (B=1 OR C=1)
*
* 另外，这个函数中做了将树状的AND或OR语句平面化(flatten。或拉平)的工作，
* 这两个工作主要体如今pull_ands()和pull_ors()两个函数中。
*/
newqual = find_duplicate_ors(qual); return newqual;
} /*
* find_duplicate_ors
* Given a qualification tree with the NOTs pushed down, search for
* OR clauses to which the inverse OR distributive law might apply.
* Only the top-level AND/OR structure is searched.
*
* Returns the modified qualification. AND/OR flatness is preserved.
*/
static Expr *
find_duplicate_ors(Expr *qual)
{
/*
* “分支一：or_clause”
*
* 假设WHERE表达式中的主操作是OR，比如是例如以下形式：
* A=1 OR B=1 OR (C=1 AND D=1)
* 那么參数qual指针实际指向一个BoolExpr结构体。
typedef struct BoolExpr
{
Expr xpr; = 略
BoolExprType boolop; = OR_EXPR。即对以下的3个进行OR操作
List *args; = 3个，各自是A=1和 B=1和(C=1 AND D=1)
} BoolExpr;
*
* 这里的args是一个list。当中的3个元素的类型分别例如以下：
* 第一个是比較操作，类型是OpExpr
* 第二个是比較操作。类型是OpExpr
* 第三个是AND操作，是一个AND_EXPR类型的BoolExpr，递归调用时会处理
*
* 张大明确的blog：http://blog.****.net/shujiezhang
*/
if (or_clause((Node *) qual))
{
List *orlist = NIL;
ListCell *temp; /* Recurse */
/*
* 对BoolExpr中的三个条件分别进行递归处理。 * 在这里须要重点关注上例中的AND_EXPR类型的BoolExpr。由于在递归调用中，他将
* 触发下一个分支（分支二）。
*/
foreach(temp, ((BoolExpr *) qual)->args)
orlist = lappend(orlist, find_duplicate_ors(lfirst(temp))); /*
* Don't need pull_ors() since this routine will never introduce an OR
* where there wasn't one before.***这个原因没理解。***
*/
/* 详情见《PostgreSQL代码分析，查询优化部分，process_duplicate_ors》博文*/
return process_duplicate_ors(orlist);
}
/*
* “分支二：and_clause”
*
* 这里主要做了两个操作：
* 1） 假设子语句中有OR类型的子语句，则递归调用find_duplicate_ors。由于 子OR语句中
* 也许也能提取公共项。
* 2） 对AND操作进行拉平。 */
else if (and_clause((Node *) qual))
{
List *andlist = NIL;
ListCell *temp; /* Recurse */
/*
* 子语句中存在一系列OR的情况。
* 比如对于：
* A=1 AND ((B=1 AND C=1) OR (B=1 AND D=1))
* 这里的qual指针指向一个AND_EXPR类型的BoolExpr结构体，则
*
typedef struct BoolExpr
{
Expr xpr; = 略
BoolExprType boolop; = AND_EXPR，即对以下的2个进行AND操作
List *args; = 2个，各自是“A=1”和 “((B=1 AND C=1) OR (B=1 AND D=1))”
} BoolExpr;
*
* 对于当中的“((B=1 AND C=1) OR (B=1 AND D=1))”。在递归调用中，
* 会进入“分支一：or_clause”，进而转换为：
* B=1 AND (C=1 OR D=1)
*
* 张大明确的blog：http://blog.****.net/shujiezhang
*/
foreach(temp, ((BoolExpr *) qual)->args)
andlist = lappend(andlist, find_duplicate_ors(lfirst(temp))); /* Flatten any ANDs introduced just below here */
/*
* 拉平。
*
* 由于主语句是AND类型。子语句也是AND类型。所以能够直接把子语句拉到父节点。 *
*/
andlist = pull_ands(andlist);
/* The AND list can't get shorter, so result is always an AND */
return make_andclause(andlist);
}
else
return qual;
}
PostgreSQL代码分析，查询优化部分。