#### 3.3建立單表查詢的計劃樹

Postgresql中的計劃器會執行三個處理步驟：
1. 執行預處理
2. 在所有可能的訪問路徑中，找出代價最小的訪問路徑
3. 按照代價最小的路徑，建立計劃樹

訪問路徑是估算代價時的處理單元。比如順序掃描、索引掃描、排序，以及各種連線操作都有其對應的路徑。訪問路徑只在計劃器建立查詢計劃樹的時候使用。最基本的訪問路徑資料結構就是relation.h定義的Path結構體，相當於順序掃描。所有其他的訪問路徑都基於該結構。
計劃器為了處理上述步驟，會在內部建立一個PlannerInfo資料結構，該資料結構中包含查詢樹，可以查詢鎖涉及的關係資訊，訪問路徑等。

```
#/pgdata/pgsql/include/postgresql/server/nodes/relation.h

/*
 * PathKeys
 *
 * The sort ordering of a path is represented by a list of PathKey nodes.
 * An empty list implies no known ordering.  Otherwise the first item
 * represents the primary sort key, the second the first secondary sort key,
 * etc.  The value being sorted is represented by linking to an
 * EquivalenceClass containing that value and including pk_opfamily among its
 * ec_opfamilies.  The EquivalenceClass tells which collation to use, too.
 * This is a convenient method because it makes it trivial to detect
 * equivalent and closely-related orderings. (See optimizer/README for more
 * information.)
 *
 * Note: pk_strategy is either BTLessStrategyNumber (for ASC) or
 * BTGreaterStrategyNumber (for DESC).  We assume that all ordering-capable
 * index types will use btree-compatible strategy numbers.
 */
typedef struct PathKey
{
        NodeTag         type;

EquivalenceClass *pk_eclass;    /* the value that is ordered */
        Oid                     pk_opfamily;    /* btree opfamily defining the ordering */
        int                     pk_strategy;    /* sort direction (ASC or DESC) */
        bool            pk_nulls_first; /* do NULLs come before normal values? */
} PathKey;

typedef struct Path
{
        NodeTag         type;

NodeTag         pathtype;               /* tag identifying scan/join method */

RelOptInfo *parent;                     /* the relation this path can build */
        PathTarget *pathtarget;         /* list of Vars/Exprs, cost, width */

ParamPathInfo *param_info;      /* parameterization info, or NULL if none */

bool            parallel_aware; /* engage parallel-aware logic? */
        bool            parallel_safe;  /* OK to use as part of parallel plan? */
        int                     parallel_workers;       /* desired # of workers; 0 = not parallel */

/* estimated size/costs for path (see costsize.c for more info) */
        double          rows;                   /* estimated number of result tuples */
        Cost            startup_cost;   /* cost expended before fetching any tuples */
        Cost            total_cost;             /* total cost (assuming all tuples fetched) */

List       *pathkeys;           /* sort ordering of path's output */
        /* pathkeys is a List of PathKey nodes; see above */
} Path;
/*----------
 * PlannerInfo
 *              Per-query information for planning/optimization
 *
 * This struct is conventionally called "root" in all the planner routines.
 * It holds links to all of the planner's working state, in addition to the
 * original Query.  Note that at present the planner extensively modifies
 * the passed-in Query data structure; someday that should stop.
 *----------
 */
typedef struct PlannerInfo
{
        NodeTag         type;

Query      *parse;                      /* the Query being planned */

PlannerGlobal *glob;            /* global info for current planner run */

Index           query_level;    /* 1 at the outermost Query */

struct PlannerInfo *parent_root;        /* NULL at outermost Query */

/*
         * plan_params contains the expressions that this query level needs to
         * make available to a lower query level that is currently being planned.
         * outer_params contains the paramIds of PARAM_EXEC Params that outer
         * query levels will make available to this query level.
         */
        List       *plan_params;        /* list of PlannerParamItems, see below */
        Bitmapset  *outer_params;

/*
         * simple_rel_array holds pointers to "base rels" and "other rels" (see
         * comments for RelOptInfo for more info).  It is indexed by rangetable
         * index (so entry 0 is always wasted).  Entries can be NULL when an RTE
         * does not correspond to a base relation, such as a join RTE or an
         * unreferenced view RTE; or if the RelOptInfo hasn't been made yet.
         */
        struct RelOptInfo **simple_rel_array;   /* All 1-rel RelOptInfos */
        int                     simple_rel_array_size;  /* allocated size of array */

/*
         * simple_rte_array is the same length as simple_rel_array and holds
         * pointers to the associated rangetable entries.  This lets us avoid
         * rt_fetch(), which can be a bit slow once large inheritance sets have
         * been expanded.
         */
        RangeTblEntry **simple_rte_array;       /* rangetable as an array */

/*
         * all_baserels is a Relids set of all base relids (but not "other"
         * relids) in the query; that is, the Relids identifier of the final join
         * we need to form.  This is computed in make_one_rel, just before we
         * start making Paths.
         */
        Relids          all_baserels;

/*
         * nullable_baserels is a Relids set of base relids that are nullable by
         * some outer join in the jointree; these are rels that are potentially
         * nullable below the WHERE clause, SELECT targetlist, etc.  This is
         * computed in deconstruct_jointree.
         */
        Relids          nullable_baserels;

/*
         * join_rel_list is a list of all join-relation RelOptInfos we have
         * considered in this planning run.  For small problems we just scan the
         * list to do lookups, but when there are many join relations we build a
         * hash table for faster lookups.  The hash table is present and valid
         * when join_rel_hash is not NULL.  Note that we still maintain the list
         * even when using the hash table for lookups; this simplifies life for
         * GEQO.
         */
        List       *join_rel_list;      /* list of join-relation RelOptInfos */
        struct HTAB *join_rel_hash; /* optional hashtable for join relations */

/*
         * When doing a dynamic-programming-style join search, join_rel_level[k]
         * is a list of all join-relation RelOptInfos of level k, and
         * join_cur_level is the current level.  New join-relation RelOptInfos are
         * automatically added to the join_rel_level[join_cur_level] list.
         * join_rel_level is NULL if not in use.
         */
        List      **join_rel_level; /* lists of join-relation RelOptInfos */
        int                     join_cur_level; /* index of list being extended */

List       *init_plans;         /* init SubPlans for query */

List       *cte_plan_ids;       /* per-CTE-item list of subplan IDs */

List       *multiexpr_params;   /* List of Lists of Params for MULTIEXPR
                                                                         * subquery outputs */

List       *eq_classes;         /* list of active EquivalenceClasses */

List       *canon_pathkeys; /* list of "canonical" PathKeys */

List       *left_join_clauses;  /* list of RestrictInfos for mergejoinable
                                                                         * outer join clauses w/nonnullable var on
                                                                         * left */

List       *right_join_clauses; /* list of RestrictInfos for mergejoinable
                                                                         * outer join clauses w/nonnullable var on
                                                                         * right */

List       *full_join_clauses;  /* list of RestrictInfos for mergejoinable
                                                                         * full join clauses */

List       *join_info_list; /* list of SpecialJoinInfos */

List       *append_rel_list;    /* list of AppendRelInfos */

List       *pcinfo_list;        /* list of PartitionedChildRelInfos */

List       *rowMarks;           /* list of PlanRowMarks */

List       *placeholder_list;   /* list of PlaceHolderInfos */

List       *fkey_list;          /* list of ForeignKeyOptInfos */

List       *query_pathkeys; /* desired pathkeys for query_planner() */

List       *group_pathkeys; /* groupClause pathkeys, if any */
        List       *window_pathkeys;    /* pathkeys of bottom window, if any */
        List       *distinct_pathkeys;  /* distinctClause pathkeys, if any */
        List       *sort_pathkeys;      /* sortClause pathkeys, if any */

List       *initial_rels;       /* RelOptInfos we are now trying to join */

/* Use fetch_upper_rel() to get any particular upper rel */
        List       *upper_rels[UPPERREL_FINAL + 1]; /* upper-rel RelOptInfos */

/* Result tlists chosen by grouping_planner for upper-stage processing */
        struct PathTarget *upper_targets[UPPERREL_FINAL + 1];

/*
         * grouping_planner passes back its final processed targetlist here, for
         * use in relabeling the topmost tlist of the finished Plan.
         */
        List       *processed_tlist;

/* Fields filled during create_plan() for use in setrefs.c */
        AttrNumber *grouping_map;       /* for GroupingFunc fixup */
        List       *minmax_aggs;        /* List of MinMaxAggInfos */

MemoryContext planner_cxt;      /* context holding PlannerInfo */

double          total_table_pages;      /* # of pages in all tables of query */

double          tuple_fraction; /* tuple_fraction passed to query_planner */
        double          limit_tuples;   /* limit_tuples passed to query_planner */

Index           qual_security_level;    /* minimum security_level for quals */
        /* Note: qual_security_level is zero if there are no securityQuals */

bool            hasInheritedTarget; /* true if parse->resultRelation is an
                                                                         * inheritance child rel */
        bool            hasJoinRTEs;    /* true if any RTEs are RTE_JOIN kind */
        bool            hasLateralRTEs; /* true if any RTEs are marked LATERAL */
        bool            hasDeletedRTEs; /* true if any RTE was deleted from jointree */
        bool            hasHavingQual;  /* true if havingQual was non-null */
        bool            hasPseudoConstantQuals; /* true if any RestrictInfo has
                                                                                 * pseudoconstant = true */
        bool            hasRecursion;   /* true if planning a recursive WITH item */

/* These fields are used only when hasRecursion is true: */
        int                     wt_param_id;    /* PARAM_EXEC ID for the work table */
        struct Path *non_recursive_path;        /* a path for non-recursive term */

/* These fields are workspace for createplan.c */
        Relids          curOuterRels;   /* outer rels above current node */
        List       *curOuterParams; /* not-yet-assigned NestLoopParams */

/* optional private data for join_search_hook, e.g., GEQO */
        void       *join_search_private;
} PlannerInfo;
```

