这篇文章主要为大家展示了“PostgreSQL中PlannedStmt的跟踪分析”，内容简而易懂，条理清晰，希望能够帮助大家解决疑惑，下面让小编带领大家一起研究并学习一下“PostgreSQL中PlannedStmt的跟踪分析”这篇文章吧。

成都创新互联公司是一家以成都网站建设公司、网页设计、品牌设计、软件运维、成都网站推广、小程序App开发等移动开发为一体互联网公司。已累计为航空箱等众行业中小客户提供优质的互联网建站和软件开发服务。

计划树

二、数据结构

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的跟踪分析”这篇文章的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注创新互联行业资讯频道！

分享名称：PostgreSQL中PlannedStmt的跟踪分析
分享路径：http://azwzsj.com/article/pichcj.html