3.1 概览

• 第一部分：3.1节 这一节会简单介绍PostgreSQL中查询处理的流程。
• 第二部分：3.2~3.4节 这一部分会描述获取单表查询上最优执行计划的步骤。3.2节讨论代价估计的过程，3.3节描述创建计划树的过程，3.4节将简要介绍执行器的工作过程。
• 第三部分：3.5~3.6节 这一部分会描述获取多表查询上最优执行计划的步骤。3.5节介绍了三种连接算法：嵌套循环连接（Nested Loop Join） ，归并连接（Merge Join） ，散列连接（Hash Join） 。3.6节将介绍为多表查询创建计划树的过程。

1. 解析器（Parser） 解析器根据SQL语句生成一颗语法解析树（parse tree） 。
2. 分析器（Analyzer） 分析器对语法解析树进行语义分析，生成一颗查询树（query tree） 。
3. 重写器（Rewriter） 重写器按照规则系统中存在的规则，对查询树进行改写。
4. 计划器（Planner） 计划器基于查询树，生成一颗执行效率最高的计划树（plan tree） 。
5. 执行器（Executor） 执行器按照计划树中的顺序访问表和索引，执行相应查询。

testdb=# SELECT id, data FROM tbl_a WHERE id < 300 ORDER BY data;

typedef struct SelectStmt
{
        NodeTag         type;
        /* 这些字段只会在SelectStmts“叶节点”中使用 */
        List       *distinctClause;     /* NULL, DISTINCT ON表达式列表, 或
                                       对所有的(SELECT DISTINCT)为lcons(NIL,NIL) */
        IntoClause *intoClause;         /* SELECT INTO 的目标 */
        List       *targetList;         /* 结果目标列表 (ResTarget) */
        List       *fromClause;         /* FROM 子句 */
        Node       *whereClause;        /* WHERE 限定条件 */
        List       *groupClause;        /* GROUP BY 子句 */
        Node       *havingClause;       /* HAVING 条件表达式 */
        List       *windowClause;       /* WINDOW window_name AS (...), ... */
        /*  在一个表示值列表的叶节点中，上面的字段全都为空，而这个字段会被设置。
         * 注意这个子列表中的元素仅仅是表达式，没有ResTarget的修饰，还需要注意列表元素可能为
         * DEFAULT (表示一个 SetToDefault 节点)，而无论值列表的上下文。 
         * 由分析阶段决定否合法并拒绝。      */
        List       *valuesLists;        /* 未转换的表达式列表 */
        /* 这些字段会同时在SelectStmts叶节点与SelectStmts上层节点中使用 */
        List       *sortClause;         /* 排序子句 (排序依据的列表) */
        Node       *limitOffset;        /* 需要跳过的元组数目 */
        Node       *limitCount;         /* 需要返回的元组数目 */
        List       *lockingClause;      /* FOR UPDATE (锁子句的列表) */
        WithClause *withClause;         /* WITH 子句 */
        /* 这些字段只会在上层的 SelectStmts 中出现 */
        SetOperation op;                /* set 操作的类型 */
        bool            all;            /* 是否指明了 ALL 选项? */
        struct SelectStmt *larg;        /* 左子节点 */
        struct SelectStmt *rarg;        /* 右子节点 */
} SelectStmt;

/*
 * Query -
 *      解析与分析过程会将所有的语句转换为一颗查询树，供重写器与计划器用于进一步的处理。
 *    功能语句（即不可优化的语句）会设置utilityStmt字段，而Query结构本身基本上是空的。
 *      DECLARE CURSOR 是一个特例：它的形式与SELECT类似，但原始的DeclareCursorStmt会
 *    被放在 utilityStmt 字段中。
 *    计划过程会将查询树转换为一颗计划树，计划树的根节点是一个PlannedStmt结构
 *    执行器不会用到查询树结构
 */