##### 預處理
在建立計劃樹之前，計劃器將先對PlannerInfo中的查詢樹進行一些預處理

1. 計簡化目標列表，limit子句等。eg：表示式2+2 會被重寫為4，由clauses.c中eval_cons_expressions()函式負責
2. 布林表示的規範化：not(not a) 會被重寫為a
3. 壓平與/或表示式：SQL表準中的是而元運算子，pg內部是多元，計劃器總是會假設所有巢狀AND/OR都應當被壓平

##### 找出代價最小的訪問路徑
計劃器對所有可能的訪問路徑進行代價估算，然後選擇代價最小的那個。具體會執行以下幾個步驟：
1. 建立一個RelOptInfo資料結構，儲存訪問路徑及其代價
RelOptInfo結構體是透過make_one_rel()函式建立的，並儲存於PlannerInfo結構體的simple_rel_array欄位中。在初始狀態時，RelOptInfo持有著baserestrictinfo變數，如果存在相應的索引，還會持有indexlist變數。baserestrictinfo儲存著查詢的where子句，而indexlist儲存著目標表上相關的索引。

```
typedef enum RelOptKind
{
        RELOPT_BASEREL,
        RELOPT_JOINREL,
        RELOPT_OTHER_MEMBER_REL,
        RELOPT_UPPER_REL,
        RELOPT_DEADREL
} RelOptKind;

typedef struct RelOptInfo
{
        NodeTag         type;

RelOptKind      reloptkind;

/* all relations included in this RelOptInfo */
        Relids          relids;                 /* set of base relids (rangetable indexes) */

/* size estimates generated by planner */
        double          rows;                   /* estimated number of result tuples */

/* per-relation planner control flags */
        bool            consider_startup;       /* keep cheap-startup-cost paths? */
        bool            consider_param_startup; /* ditto, for parameterized paths? */
        bool            consider_parallel;      /* consider parallel paths? */

/* default result targetlist for Paths scanning this relation */
        struct PathTarget *reltarget;   /* list of Vars/Exprs, cost, width */

/* materialization information */
        List       *pathlist;           /* Path structures */
        List       *ppilist;            /* ParamPathInfos used in pathlist */
        List       *partial_pathlist;   /* partial Paths */
        struct Path *cheapest_startup_path;
        struct Path *cheapest_total_path;
        struct Path *cheapest_unique_path;
        List       *cheapest_parameterized_paths;

/* parameterization information needed for both base rels and join rels */
        /* (see also lateral_vars and lateral_referencers) */
        Relids          direct_lateral_relids;  /* rels directly laterally referenced */
        Relids          lateral_relids; /* minimum parameterization of rel */

/* information about a base rel (not set for join rels!) */
        Index           relid;
        Oid                     reltablespace;  /* containing tablespace */
        RTEKind         rtekind;                /* RELATION, SUBQUERY, or FUNCTION */
        AttrNumber      min_attr;               /* smallest attrno of rel (often <0) */
        AttrNumber      max_attr;               /* largest attrno of rel */
        Relids     *attr_needed;        /* array indexed [min_attr .. max_attr] */
        int32      *attr_widths;        /* array indexed [min_attr .. max_attr] */
        List       *lateral_vars;       /* LATERAL Vars and PHVs referenced by rel */
        Relids          lateral_referencers;    /* rels that reference me laterally */
        List       *indexlist;          /* list of IndexOptInfo */
        List       *statlist;           /* list of StatisticExtInfo */
        BlockNumber pages;                      /* size estimates derived from pg_class */
        double          tuples;
        double          allvisfrac;
        PlannerInfo *subroot;           /* if subquery */
        List       *subplan_params; /* if subquery */
        int                     rel_parallel_workers;   /* wanted number of parallel workers */

/* Information about foreign tables and foreign joins */
        Oid                     serverid;               /* identifies server for the table or join */
        Oid                     userid;                 /* identifies user to check access as */
        bool            useridiscurrent;        /* join is only valid for current user */
        /* use "struct FdwRoutine" to avoid including fdwapi.h here */
        struct FdwRoutine *fdwroutine;
        void       *fdw_private;

/* cache space for remembering if we have proven this relation unique */
        List       *unique_for_rels;    /* known unique for these other relid
                                                                         * set(s) */
        List       *non_unique_for_rels;        /* known not unique for these set(s) */

/* used by various scans and joins: */
        List       *baserestrictinfo;   /* RestrictInfo structures (if base rel) */
        QualCost        baserestrictcost;       /* cost of evaluating the above */
        Index           baserestrict_min_security;      /* min security_level found in
                                                                                         * baserestrictinfo */
        List       *joininfo;           /* RestrictInfo structures for join clauses
                                                                 * involving this rel */
        bool            has_eclass_joins;       /* T means joininfo is incomplete */

/* used by "other" relations */
        Relids          top_parent_relids;      /* Relids of topmost parents */
} RelOptInfo;
```
2. 估計所有可能訪問路徑的代價，並將訪問路徑新增至RelOptInfo結構中。具體細節：
- 建立一條路徑，估計改路徑中順序掃描的代價，並將其寫入路徑中。將該路徑新增到RelOptInfo結構的pathlist變數中。
- 如果目標表上存在相關索引，則為每個索引建立相應的索引訪問路徑。估計所有索引掃描的代價，並將代價寫入相應的路徑中。然後將索引訪問路徑新增到pathlist變數中。
- 如果可以進行點陣圖掃描，則建立一條點陣圖掃描的訪問路徑，估計所有點陣圖掃描的代價，並將代價寫入到路徑中，然後將點陣圖掃描路徑新增到pathlist變數中。

