共計 6819 個字符，預計需要花費 18 分鐘才能閱讀完成。

這篇文章主要為大家展示了“PostgreSQL 中 PlannedStmt 的跟蹤分析”，內容簡而易懂，條理清晰，希望能夠幫助大家解決疑惑，下面讓丸趣 TV 小編帶領大家一起研究并學習一下“PostgreSQL 中 PlannedStmt 的跟蹤分析”這篇文章吧。

計劃樹

二、數據結構

Plan

 /* ----------------
 * Plan node
 *
 * All plan nodes  derive  from the Plan structure by having the
 * Plan structure as the first field. This ensures that everything works
 * when nodes are cast to Plan s. (node pointers are frequently cast to Plan*
 * when passed around generically in the executor)
 *
 * We never actually instantiate any Plan nodes; this is just the common
 * abstract superclass for all Plan-type nodes.
 * ----------------
 */
 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;

Limit

 /* ----------------
 * limit node
 *
 * Note: as of Postgres 8.2, the offset and count expressions are expected
 * to yield int8, rather than int4 as before.
 * ----------------
 */
 typedef struct Limit
 {
 Plan plan;
 Node *limitOffset; /* OFFSET parameter, or NULL if none */
 Node *limitCount; /* COUNT parameter, or NULL if none */
 } Limit;

Sort

 /* ----------------
 * sort node
 * ----------------
 */
 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;

Append

 /* ----------------
 * Append node -
 * Generate the concatenation of the results of sub-plans.
 * ----------------
 */
 typedef struct Append
 {
 Plan plan;
 List *appendplans;
 
 /*
 * All  appendplans  preceding this index are non-partial plans. All
 *  appendplans  from this index onwards are partial plans.
 */
 int first_partial_plan;
 
 /* RT indexes of non-leaf tables in a partition tree */
 List *partitioned_rels;
 
 /* Info for run-time subplan pruning; NULL if we re not doing that */
 struct PartitionPruneInfo *part_prune_info;
 } Append;

NestLoop

 /* ----------------
 * nest loop join node
 *
 * The nestParams list identifies any executor Params that must be passed
 * into execution of the inner subplan carrying values from the current row
 * of the outer subplan. Currently we restrict these values to be simple
 * Vars, but perhaps someday that d be worth relaxing. (Note: during plan
 * creation, the paramval can actually be a PlaceHolderVar expression; but it
 * must be a Var with varno OUTER_VAR by the time it gets to the executor.)
 * ----------------
 */
 typedef struct NestLoop
 {
 Join join;
 List *nestParams; /* list of NestLoopParam nodes */
 } NestLoop;
 
 typedef struct NestLoopParam
 {
 NodeTag type;
 int paramno; /* number of the PARAM_EXEC Param to set */
 Var *paramval; /* outer-relation Var to assign to Param */
 } NestLoopParam;
 
 /*
 * ==========
 * Join nodes
 * ==========
 */
 /* ----------------
 * merge join node
 *
 * The expected ordering of each mergeable column is described by a btree
 * opfamily OID, a collation OID, a direction (BTLessStrategyNumber or
 * BTGreaterStrategyNumber) and a nulls-first flag. Note that the two sides
 * of each mergeclause may be of different datatypes, but they are ordered the
 * same way according to the common opfamily and collation. The operator in
 * each mergeclause must be an equality operator of the indicated opfamily.
 * ----------------
 */
 typedef struct MergeJoin
 {
 Join join;
 bool skip_mark_restore; /* Can we skip mark/restore calls? */
 List *mergeclauses; /* mergeclauses as expression trees */
 /* these are arrays, but have the same length as the mergeclauses list: */
 Oid *mergeFamilies; /* per-clause OIDs of btree opfamilies */
 Oid *mergeCollations; /* per-clause OIDs of collations */
 int *mergeStrategies; /* per-clause ordering (ASC or DESC) */
 bool *mergeNullsFirst; /* per-clause nulls ordering */
 } MergeJoin;
 
 /* ----------------
 * hash join node
 * ----------------
 */
 typedef struct HashJoin
 {
 Join join;
 List *hashclauses;
 } HashJoin;
 
 /* ----------------
 * Join node
 *
 * jointype: rule for joining tuples from left and right subtrees
 * inner_unique each outer tuple can match to no more than one inner tuple
 * joinqual: qual conditions that came from JOIN/ON or JOIN/USING
 * (plan.qual contains conditions that came from WHERE)
 *
 * When jointype is INNER, joinqual and plan.qual are semantically
 * interchangeable. For OUTER jointypes, the two are *not* interchangeable;
 * only joinqual is used to determine whether a match has been found for
 * the purpose of deciding whether to generate null-extended tuples.
 * (But plan.qual is still applied before actually returning a tuple.)
 * For an outer join, only joinquals are allowed to be used as the merge
 * or hash condition of a merge or hash join.
 *
 * inner_unique is set if the joinquals are such that no more than one inner
 * tuple could match any given outer tuple. This allows the executor to
 * skip searching for additional matches. (This must be provable from just
 * the joinquals, ignoring plan.qual, due to where the executor tests it.)
 * ----------------
 */
 typedef struct Join
 {
 Plan plan;
 JoinType jointype;
 bool inner_unique;
 List *joinqual; /* JOIN quals (in addition to plan.qual) */
 } Join;

SeqScan

 /*
 * ==========
 * Scan nodes
 * ==========
 */
 typedef struct Scan
 {
 Plan plan;
 Index scanrelid; /* relid is index into the range table */
 } Scan;
 
 /* ----------------
 * sequential scan node
 * ----------------
 */
 typedef Scan SeqScan;

以上是“PostgreSQL 中 PlannedStmt 的跟蹤分析”這篇文章的所有內容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內容對大家有所幫助，如果還想學習更多知識，歡迎關注丸趣 TV 行業資訊頻道！