Shulou(Shulou.com)05/31 Report--

This article mainly shows you the "tracking analysis of PlannedStmt in PostgreSQL", which is easy to understand and clear. I hope it can help you solve your doubts. Let the editor lead you to study and learn the article "tracking analysis of PlannedStmt in PostgreSQL".

Plan tree

2. Data structure

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; / * targetlist 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 The above is all the contents of this article "tracking and Analysis of PlannedStmt in PostgreSQL". Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.