PostgreSQL中PlannedStmt的跟踪分析

这篇文章主要为大家展示了“PostgreSQL中PlannedStmt的跟踪分析”，内容简而易懂，条理清晰，希望能够帮助大家解决疑惑，下面让小编带领大家一起研究并学习一下“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的跟踪分析”这篇文章的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注亿速云行业资讯频道！