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