3. 從RelOptInfo的pathlist中，找出代價最小的訪問路徑
4. 如果有必要，估計limit,order by 和aggregate操作的代價

###### eg.1
  一個不帶索引的簡單單表查詢，該查詢同時包含where和order by子句

```
select * from tbl_1 where id<300 order by data;
```

> 圖例參考45頁，3.10 3.11

![圖310-311](https://gitee.com/firsouler/postgresql-learning/raw/master/pginternalsImages/3.10-11.jpg)

1. 建立一個RelOptInfo結構，將其報錯在PlannerInfo結構的simple_rel_array欄位中
2. 在RelOptInfo結構的baserestrictinfo欄位中，新增一條where子句
> where子句id<30會經由initsplan.c中定義的distribute_restrictinfo_to_rels()函式，新增至列表變數baserestrictinfo中。另外由於目標表上沒有相關索引，RelOptInfo的indexlist欄位為空。
3. 為了滿足排序要求，planner.c中的standard_qp_callback()函式會在PlannerInfo的sor_pathkeys欄位中新增一個pathkey.
> Pathkey是表示路徑排序順序的資料結構。本例因為查詢包含一條ORDER BY子句，且該子句中的列為data，故data會被包裝為pathkey，放入列表變數sort_pathkeys中。
4. 建立一個Path結構，並使用cost_seqscan函式估計順序掃描的代價，並將代價寫入Path中。然後使用pathnode.c中定義的add_path()函式，將該路徑新增至RelOptInfo中。
>如前所述，Path 中同時包含啟動代價和總代價，兩者都是由cost_seqscan 函式所估計的。在本例中，因為目標表上沒有索引，計劃器只估計了順序掃描的代價，因此最小代價是自動確定的。
5. 建立一個新的RelOptInfo結構，用於處理Order by子句
> 注意，新的RelOptInfo沒有baserestrictinfo欄位，該資訊已經被WHERE子句所持有。
6. 建立一個排序路徑，並新增到新的RelOptInfo中，然後讓SotPath的subpath欄位指向順序掃描的路徑。

```
typedef struct SortPath
{
        Path            path;
        Path       *subpath;            /* path representing input source (代表輸入來源的子路徑)*/
} SortPath;
```
SortPath結構包含path與subpath兩個Path結構，path中儲存了排序運算元本身的相關資訊，subpath則指向之前得到的代價最小的路徑。

注意順序掃描路徑中的parent欄位，該欄位指向之前的RelOptInfo結構體（也就是在baserestrictinfo中儲存著WHERE子句的那個RelOptInfo）。因此在下一步建立計劃樹的過程中，儘管新的RelOptInfo結構並未包含baserestrictinfo，但是計劃器可以建立一個包含Filter的順序掃描節點，將WHERE子句作為過濾條件。
這裡已經獲得了代價最小的訪問路徑，然後就可以基於此生成一棵計劃樹。第3.3.3節描述了相關的細節

###### eg.2
> pg內幕探索，3.3.2.2

mydb=# select * from tb1 where id<240;
```
1. 建立一個RelOptInfo結構體
2. 在baserestrictinfo中新增一個where子句，將目標索引加到indexlist中。
3. 建立一條路徑，估算順序掃描的代價，並新增到pathlist中
4. 建立一個IndexPath，估計索引掃描代價，並透過add_path()函式將IndexPath新增到pathlist中
5. 建立另一個IndexPath，估算另一種索引代價
6. 建立一個新的RelOptInfo結構
7. 將代價最小的路徑新增到新的RelOptInfo的pathlist中

> 圖例參考3.12-3.14

![圖312](https://gitee.com/firsouler/postgresql-learning/raw/master/pginternalsImages/3.12.jpg)

![圖313](https://gitee.com/firsouler/postgresql-learning/raw/master/pginternalsImages/3.13.jpg)

![圖314](https://gitee.com/firsouler/postgresql-learning/raw/master/pginternalsImages/3.14.jpg)

##### 建立計劃樹

計劃樹的根節點定義在plannodes.h中的PlannedStmt結構，包含19個欄位，其中有4個代表性欄位：
- commandType儲存操作的型別，諸如select、update和insert
- rtable儲存範圍表的列表（RangeTblEntry的列表）
- relationOids儲存與查詢相關表的oid
- plantree儲存一顆由計劃節點組成的計劃樹，每個計劃節點對應著一種特定操作，諸如順序掃描、排序和索引掃描

```
/*
* PlannedStmt節點計劃器的輸出是一顆計劃樹，PlannedStmt是計劃樹的根節點
PlannedStmt儲存著執行器所需的“一次性”資訊
*/

typedef struct PlannedStmt
{
        NodeTag         type;

CmdType         commandType;    /* select|insert|update|delete|utility */

uint32          queryId;                /* query identifier (copied from Query) */

bool            hasReturning;   /* is it insert|update|delete RETURNING? */

bool            hasModifyingCTE;        /* has insert|update|delete in WITH? */

bool            canSetTag;              /* do I set the command result tag? */

bool            transientPlan;  /* redo plan when TransactionXmin changes? */

bool            dependsOnRole;  /* is plan specific to current role? */

bool            parallelModeNeeded; /* parallel mode required to execute? */

struct Plan *planTree;          /* tree of Plan nodes */

List       *rtable;                     /* list of RangeTblEntry nodes */

/* rtable indexes of target relations for INSERT/UPDATE/DELETE */
        List       *resultRelations;    /* integer list of RT indexes, or NIL */

/*
         * rtable indexes of non-leaf target relations for UPDATE/DELETE on all
         * the partitioned tables mentioned in the query.
         */
        List       *nonleafResultRelations;

/*
         * rtable indexes of root target relations for UPDATE/DELETE; this list
         * maintains a subset of the RT indexes in nonleafResultRelations,
         * indicating the roots of the respective partition hierarchies.
         */
        List       *rootResultRelations;

List       *subplans;           /* Plan trees for SubPlan expressions; note
                                                                 * that some could be NULL */

Bitmapset  *rewindPlanIDs;      /* indices of subplans that require REWIND */

List       *rowMarks;           /* a list of PlanRowMark's */

List       *relationOids;       /* OIDs of relations the plan depends on */

List       *invalItems;         /* other dependencies, as PlanInvalItems */

int                     nParamExec;             /* number of PARAM_EXEC Params used */

Node       *utilityStmt;        /* non-null if this is utility stmt */

/* statement location in source string (copied from Query) */
        int                     stmt_location;  /* start location, or -1 if unknown */
        int                     stmt_len;               /* length in bytes; 0 means "rest of string" */
} PlannedStmt;
```

如上所述，計劃樹包含各式各樣的計劃節點。PlanNode 是所有計劃節點的基類，其他計劃節點都會包含PlanNode結構。比如順序掃描節點SeqScanNode包含一個PlanNode和一個整型變數scanrelid。PlanNode包含14個欄位，下面是7個代表性欄位：
- startup_cost和total_cost是該節點對應操作的預估代價。
- rows是計劃器預計掃描的行數。
- targetlist儲存了該查詢樹中目標項的列表。
- qual儲存了限定條件的列表。
- lefttree和righttree用於新增子節點。

```
/*
* 計劃節點(plan node)
* 所有的計劃節點都“派生”自plan結構，將其作為自己的第一個欄位。這樣確保了當其強制轉換為plan結構時所有內容都能正常工作。（當作為通用引數傳入執行器時，節點指標會很頻繁地轉換為plan） 我們從來不會真的去例項化任何plan節點，它只是所有plan型別節點的公共抽象父類。
*/
typedef struct Plan
{
        NodeTag         type;

/*
         * estimated execution costs for plan (see costsize.c for more info)
         */
        Cost            startup_cost;   /* cost expended before fetching any tuples */
        Cost            total_cost;             /* total cost (assuming all tuples fetched) */

/*
         * planner's estimate of result size of this plan step
         */
        double          plan_rows;              /* number of rows plan is expected to emit */
        int                     plan_width;             /* average row width in bytes */

/*
         * information needed for parallel query
         */
        bool            parallel_aware; /* engage parallel-aware logic? */
        bool            parallel_safe;  /* OK to use as part of parallel plan? */

/*
         * Common structural data for all Plan types.
         */
        int                     plan_node_id;   /* unique across entire final plan tree */
        List       *targetlist;         /* target list to be computed at this node */
        List       *qual;                       /* implicitly-ANDed qual conditions */
        struct Plan *lefttree;          /* input plan tree(s) */
        struct Plan *righttree;
        List       *initPlan;           /* Init Plan nodes (un-correlated expr
                                                                 * subselects) */

/*
         * Information for management of parameter-change-driven rescanning
         *
         * extParam includes the paramIDs of all external PARAM_EXEC params
         * affecting this plan node or its children.  setParam params from the
         * node's initPlans are not included, but their extParams are.
         *
         * allParam includes all the extParam paramIDs, plus the IDs of local
         * params that affect the node (i.e., the setParams of its initplans).
         * These are _all_ the PARAM_EXEC params that affect this node.
         */
        Bitmapset  *extParam;
        Bitmapset  *allParam;
} Plan;
```
例子1：計劃樹由一個排序路徑和一個順序掃描路徑組合而成，如圖3.15-1。

```
typedef struct Sort
{
        Plan            plan;
        int                     numCols;                /* number of sort-key columns */
        AttrNumber *sortColIdx;         /* their indexes in the target list */
        Oid                *sortOperators;      /* OIDs of operators to sort them by */
        Oid                *collations;         /* OIDs of collations */
        bool       *nullsFirst;         /* NULLS FIRST/LAST directions */
} Sort;
```

例子2：計劃樹由單個IndexScanNode獨立組成，如圖3.15-2

```
typedef struct Scan
{
        Plan            plan;
        Index           scanrelid;              /* relid is index into the range table */
} Scan;

typedef struct IndexScan
{
        Scan            scan;
        Oid                     indexid;                /* OID of index to scan */
        List       *indexqual;          /* list of index quals (usually OpExprs) */
        List       *indexqualorig;      /* the same in original form */
        List       *indexorderby;       /* list of index ORDER BY exprs */
        List       *indexorderbyorig;   /* the same in original form */
        List       *indexorderbyops;    /* OIDs of sort ops for ORDER BY exprs */
        ScanDirection indexorderdir;    /* forward or backward or don't care */
} IndexScan
```

![圖315](https://gitee.com/firsouler/postgresql-learning/raw/master/pginternalsImages/3.15.jpg)

【讀書筆記】《PostgreSQL指南-內幕探索》-3.3建立單表查詢的計劃樹

相關文章