typedef struct Query
{
    NodeTag        type;
    CmdType        commandType;        /* select|insert|update|delete|utility */
    QuerySource querySource;        /* 我来自哪里? */
    uint32        queryId;            /* 查询标识符 (可由插件配置) */
    bool        canSetTag;            /* 我设置了命令结果标签吗? */
    Node           *utilityStmt;        /* 如果这是一条DECLARE CURSOR或不可优化的语句 */
    int        resultRelation;         /* 对增删改语句而言是目标关系的索引; SELECT为0 */
    bool        hasAggs;            /* 是否在目标列表或having表达式中指定了聚合函数 */
    bool        hasWindowFuncs;     /* tlist是否包含窗口函数 */
    bool        hasSubLinks;        /* 是否包含子查询SubLink */
    bool        hasDistinctOn;        /* 是否包含来自DISTINCT ON的distinct子句 */
    bool        hasRecursive;        /* 是否制定了WITH RECURSIVE */
    bool        hasModifyingCTE;    /* 是否在WITH子句中包含了INSERT/UPDATE/DELETE */
    bool        hasForUpdate;        /* 是否指定了FOR [KEY] UPDATE/SHARE*/
    bool        hasRowSecurity;     /* 是否应用了行安全策略 */
    List           *cteList;            /* CTE列表 */
    List           *rtable;            /* 范围表项目列表 */
    FromExpr       *jointree;            /* 表连接树 (FROM 与 WHERE 子句) */
    List           *targetList;        /* 目标列表 (TargetEntry的列表) */
    List           *withCheckOptions;    /* WithCheckOption的列表 */
    OnConflictExpr     *onConflict;     /* ON CONFLICT DO [NOTHING | UPDATE] */
    List           *returningList;        /* 返回值列表(TargetEntry的列表) */
    List           *groupClause;        /* SortGroupClause的列表 */
    List           *groupingSets;        /* 如果有，GroupingSet的列表 */
    Node           *havingQual;        /* 分组的Having条件列表 */
    List           *windowClause;        /* 窗口子句列表 */
    List           *distinctClause;     /* SortGroupClause列表 */
    List           *sortClause;        /* SortGroupClause列表 */
    Node           *limitOffset;        /* Offset跳过元组数目 (int8 表达式) */
    Node           *limitCount;        /* Limit返回元组数目 (int8 表达式) */
    List           *rowMarks;          /* RowMarkClause列表 */
    Node           *setOperations;        /* 如果是UNION/INTERSECT/EXCEPT的顶层查询，
                                       则为集合操作列表 */
    List           *constraintDeps;     /* 确认查询语义是否合法时，所依赖约束对象的OID列表 */
} Query;

• targetlist 是查询结果中列（Column） 的列表。在本例中该列表包含两列：id 和data。如果在输入的查询树中使用了*（星号），那么分析器会将其显式替换为所有具体的列。
• 范围表rtable是该查询所用到关系的列表。本例中该变量包含了表tbl_a的信息，如该表的表名与oid。
• 连接树jointree存储着FROM和WHERE子句的相关信息。
• 排序子句sortClause是SortGroupClause结构体的列表。

视图

在PostgreSQL中，视图是基于规则系统实现的。当使用CREATE VIEW命令定义一个视图时，PostgreSQL就会创建相应的规则，并存储到系统目录中。

假设下面的视图已经被定义，而pg_rule中也存储了相应的规则。

sampledb=# CREATE VIEW employees_list 
sampledb-#   AS SELECT e.id, e.name, d.name AS department 
sampledb-#      FROM employees AS e, departments AS d WHERE e.department_id = d.id;

当执行一个包含该视图的查询，解析器会创建一颗如图3.4(a)所示的语法解析树。

sampledb=# SELECT * FROM employees_list;

在该阶段，重写器会基于pg_rules中存储的视图规则将rangetable节点重写为一颗查询子树，与子查询相对应。

图3.4 重写阶段一例

因为PostgreSQL使用这种机制实现视图，直到9.2版本，视图都是不能更新的。虽然9.3版本后可以对视图进行更新，但对视图的更新仍然存在很多限制，具体细节请参考官方文档。

pg_hint_plan

PostgreSQL不支持SQL中的提示（hint） ，并且永远也不会去支持。如果你想在查询中使用提示，可以考虑使用pg_hint_plan扩展，细节请参考官方站点。

testdb=# EXPLAIN SELECT * FROM tbl_a WHERE id < 300 ORDER BY data;
                          QUERY PLAN               
---------------------------------------------------------------
 Sort  (cost=182.34..183.09 rows=300 width=8)
   Sort Key: data
   ->  Seq Scan on tbl_a  (cost=0.00..170.00 rows=300 width=8)
         Filter: (id < 300)
(4 rows)