#include "access/sdir.h"
#include "lib/stringinfo.h"
#include "nodes/params.h"
#include "nodes/parsenodes.h"
#include "storage/block.h"

Include dependency graph for pathnodes.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	QualCost

struct	AggClauseCosts

struct	PlannerGlobal

struct	PlannerInfo

struct	PartitionSchemeData

struct	RelOptInfo

struct	RelAggInfo

struct	IndexOptInfo

struct	ForeignKeyOptInfo

struct	StatisticExtInfo

struct	JoinDomain

struct	EquivalenceClass

struct	EquivalenceMember

struct	EquivalenceMemberIterator

struct	PathKey

struct	GroupByOrdering

struct	PathTarget

struct	ParamPathInfo

struct	Path

struct	IndexPath

struct	IndexClause

struct	BitmapHeapPath

struct	BitmapAndPath

struct	BitmapOrPath

struct	TidPath

struct	TidRangePath

struct	SubqueryScanPath

struct	ForeignPath

struct	CustomPath

struct	AppendPath

struct	MergeAppendPath

struct	GroupResultPath

struct	MaterialPath

struct	MemoizePath

struct	GatherPath

struct	GatherMergePath

struct	JoinPath

struct	NestPath

struct	MergePath

struct	HashPath

struct	ProjectionPath

struct	ProjectSetPath

struct	SortPath

struct	IncrementalSortPath

struct	GroupPath

struct	UniquePath

struct	AggPath

struct	GroupingSetData

struct	RollupData

struct	GroupingSetsPath

struct	MinMaxAggPath

struct	WindowAggPath

struct	SetOpPath

struct	RecursiveUnionPath

struct	LockRowsPath

struct	ModifyTablePath

struct	LimitPath

struct	RestrictInfo

struct	MergeScanSelCache

struct	PlaceHolderVar

struct	SpecialJoinInfo

struct	OuterJoinClauseInfo

struct	AppendRelInfo

struct	RowIdentityVarInfo

struct	PlaceHolderInfo

struct	MinMaxAggInfo

struct	AggClauseInfo

struct	GroupingExprInfo

struct	PlannerParamItem

struct	SemiAntiJoinFactors

struct	JoinPathExtraData

struct	GroupPathExtraData

struct	FinalPathExtraData

struct	JoinCostWorkspace

struct	AggInfo

struct	AggTransInfo

struct	UniqueRelInfo

Macros
#define	PGS_SEQSCAN 0x00000001

#define	PGS_INDEXSCAN 0x00000002

#define	PGS_INDEXONLYSCAN 0x00000004

#define	PGS_BITMAPSCAN 0x00000008

#define	PGS_TIDSCAN 0x00000010

#define	PGS_FOREIGNJOIN 0x00000020

#define	PGS_MERGEJOIN_PLAIN 0x00000040

#define	PGS_MERGEJOIN_MATERIALIZE 0x00000080

#define	PGS_NESTLOOP_PLAIN 0x00000100

#define	PGS_NESTLOOP_MATERIALIZE 0x00000200

#define	PGS_NESTLOOP_MEMOIZE 0x00000400

#define	PGS_HASHJOIN 0x00000800

#define	PGS_APPEND 0x00001000

#define	PGS_MERGE_APPEND 0x00002000

#define	PGS_GATHER 0x00004000

#define	PGS_GATHER_MERGE 0x00008000

#define	PGS_CONSIDER_INDEXONLY 0x00010000

#define	PGS_CONSIDER_PARTITIONWISE 0x00020000

#define	PGS_CONSIDER_NONPARTIAL 0x00040000

#define	PGS_SCAN_ANY

#define	PGS_MERGEJOIN_ANY (PGS_MERGEJOIN_PLAIN \| PGS_MERGEJOIN_MATERIALIZE)

#define	PGS_NESTLOOP_ANY (PGS_NESTLOOP_PLAIN \| PGS_NESTLOOP_MATERIALIZE \| PGS_NESTLOOP_MEMOIZE)

#define	PGS_JOIN_ANY (PGS_FOREIGNJOIN \| PGS_MERGEJOIN_ANY \| PGS_NESTLOOP_ANY \| PGS_HASHJOIN)

#define	planner_subplan_get_plan(root, subplan) ((Plan *) list_nth((root)->glob->subplans, (subplan)->plan_id - 1))

#define	planner_rt_fetch(rti, root)

#define	AMFLAG_HAS_TID_RANGE (1 << 0)

#define	IS_SIMPLE_REL(rel)

#define	IS_JOIN_REL(rel)

#define	IS_UPPER_REL(rel)

#define	IS_OTHER_REL(rel)

#define	IS_PARTITIONED_REL(rel)

#define	REL_HAS_ALL_PART_PROPS(rel)

#define	RELATION_WAS_MADE_UNIQUE(rel, sjinfo, nominal_jointype)

#define	IS_GROUPED_REL(rel) ((rel)->agg_info != NULL)

#define	EC_MUST_BE_REDUNDANT(eclass) ((eclass)->ec_has_const)

#define	get_pathtarget_sortgroupref(target, colno) ((target)->sortgrouprefs ? (target)->sortgrouprefs[colno] : (Index) 0)

#define	PATH_REQ_OUTER(path) ((path)->param_info ? (path)->param_info->ppi_req_outer : (Relids) NULL)

#define	IS_DUMMY_APPEND(p) (IsA((p), AppendPath) && ((AppendPath *) (p))->subpaths == NIL)

#define	IS_DUMMY_REL(r) is_dummy_rel(r)

#define	RINFO_IS_PUSHED_DOWN(rinfo, joinrelids)

#define	GROUPING_CAN_USE_SORT 0x0001

#define	GROUPING_CAN_USE_HASH 0x0002

#define	GROUPING_CAN_PARTIAL_AGG 0x0004

Typedefs
typedef Bitmapset *	Relids

typedef enum CostSelector	CostSelector

typedef struct QualCost	QualCost

typedef struct AggClauseCosts	AggClauseCosts

typedef enum UpperRelationKind	UpperRelationKind

typedef struct PlannerGlobal	PlannerGlobal

typedef struct PlannerInfo	PlannerInfo

typedef struct PartitionSchemeData	PartitionSchemeData

typedef struct PartitionSchemeData *	PartitionScheme

typedef enum RelOptKind	RelOptKind

typedef struct RelOptInfo	RelOptInfo

typedef struct RelAggInfo	RelAggInfo

typedef struct IndexOptInfo	IndexOptInfo

typedef struct ForeignKeyOptInfo	ForeignKeyOptInfo

typedef struct StatisticExtInfo	StatisticExtInfo

typedef struct JoinDomain	JoinDomain

typedef struct EquivalenceClass	EquivalenceClass

typedef struct EquivalenceMember	EquivalenceMember

typedef struct PathKey	PathKey

typedef struct GroupByOrdering	GroupByOrdering

typedef enum VolatileFunctionStatus	VolatileFunctionStatus

typedef struct PathTarget	PathTarget

typedef struct ParamPathInfo	ParamPathInfo

typedef struct Path	Path

typedef struct IndexPath	IndexPath

typedef struct IndexClause	IndexClause

typedef struct BitmapHeapPath	BitmapHeapPath

typedef struct BitmapAndPath	BitmapAndPath

typedef struct BitmapOrPath	BitmapOrPath

typedef struct TidPath	TidPath

typedef struct TidRangePath	TidRangePath

typedef struct SubqueryScanPath	SubqueryScanPath

typedef struct ForeignPath	ForeignPath

typedef struct CustomPath	CustomPath

typedef struct AppendPath	AppendPath

typedef struct MergeAppendPath	MergeAppendPath

typedef struct GroupResultPath	GroupResultPath

typedef struct MaterialPath	MaterialPath

typedef struct MemoizePath	MemoizePath

typedef struct GatherPath	GatherPath

typedef struct GatherMergePath	GatherMergePath

typedef struct JoinPath	JoinPath

typedef struct NestPath	NestPath

typedef struct MergePath	MergePath

typedef struct HashPath	HashPath

typedef struct ProjectionPath	ProjectionPath

typedef struct ProjectSetPath	ProjectSetPath

typedef struct SortPath	SortPath

typedef struct IncrementalSortPath	IncrementalSortPath

typedef struct GroupPath	GroupPath

typedef struct UniquePath	UniquePath

typedef struct AggPath	AggPath

typedef struct GroupingSetData	GroupingSetData

typedef struct RollupData	RollupData

typedef struct GroupingSetsPath	GroupingSetsPath

typedef struct MinMaxAggPath	MinMaxAggPath

typedef struct WindowAggPath	WindowAggPath

typedef struct SetOpPath	SetOpPath

typedef struct RecursiveUnionPath	RecursiveUnionPath

typedef struct LockRowsPath	LockRowsPath

typedef struct ModifyTablePath	ModifyTablePath

typedef struct LimitPath	LimitPath

typedef struct RestrictInfo	RestrictInfo

typedef struct MergeScanSelCache	MergeScanSelCache

typedef struct PlaceHolderVar	PlaceHolderVar

typedef struct SpecialJoinInfo	SpecialJoinInfo

typedef struct OuterJoinClauseInfo	OuterJoinClauseInfo

typedef struct AppendRelInfo	AppendRelInfo

typedef struct RowIdentityVarInfo	RowIdentityVarInfo

typedef struct PlaceHolderInfo	PlaceHolderInfo

typedef struct MinMaxAggInfo	MinMaxAggInfo

typedef struct AggClauseInfo	AggClauseInfo

typedef struct GroupingExprInfo	GroupingExprInfo

typedef struct PlannerParamItem	PlannerParamItem

typedef struct SemiAntiJoinFactors	SemiAntiJoinFactors

typedef struct JoinPathExtraData	JoinPathExtraData

typedef struct JoinCostWorkspace	JoinCostWorkspace

typedef struct AggInfo	AggInfo

typedef struct AggTransInfo	AggTransInfo

typedef struct UniqueRelInfo	UniqueRelInfo

Enumerations
enum	CostSelector { STARTUP_COST , TOTAL_COST }

enum	UpperRelationKind { UPPERREL_SETOP , UPPERREL_PARTIAL_GROUP_AGG , UPPERREL_GROUP_AGG , UPPERREL_WINDOW , UPPERREL_PARTIAL_DISTINCT , UPPERREL_DISTINCT , UPPERREL_ORDERED , UPPERREL_FINAL }

enum	RelOptKind { RELOPT_BASEREL , RELOPT_JOINREL , RELOPT_OTHER_MEMBER_REL , RELOPT_OTHER_JOINREL , RELOPT_UPPER_REL , RELOPT_OTHER_UPPER_REL }

enum	VolatileFunctionStatus { VOLATILITY_UNKNOWN = 0 , VOLATILITY_VOLATILE , VOLATILITY_NOVOLATILE }

enum	PartitionwiseAggregateType { PARTITIONWISE_AGGREGATE_NONE , PARTITIONWISE_AGGREGATE_FULL , PARTITIONWISE_AGGREGATE_PARTIAL }

Functions
bool	is_dummy_rel (RelOptInfo *rel)

Macro Definition Documentation

◆ AMFLAG_HAS_TID_RANGE

#define AMFLAG_HAS_TID_RANGE (1 << 0)

Definition at line 973 of file pathnodes.h.

◆ EC_MUST_BE_REDUNDANT

#define EC_MUST_BE_REDUNDANT ( eclass ) ((eclass)->ec_has_const)

Definition at line 1684 of file pathnodes.h.

{
    pg_node_attr(no_copy_equal, no_read, no_query_jumble)
 
    NodeTag     type;
 
    Expr       *em_expr;        /* the expression represented */
    Relids      em_relids;      /* all relids appearing in em_expr */
    bool        em_is_const;    /* expression is pseudoconstant? */
    bool        em_is_child;    /* derived version for a child relation? */
    Oid         em_datatype;    /* the "nominal type" used by the opfamily */
    JoinDomain *em_jdomain;     /* join domain containing the source clause */
    /* if em_is_child is true, this links to corresponding EM for top parent */
    struct EquivalenceMember *em_parent pg_node_attr(read_write_ignore);
} EquivalenceMember;
 
/*
 * EquivalenceMemberIterator
 *
 * EquivalenceMemberIterator allows efficient access to sets of
 * EquivalenceMembers for callers which require access to child members.
 * Because partitioning workloads can result in large numbers of child
 * members, the child members are not stored in the EquivalenceClass's
 * ec_members List.  Instead, these are stored in the EquivalenceClass's
 * ec_childmembers array of Lists.  The functionality provided by
 * EquivalenceMemberIterator aims to provide efficient access to parent
 * members and child members belonging to specific child relids.
 *
 * Currently, there is only one way to initialize and iterate over an
 * EquivalenceMemberIterator and that is via the setup_eclass_member_iterator
 * and eclass_member_iterator_next functions.  The iterator object is
 * generally a local variable which is passed by address to
 * setup_eclass_member_iterator.  The calling function defines which
 * EquivalenceClass the iterator should be looking at and which child
 * relids to also return members for.  child_relids can be passed as NULL, but
 * the caller may as well just perform a foreach loop over ec_members as only
 * parent-level members will be returned in that case.
 *
 * When calling the next function on an EquivalenceMemberIterator, all
 * parent-level EquivalenceMembers are returned first, followed by all child
 * members for the specified 'child_relids' for all child members which were
 * indexed by any of the specified 'child_relids' in add_child_eq_member().
 *
 * Code using the iterator method of finding EquivalenceMembers will generally
 * always want to ensure the returned member matches their search criteria
 * rather than relying on the filtering to be done for them as all parent
 * members are returned and for members belonging to RELOPT_OTHER_JOINREL
 * rels, the member's em_relids may be a superset of the specified
 * 'child_relids', which might not be what the caller wants.
 *
 * The most common way to use this iterator is as follows:
 * -----
 * EquivalenceMemberIterator        it;
 * EquivalenceMember               *em;
 *
 * setup_eclass_member_iterator(&it, ec, child_relids);
 * while ((em = eclass_member_iterator_next(&it)) != NULL)
 * {
 *      ...
 * }
 * -----
 * It is not valid to call eclass_member_iterator_next() after it has returned
 * NULL for any given EquivalenceMemberIterator.  Individual fields within
 * the EquivalenceMemberIterator struct must not be accessed by callers.
 */
typedef struct
{
    EquivalenceClass *ec;       /* The EquivalenceClass to iterate over */
    int         current_relid;  /* Current relid position within 'relids'. -1
                                 * when still looping over ec_members and -2
                                 * at the end of iteration */
    Relids      child_relids;   /* Relids of child relations of interest.
                                 * Non-child rels are ignored */
    ListCell   *current_cell;   /* Next cell to return within current_list */
    List       *current_list;   /* Current list of members being returned */
} EquivalenceMemberIterator;
 
/*
 * PathKeys
 *
 * The sort ordering of a path is represented by a list of PathKey nodes.
 * An empty list implies no known ordering.  Otherwise the first item
 * represents the primary sort key, the second the first secondary sort key,
 * etc.  The value being sorted is represented by linking to an
 * EquivalenceClass containing that value and including pk_opfamily among its
 * ec_opfamilies.  The EquivalenceClass tells which collation to use, too.
 * This is a convenient method because it makes it trivial to detect
 * equivalent and closely-related orderings. (See optimizer/README for more
 * information.)
 *
 * Note: pk_cmptype is either COMPARE_LT (for ASC) or COMPARE_GT (for DESC).
 */
typedef struct PathKey
{
    pg_node_attr(no_read, no_query_jumble)
 
    NodeTag     type;
 
    /* the value that is ordered */
    EquivalenceClass *pk_eclass pg_node_attr(copy_as_scalar, equal_as_scalar);
    Oid         pk_opfamily;    /* index opfamily defining the ordering */
    CompareType pk_cmptype;     /* sort direction (ASC or DESC) */
    bool        pk_nulls_first; /* do NULLs come before normal values? */
} PathKey;
 
/*
 * Contains an order of group-by clauses and the corresponding list of
 * pathkeys.
 *
 * The elements of 'clauses' list should have the same order as the head of
 * 'pathkeys' list.  The tleSortGroupRef of the clause should be equal to
 * ec_sortref of the pathkey equivalence class.  If there are redundant
 * clauses with the same tleSortGroupRef, they must be grouped together.
 */
typedef struct GroupByOrdering
{
    NodeTag     type;
 
    List       *pathkeys;
    List       *clauses;
} GroupByOrdering;
 
/*
 * VolatileFunctionStatus -- allows nodes to cache their
 * contain_volatile_functions properties. VOLATILITY_UNKNOWN means not yet
 * determined.
 */
typedef enum VolatileFunctionStatus
{
    VOLATILITY_UNKNOWN = 0,
    VOLATILITY_VOLATILE,
    VOLATILITY_NOVOLATILE,
} VolatileFunctionStatus;
 
/*
 * PathTarget
 *
 * This struct contains what we need to know during planning about the
 * targetlist (output columns) that a Path will compute.  Each RelOptInfo
 * includes a default PathTarget, which its individual Paths may simply
 * reference.  However, in some cases a Path may compute outputs different
 * from other Paths, and in that case we make a custom PathTarget for it.
 * For example, an indexscan might return index expressions that would
 * otherwise need to be explicitly calculated.  (Note also that "upper"
 * relations generally don't have useful default PathTargets.)
 *
 * exprs contains bare expressions; they do not have TargetEntry nodes on top,
 * though those will appear in finished Plans.
 *
 * sortgrouprefs[] is an array of the same length as exprs, containing the
 * corresponding sort/group refnos, or zeroes for expressions not referenced
 * by sort/group clauses.  If sortgrouprefs is NULL (which it generally is in
 * RelOptInfo.reltarget targets; only upper-level Paths contain this info),
 * we have not identified sort/group columns in this tlist.  This allows us to
 * deal with sort/group refnos when needed with less expense than including
 * TargetEntry nodes in the exprs list.
 */
typedef struct PathTarget
{
    pg_node_attr(no_copy_equal, no_read, no_query_jumble)
 
    NodeTag     type;
 
    /* list of expressions to be computed */
    List       *exprs;
 
    /* corresponding sort/group refnos, or 0 */
    Index      *sortgrouprefs pg_node_attr(array_size(exprs));
 
    /* cost of evaluating the expressions */
    QualCost    cost;
 
    /* estimated avg width of result tuples */
    int         width;
 
    /* indicates if exprs contain any volatile functions */
    VolatileFunctionStatus has_volatile_expr;
} PathTarget;
 
/* Convenience macro to get a sort/group refno from a PathTarget */
#define get_pathtarget_sortgroupref(target, colno) \
    ((target)->sortgrouprefs ? (target)->sortgrouprefs[colno] : (Index) 0)
 
 
/*
 * ParamPathInfo
 *
 * All parameterized paths for a given relation with given required outer rels
 * link to a single ParamPathInfo, which stores common information such as
 * the estimated rowcount for this parameterization.  We do this partly to
 * avoid recalculations, but mostly to ensure that the estimated rowcount
 * is in fact the same for every such path.
 *
 * Note: ppi_clauses is only used in ParamPathInfos for base relation paths;
 * in join cases it's NIL because the set of relevant clauses varies depending
 * on how the join is formed.  The relevant clauses will appear in each
 * parameterized join path's joinrestrictinfo list, instead.  ParamPathInfos
 * for append relations don't bother with this, either.
 *
 * ppi_serials is the set of rinfo_serial numbers for quals that are enforced
 * by this path.  As with ppi_clauses, it's only maintained for baserels.
 * (We could construct it on-the-fly from ppi_clauses, but it seems better
 * to materialize a copy.)
 */
typedef struct ParamPathInfo
{
    pg_node_attr(no_copy_equal, no_read, no_query_jumble)
 
    NodeTag     type;
 
    Relids      ppi_req_outer;  /* rels supplying parameters used by path */
    Cardinality ppi_rows;       /* estimated number of result tuples */
    List       *ppi_clauses;    /* join clauses available from outer rels */
    Bitmapset  *ppi_serials;    /* set of rinfo_serial for enforced quals */
} ParamPathInfo;
 
 
/*
 * Type "Path" is used as-is for sequential-scan paths, as well as some other
 * simple plan types that we don't need any extra information in the path for.
 * For other path types it is the first component of a larger struct.
 *
 * "pathtype" is the NodeTag of the Plan node we could build from this Path.
 * It is partially redundant with the Path's NodeTag, but allows us to use
 * the same Path type for multiple Plan types when there is no need to
 * distinguish the Plan type during path processing.
 *
 * "parent" identifies the relation this Path scans, and "pathtarget"
 * describes the precise set of output columns the Path would compute.
 * In simple cases all Paths for a given rel share the same targetlist,
 * which we represent by having path->pathtarget equal to parent->reltarget.
 *
 * "param_info", if not NULL, links to a ParamPathInfo that identifies outer
 * relation(s) that provide parameter values to each scan of this path.
 * That means this path can only be joined to those rels by means of nestloop
 * joins with this path on the inside.  Also note that a parameterized path
 * is responsible for testing all "movable" joinclauses involving this rel
 * and the specified outer rel(s).
 *
 * "rows" is the same as parent->rows in simple paths, but in parameterized
 * paths it can be less than parent->rows, reflecting the fact that we've
 * filtered by extra join conditions.
 *
 * "pathkeys" is a List of PathKey nodes (see above), describing the sort
 * ordering of the path's output rows.
 *
 * We do not support copying Path trees, mainly because the circular linkages
 * between RelOptInfo and Path nodes can't be handled easily in a simple
 * depth-first traversal.  We also don't have read support at the moment.
 */
typedef struct Path
{
    pg_node_attr(no_copy_equal, no_read, no_query_jumble)
 
    NodeTag     type;
 
    /* tag identifying scan/join method */
    NodeTag     pathtype;
 
    /*
     * the relation this path can build
     *
     * We do NOT print the parent, else we'd be in infinite recursion.  We can
     * print the parent's relids for identification purposes, though.
     */
    RelOptInfo *parent pg_node_attr(write_only_relids);
 
    /*
     * list of Vars/Exprs, cost, width
     *
     * We print the pathtarget only if it's not the default one for the rel.
     */
    PathTarget *pathtarget pg_node_attr(write_only_nondefault_pathtarget);
 
    /*
     * parameterization info, or NULL if none
     *
     * We do not print the whole of param_info, since it's printed via
     * RelOptInfo; it's sufficient and less cluttering to print just the
     * required outer relids.
     */
    ParamPathInfo *param_info pg_node_attr(write_only_req_outer);
 
    /* engage parallel-aware logic? */
    bool        parallel_aware;
    /* OK to use as part of parallel plan? */
    bool        parallel_safe;
    /* desired # of workers; 0 = not parallel */
    int         parallel_workers;
 
    /* estimated size/costs for path (see costsize.c for more info) */
    Cardinality rows;           /* estimated number of result tuples */
    int         disabled_nodes; /* count of disabled nodes */
    Cost        startup_cost;   /* cost expended before fetching any tuples */
    Cost        total_cost;     /* total cost (assuming all tuples fetched) */
 
    /* sort ordering of path's output; a List of PathKey nodes; see above */
    List       *pathkeys;
} Path;
 
/* Macro for extracting a path's parameterization relids; beware double eval */
#define PATH_REQ_OUTER(path)  \
    ((path)->param_info ? (path)->param_info->ppi_req_outer : (Relids) NULL)
 
/*----------
 * IndexPath represents an index scan over a single index.
 *
 * This struct is used for both regular indexscans and index-only scans;
 * path.pathtype is T_IndexScan or T_IndexOnlyScan to show which is meant.
 *
 * 'indexinfo' is the index to be scanned.
 *
 * 'indexclauses' is a list of IndexClause nodes, each representing one
 * index-checkable restriction, with implicit AND semantics across the list.
 * An empty list implies a full index scan.
 *
 * 'indexorderbys', if not NIL, is a list of ORDER BY expressions that have
 * been found to be usable as ordering operators for an amcanorderbyop index.
 * The list must match the path's pathkeys, ie, one expression per pathkey
 * in the same order.  These are not RestrictInfos, just bare expressions,
 * since they generally won't yield booleans.  It's guaranteed that each
 * expression has the index key on the left side of the operator.
 *
 * 'indexorderbycols' is an integer list of index column numbers (zero-based)
 * of the same length as 'indexorderbys', showing which index column each
 * ORDER BY expression is meant to be used with.  (There is no restriction
 * on which index column each ORDER BY can be used with.)
 *
 * 'indexscandir' is one of:
 *      ForwardScanDirection: forward scan of an index
 *      BackwardScanDirection: backward scan of an ordered index
 * Unordered indexes will always have an indexscandir of ForwardScanDirection.
 *
 * 'indextotalcost' and 'indexselectivity' are saved in the IndexPath so that
 * we need not recompute them when considering using the same index in a
 * bitmap index/heap scan (see BitmapHeapPath).  The costs of the IndexPath
 * itself represent the costs of an IndexScan or IndexOnlyScan plan type.
 *----------
 */
typedef struct IndexPath
{
    Path        path;
    IndexOptInfo *indexinfo;
    List       *indexclauses;
    List       *indexorderbys;
    List       *indexorderbycols;
    ScanDirection indexscandir;
    Cost        indextotalcost;
    Selectivity indexselectivity;
} IndexPath;
 
/*
 * Each IndexClause references a RestrictInfo node from the query's WHERE
 * or JOIN conditions, and shows how that restriction can be applied to
 * the particular index.  We support both indexclauses that are directly
 * usable by the index machinery, which are typically of the form
 * "indexcol OP pseudoconstant", and those from which an indexable qual
 * can be derived.  The simplest such transformation is that a clause
 * of the form "pseudoconstant OP indexcol" can be commuted to produce an
 * indexable qual (the index machinery expects the indexcol to be on the
 * left always).  Another example is that we might be able to extract an
 * indexable range condition from a LIKE condition, as in "x LIKE 'foo%bar'"
 * giving rise to "x >= 'foo' AND x < 'fop'".  Derivation of such lossy
 * conditions is done by a planner support function attached to the
 * indexclause's top-level function or operator.
 *
 * indexquals is a list of RestrictInfos for the directly-usable index
 * conditions associated with this IndexClause.  In the simplest case
 * it's a one-element list whose member is iclause->rinfo.  Otherwise,
 * it contains one or more directly-usable indexqual conditions extracted
 * from the given clause.  The 'lossy' flag indicates whether the
 * indexquals are semantically equivalent to the original clause, or
 * represent a weaker condition.
 *
 * Normally, indexcol is the index of the single index column the clause
 * works on, and indexcols is NIL.  But if the clause is a RowCompareExpr,
 * indexcol is the index of the leading column, and indexcols is a list of
 * all the affected columns.  (Note that indexcols matches up with the
 * columns of the actual indexable RowCompareExpr in indexquals, which
 * might be different from the original in rinfo.)
 *
 * An IndexPath's IndexClause list is required to be ordered by index
 * column, i.e. the indexcol values must form a nondecreasing sequence.
 * (The order of multiple clauses for the same index column is unspecified.)
 */
typedef struct IndexClause
{
    pg_node_attr(no_copy_equal, no_read, no_query_jumble)
 
    NodeTag     type;
    struct RestrictInfo *rinfo; /* original restriction or join clause */
    List       *indexquals;     /* indexqual(s) derived from it */
    bool        lossy;          /* are indexquals a lossy version of clause? */
    AttrNumber  indexcol;       /* index column the clause uses (zero-based) */
    List       *indexcols;      /* multiple index columns, if RowCompare */
} IndexClause;
 
/*
 * BitmapHeapPath represents one or more indexscans that generate TID bitmaps
 * instead of directly accessing the heap, followed by AND/OR combinations
 * to produce a single bitmap, followed by a heap scan that uses the bitmap.
 * Note that the output is always considered unordered, since it will come
 * out in physical heap order no matter what the underlying indexes did.
 *
 * The individual indexscans are represented by IndexPath nodes, and any
 * logic on top of them is represented by a tree of BitmapAndPath and
 * BitmapOrPath nodes.  Notice that we can use the same IndexPath node both
 * to represent a regular (or index-only) index scan plan, and as the child
 * of a BitmapHeapPath that represents scanning the same index using a
 * BitmapIndexScan.  The startup_cost and total_cost figures of an IndexPath
 * always represent the costs to use it as a regular (or index-only)
 * IndexScan.  The costs of a BitmapIndexScan can be computed using the
 * IndexPath's indextotalcost and indexselectivity.
 */
typedef struct BitmapHeapPath
{
    Path        path;
    Path       *bitmapqual;     /* IndexPath, BitmapAndPath, BitmapOrPath */
} BitmapHeapPath;
 
/*
 * BitmapAndPath represents a BitmapAnd plan node; it can only appear as
 * part of the substructure of a BitmapHeapPath.  The Path structure is
 * a bit more heavyweight than we really need for this, but for simplicity
 * we make it a derivative of Path anyway.
 */
typedef struct BitmapAndPath
{
    Path        path;
    List       *bitmapquals;    /* IndexPaths and BitmapOrPaths */
    Selectivity bitmapselectivity;
} BitmapAndPath;
 
/*
 * BitmapOrPath represents a BitmapOr plan node; it can only appear as
 * part of the substructure of a BitmapHeapPath.  The Path structure is
 * a bit more heavyweight than we really need for this, but for simplicity
 * we make it a derivative of Path anyway.
 */
typedef struct BitmapOrPath
{
    Path        path;
    List       *bitmapquals;    /* IndexPaths and BitmapAndPaths */
    Selectivity bitmapselectivity;
} BitmapOrPath;
 
/*
 * TidPath represents a scan by TID
 *
 * tidquals is an implicitly OR'ed list of qual expressions of the form
 * "CTID = pseudoconstant", or "CTID = ANY(pseudoconstant_array)",
 * or a CurrentOfExpr for the relation.
 */
typedef struct TidPath
{
    Path        path;
    List       *tidquals;       /* qual(s) involving CTID = something */
} TidPath;
 
/*
 * TidRangePath represents a scan by a contiguous range of TIDs
 *
 * tidrangequals is an implicitly AND'ed list of qual expressions of the form
 * "CTID relop pseudoconstant", where relop is one of >,>=,<,<=.
 */
typedef struct TidRangePath
{
    Path        path;
    List       *tidrangequals;
} TidRangePath;
 
/*
 * SubqueryScanPath represents a scan of an unflattened subquery-in-FROM
 *
 * Note that the subpath comes from a different planning domain; for example
 * RTE indexes within it mean something different from those known to the
 * SubqueryScanPath.  path.parent->subroot is the planning context needed to
 * interpret the subpath.
 */
typedef struct SubqueryScanPath
{
    Path        path;
    Path       *subpath;        /* path representing subquery execution */
} SubqueryScanPath;
 
/*
 * ForeignPath represents a potential scan of a foreign table, foreign join
 * or foreign upper-relation.
 *
 * In the case of a foreign join, fdw_restrictinfo stores the RestrictInfos to
 * apply to the join, which are used by createplan.c to get pseudoconstant
 * clauses evaluated as one-time quals in a gating Result plan node.
 *
 * fdw_private stores FDW private data about the scan.  While fdw_private is
 * not actually touched by the core code during normal operations, it's
 * generally a good idea to use a representation that can be dumped by
 * nodeToString(), so that you can examine the structure during debugging
 * with tools like pprint().
 */
typedef struct ForeignPath
{
    Path        path;
    Path       *fdw_outerpath;
    List       *fdw_restrictinfo;
    List       *fdw_private;
} ForeignPath;
 
/*
 * CustomPath represents a table scan or a table join done by some out-of-core
 * extension.
 *
 * We provide a set of hooks here - which the provider must take care to set
 * up correctly - to allow extensions to supply their own methods of scanning
 * a relation or join relations.  For example, a provider might provide GPU
 * acceleration, a cache-based scan, or some other kind of logic we haven't
 * dreamed up yet.
 *
 * CustomPaths can be injected into the planning process for a base or join
 * relation by set_rel_pathlist_hook or set_join_pathlist_hook functions,
 * respectively.
 *
 * In the case of a table join, custom_restrictinfo stores the RestrictInfos
 * to apply to the join, which are used by createplan.c to get pseudoconstant
 * clauses evaluated as one-time quals in a gating Result plan node.
 *
 * Core code must avoid assuming that the CustomPath is only as large as
 * the structure declared here; providers are allowed to make it the first
 * element in a larger structure.  (Since the planner never copies Paths,
 * this doesn't add any complication.)  However, for consistency with the
 * FDW case, we provide a "custom_private" field in CustomPath; providers
 * may prefer to use that rather than define another struct type.
 */
 
struct CustomPathMethods;
 
typedef struct CustomPath
{
    Path        path;
    uint32      flags;          /* mask of CUSTOMPATH_* flags, see
                                 * nodes/extensible.h */
    List       *custom_paths;   /* list of child Path nodes, if any */
    List       *custom_restrictinfo;
    List       *custom_private;
    const struct CustomPathMethods *methods;
} CustomPath;
 
/*
 * AppendPath represents an Append plan, ie, successive execution of
 * several member plans.
 *
 * For partial Append, 'subpaths' contains non-partial subpaths followed by
 * partial subpaths.
 *
 * Whenever accumulate_append_subpath() allows us to consolidate multiple
 * levels of Append paths down to one, we store the RTI sets for the omitted
 * paths in child_append_relid_sets. This is not necessary for planning or
 * execution; we do it for the benefit of code that wants to inspect the
 * final plan and understand how it came to be.
 *
 * Note: it is possible for "subpaths" to contain only one, or even no,
 * elements.  These cases are optimized during create_append_plan.
 * In particular, an AppendPath with no subpaths is a "dummy" path that
 * is created to represent the case that a relation is provably empty.
 * (This is a convenient representation because it means that when we build
 * an appendrel and find that all its children have been excluded, no extra
 * action is needed to recognize the relation as dummy.)
 */
typedef struct AppendPath
{
    Path        path;
    List       *subpaths;       /* list of component Paths */
    /* Index of first partial path in subpaths; list_length(subpaths) if none */
    int         first_partial_path;
    Cardinality limit_tuples;   /* hard limit on output tuples, or -1 */
    List       *child_append_relid_sets;
} AppendPath;
 
#define IS_DUMMY_APPEND(p) \
    (IsA((p), AppendPath) && ((AppendPath *) (p))->subpaths == NIL)
 
/*
 * A relation that's been proven empty will have one path that is dummy
 * (but might have projection paths on top).  For historical reasons,
 * this is provided as a macro that wraps is_dummy_rel().
 */
#define IS_DUMMY_REL(r) is_dummy_rel(r)
extern bool is_dummy_rel(RelOptInfo *rel);
 
/*
 * MergeAppendPath represents a MergeAppend plan, ie, the merging of sorted
 * results from several member plans to produce similarly-sorted output.
 *
 * child_append_relid_sets has the same meaning here as for AppendPath.
 */
typedef struct MergeAppendPath
{
    Path        path;
    List       *subpaths;       /* list of component Paths */
    Cardinality limit_tuples;   /* hard limit on output tuples, or -1 */
    List       *child_append_relid_sets;
} MergeAppendPath;
 
/*
 * GroupResultPath represents use of a Result plan node to compute the
 * output of a degenerate GROUP BY case, wherein we know we should produce
 * exactly one row, which might then be filtered by a HAVING qual.
 *
 * Note that quals is a list of bare clauses, not RestrictInfos.
 */
typedef struct GroupResultPath
{
    Path        path;
    List       *quals;
} GroupResultPath;
 
/*
 * MaterialPath represents use of a Material plan node, i.e., caching of
 * the output of its subpath.  This is used when the subpath is expensive
 * and needs to be scanned repeatedly, or when we need mark/restore ability
 * and the subpath doesn't have it.
 */
typedef struct MaterialPath
{
    Path        path;
    Path       *subpath;
} MaterialPath;
 
/*
 * MemoizePath represents a Memoize plan node, i.e., a cache that caches
 * tuples from parameterized paths to save the underlying node from having to
 * be rescanned for parameter values which are already cached.
 */
typedef struct MemoizePath
{
    Path        path;
    Path       *subpath;        /* outerpath to cache tuples from */
    List       *hash_operators; /* OIDs of hash equality ops for cache keys */
    List       *param_exprs;    /* expressions that are cache keys */
    bool        singlerow;      /* true if the cache entry is to be marked as
                                 * complete after caching the first record. */
    bool        binary_mode;    /* true when cache key should be compared bit
                                 * by bit, false when using hash equality ops */
    uint32      est_entries;    /* The maximum number of entries that the
                                 * planner expects will fit in the cache, or 0
                                 * if unknown */
    Cardinality est_calls;      /* expected number of rescans */
    Cardinality est_unique_keys;    /* estimated unique keys, for EXPLAIN */
    double      est_hit_ratio;  /* estimated cache hit ratio, for EXPLAIN */
} MemoizePath;
 
/*
 * GatherPath runs several copies of a plan in parallel and collects the
 * results.  The parallel leader may also execute the plan, unless the
 * single_copy flag is set.
 */
typedef struct GatherPath
{
    Path        path;
    Path       *subpath;        /* path for each worker */
    bool        single_copy;    /* don't execute path more than once */
    int         num_workers;    /* number of workers sought to help */
} GatherPath;
 
/*
 * GatherMergePath runs several copies of a plan in parallel and collects
 * the results, preserving their common sort order.
 */
typedef struct GatherMergePath
{
    Path        path;
    Path       *subpath;        /* path for each worker */
    int         num_workers;    /* number of workers sought to help */
} GatherMergePath;
 
 
/*
 * All join-type paths share these fields.
 */
 
typedef struct JoinPath
{
    pg_node_attr(abstract)
 
    Path        path;
 
    JoinType    jointype;
 
    bool        inner_unique;   /* each outer tuple provably matches no more
                                 * than one inner tuple */
 
    Path       *outerjoinpath;  /* path for the outer side of the join */
    Path       *innerjoinpath;  /* path for the inner side of the join */
 
    List       *joinrestrictinfo;   /* RestrictInfos to apply to join */
 
    /*
     * See the notes for RelOptInfo and ParamPathInfo to understand why
     * joinrestrictinfo is needed in JoinPath, and can't be merged into the
     * parent RelOptInfo.
     */
} JoinPath;
 
/*
 * A nested-loop path needs no special fields.
 */
 
typedef struct NestPath
{
    JoinPath    jpath;
} NestPath;
 
/*
 * A mergejoin path has these fields.
 *
 * Unlike other path types, a MergePath node doesn't represent just a single
 * run-time plan node: it can represent up to four.  Aside from the MergeJoin
 * node itself, there can be a Sort node for the outer input, a Sort node
 * for the inner input, and/or a Material node for the inner input.  We could
 * represent these nodes by separate path nodes, but considering how many
 * different merge paths are investigated during a complex join problem,
 * it seems better to avoid unnecessary palloc overhead.
 *
 * path_mergeclauses lists the clauses (in the form of RestrictInfos)
 * that will be used in the merge.
 *
 * Note that the mergeclauses are a subset of the parent relation's
 * restriction-clause list.  Any join clauses that are not mergejoinable
 * appear only in the parent's restrict list, and must be checked by a
 * qpqual at execution time.
 *
 * outersortkeys (resp. innersortkeys) is NIL if the outer path
 * (resp. inner path) is already ordered appropriately for the
 * mergejoin.  If it is not NIL then it is a PathKeys list describing
 * the ordering that must be created by an explicit Sort node.
 *
 * outer_presorted_keys is the number of presorted keys of the outer
 * path that match outersortkeys.  It is used to determine whether
 * explicit incremental sort can be applied when outersortkeys is not
 * NIL.  We do not track the number of presorted keys of the inner
 * path, as incremental sort currently does not support mark/restore.
 *
 * skip_mark_restore is true if the executor need not do mark/restore calls.
 * Mark/restore overhead is usually required, but can be skipped if we know
 * that the executor need find only one match per outer tuple, and that the
 * mergeclauses are sufficient to identify a match.  In such cases the
 * executor can immediately advance the outer relation after processing a
 * match, and therefore it need never back up the inner relation.
 *
 * materialize_inner is true if a Material node should be placed atop the
 * inner input.  This may appear with or without an inner Sort step.
 */
 
typedef struct MergePath
{
    JoinPath    jpath;
    List       *path_mergeclauses;  /* join clauses to be used for merge */
    List       *outersortkeys;  /* keys for explicit sort, if any */
    List       *innersortkeys;  /* keys for explicit sort, if any */
    int         outer_presorted_keys;   /* number of presorted keys of the
                                         * outer path */
    bool        skip_mark_restore;  /* can executor skip mark/restore? */
    bool        materialize_inner;  /* add Materialize to inner? */
} MergePath;
 
/*
 * A hashjoin path has these fields.
 *
 * The remarks above for mergeclauses apply for hashclauses as well.
 *
 * Hashjoin does not care what order its inputs appear in, so we have
 * no need for sortkeys.
 */
 
typedef struct HashPath
{
    JoinPath    jpath;
    List       *path_hashclauses;   /* join clauses used for hashing */
    int         num_batches;    /* number of batches expected */
    Cardinality inner_rows_total;   /* total inner rows expected */
} HashPath;
 
/*
 * ProjectionPath represents a projection (that is, targetlist computation)
 *
 * Nominally, this path node represents using a Result plan node to do a
 * projection step.  However, if the input plan node supports projection,
 * we can just modify its output targetlist to do the required calculations
 * directly, and not need a Result.  In some places in the planner we can just
 * jam the desired PathTarget into the input path node (and adjust its cost
 * accordingly), so we don't need a ProjectionPath.  But in other places
 * it's necessary to not modify the input path node, so we need a separate
 * ProjectionPath node, which is marked dummy to indicate that we intend to
 * assign the work to the input plan node.  The estimated cost for the
 * ProjectionPath node will account for whether a Result will be used or not.
 */
typedef struct ProjectionPath
{
    Path        path;
    Path       *subpath;        /* path representing input source */
    bool        dummypp;        /* true if no separate Result is needed */
} ProjectionPath;
 
/*
 * ProjectSetPath represents evaluation of a targetlist that includes
 * set-returning function(s), which will need to be implemented by a
 * ProjectSet plan node.
 */
typedef struct ProjectSetPath
{
    Path        path;
    Path       *subpath;        /* path representing input source */
} ProjectSetPath;
 
/*
 * SortPath represents an explicit sort step
 *
 * The sort keys are, by definition, the same as path.pathkeys.
 *
 * Note: the Sort plan node cannot project, so path.pathtarget must be the
 * same as the input's pathtarget.
 */
typedef struct SortPath
{
    Path        path;
    Path       *subpath;        /* path representing input source */
} SortPath;
 
/*
 * IncrementalSortPath represents an incremental sort step
 *
 * This is like a regular sort, except some leading key columns are assumed
 * to be ordered already.
 */
typedef struct IncrementalSortPath
{
    SortPath    spath;
    int         nPresortedCols; /* number of presorted columns */
} IncrementalSortPath;
 
/*
 * GroupPath represents grouping (of presorted input)
 *
 * groupClause represents the columns to be grouped on; the input path
 * must be at least that well sorted.
 *
 * We can also apply a qual to the grouped rows (equivalent of HAVING)
 */
typedef struct GroupPath
{
    Path        path;
    Path       *subpath;        /* path representing input source */
    List       *groupClause;    /* a list of SortGroupClause's */
    List       *qual;           /* quals (HAVING quals), if any */
} GroupPath;
 
/*
 * UniquePath represents adjacent-duplicate removal (in presorted input)
 *
 * The columns to be compared are the first numkeys columns of the path's
 * pathkeys.  The input is presumed already sorted that way.
 */
typedef struct UniquePath
{
    Path        path;
    Path       *subpath;        /* path representing input source */
    int         numkeys;        /* number of pathkey columns to compare */
} UniquePath;
 
/*
 * AggPath represents generic computation of aggregate functions
 *
 * This may involve plain grouping (but not grouping sets), using either
 * sorted or hashed grouping; for the AGG_SORTED case, the input must be
 * appropriately presorted.
 */
typedef struct AggPath
{
    Path        path;
    Path       *subpath;        /* path representing input source */
    AggStrategy aggstrategy;    /* basic strategy, see nodes.h */
    AggSplit    aggsplit;       /* agg-splitting mode, see nodes.h */
    Cardinality numGroups;      /* estimated number of groups in input */
    uint64      transitionSpace;    /* for pass-by-ref transition data */
    List       *groupClause;    /* a list of SortGroupClause's */
    List       *qual;           /* quals (HAVING quals), if any */
} AggPath;
 
/*
 * Various annotations used for grouping sets in the planner.
 */
 
typedef struct GroupingSetData
{
    pg_node_attr(no_copy_equal, no_read, no_query_jumble)
 
    NodeTag     type;
    List       *set;            /* grouping set as list of sortgrouprefs */
    Cardinality numGroups;      /* est. number of result groups */
} GroupingSetData;
 
typedef struct RollupData
{
    pg_node_attr(no_copy_equal, no_read, no_query_jumble)
 
    NodeTag     type;
    List       *groupClause;    /* applicable subset of parse->groupClause */
    List       *gsets;          /* lists of integer indexes into groupClause */
    List       *gsets_data;     /* list of GroupingSetData */
    Cardinality numGroups;      /* est. number of result groups */
    bool        hashable;       /* can be hashed */
    bool        is_hashed;      /* to be implemented as a hashagg */
} RollupData;
 
/*
 * GroupingSetsPath represents a GROUPING SETS aggregation
 */
 
typedef struct GroupingSetsPath
{
    Path        path;
    Path       *subpath;        /* path representing input source */
    AggStrategy aggstrategy;    /* basic strategy */
    List       *rollups;        /* list of RollupData */
    List       *qual;           /* quals (HAVING quals), if any */
    uint64      transitionSpace;    /* for pass-by-ref transition data */
} GroupingSetsPath;
 
/*
 * MinMaxAggPath represents computation of MIN/MAX aggregates from indexes
 */
typedef struct MinMaxAggPath
{
    Path        path;
    List       *mmaggregates;   /* list of MinMaxAggInfo */
    List       *quals;          /* HAVING quals, if any */
} MinMaxAggPath;
 
/*
 * WindowAggPath represents generic computation of window functions
 */
typedef struct WindowAggPath
{
    Path        path;
    Path       *subpath;        /* path representing input source */
    WindowClause *winclause;    /* WindowClause we'll be using */
    List       *qual;           /* lower-level WindowAgg runconditions */
    List       *runCondition;   /* OpExpr List to short-circuit execution */
    bool        topwindow;      /* false for all apart from the WindowAgg
                                 * that's closest to the root of the plan */
} WindowAggPath;
 
/*
 * SetOpPath represents a set-operation, that is INTERSECT or EXCEPT
 */
typedef struct SetOpPath
{
    Path        path;
    Path       *leftpath;       /* paths representing input sources */
    Path       *rightpath;
    SetOpCmd    cmd;            /* what to do, see nodes.h */
    SetOpStrategy strategy;     /* how to do it, see nodes.h */
    List       *groupList;      /* SortGroupClauses identifying target cols */
    Cardinality numGroups;      /* estimated number of groups in left input */
} SetOpPath;
 
/*
 * RecursiveUnionPath represents a recursive UNION node
 */
typedef struct RecursiveUnionPath
{
    Path        path;
    Path       *leftpath;       /* paths representing input sources */
    Path       *rightpath;
    List       *distinctList;   /* SortGroupClauses identifying target cols */
    int         wtParam;        /* ID of Param representing work table */
    Cardinality numGroups;      /* estimated number of groups in input */
} RecursiveUnionPath;
 
/*
 * LockRowsPath represents acquiring row locks for SELECT FOR UPDATE/SHARE
 */
typedef struct LockRowsPath
{
    Path        path;
    Path       *subpath;        /* path representing input source */
    List       *rowMarks;       /* a list of PlanRowMark's */
    int         epqParam;       /* ID of Param for EvalPlanQual re-eval */
} LockRowsPath;
 
/*
 * ModifyTablePath represents performing INSERT/UPDATE/DELETE/MERGE
 *
 * We represent most things that will be in the ModifyTable plan node
 * literally, except we have a child Path not Plan.  But analysis of the
 * OnConflictExpr is deferred to createplan.c, as is collection of FDW data.
 */
typedef struct ModifyTablePath
{
    Path        path;
    Path       *subpath;        /* Path producing source data */
    CmdType     operation;      /* INSERT, UPDATE, DELETE, or MERGE */
    bool        canSetTag;      /* do we set the command tag/es_processed? */
    Index       nominalRelation;    /* Parent RT index for use of EXPLAIN */
    Index       rootRelation;   /* Root RT index, if partitioned/inherited */
    List       *resultRelations;    /* integer list of RT indexes */
    List       *updateColnosLists;  /* per-target-table update_colnos lists */
    List       *withCheckOptionLists;   /* per-target-table WCO lists */
    List       *returningLists; /* per-target-table RETURNING tlists */
    List       *rowMarks;       /* PlanRowMarks (non-locking only) */
    OnConflictExpr *onconflict; /* ON CONFLICT clause, or NULL */
    ForPortionOfExpr *forPortionOf; /* FOR PORTION OF clause for UPDATE/DELETE */
    int         epqParam;       /* ID of Param for EvalPlanQual re-eval */
    List       *mergeActionLists;   /* per-target-table lists of actions for
                                     * MERGE */
    List       *mergeJoinConditions;    /* per-target-table join conditions
                                         * for MERGE */
} ModifyTablePath;
 
/*
 * LimitPath represents applying LIMIT/OFFSET restrictions
 */
typedef struct LimitPath
{
    Path        path;
    Path       *subpath;        /* path representing input source */
    Node       *limitOffset;    /* OFFSET parameter, or NULL if none */
    Node       *limitCount;     /* COUNT parameter, or NULL if none */
    LimitOption limitOption;    /* FETCH FIRST with ties or exact number */
} LimitPath;
 
 
/*
 * Restriction clause info.
 *
 * We create one of these for each AND sub-clause of a restriction condition
 * (WHERE or JOIN/ON clause).  Since the restriction clauses are logically
 * ANDed, we can use any one of them or any subset of them to filter out
 * tuples, without having to evaluate the rest.  The RestrictInfo node itself
 * stores data used by the optimizer while choosing the best query plan.
 *
 * If a restriction clause references a single base relation, it will appear
 * in the baserestrictinfo list of the RelOptInfo for that base rel.
 *
 * If a restriction clause references more than one base+OJ relation, it will
 * appear in the joininfo list of every RelOptInfo that describes a strict
 * subset of the relations mentioned in the clause.  The joininfo lists are
 * used to drive join tree building by selecting plausible join candidates.
 * The clause cannot actually be applied until we have built a join rel
 * containing all the relations it references, however.
 *
 * When we construct a join rel that includes all the relations referenced
 * in a multi-relation restriction clause, we place that clause into the
 * joinrestrictinfo lists of paths for the join rel, if neither left nor
 * right sub-path includes all relations referenced in the clause.  The clause
 * will be applied at that join level, and will not propagate any further up
 * the join tree.  (Note: the "predicate migration" code was once intended to
 * push restriction clauses up and down the plan tree based on evaluation
 * costs, but it's dead code and is unlikely to be resurrected in the
 * foreseeable future.)
 *
 * Note that in the presence of more than two rels, a multi-rel restriction
 * might reach different heights in the join tree depending on the join
 * sequence we use.  So, these clauses cannot be associated directly with
 * the join RelOptInfo, but must be kept track of on a per-join-path basis.
 *
 * RestrictInfos that represent equivalence conditions (i.e., mergejoinable
 * equalities that are not outerjoin-delayed) are handled a bit differently.
 * Initially we attach them to the EquivalenceClasses that are derived from
 * them.  When we construct a scan or join path, we look through all the
 * EquivalenceClasses and generate derived RestrictInfos representing the
 * minimal set of conditions that need to be checked for this particular scan
 * or join to enforce that all members of each EquivalenceClass are in fact
 * equal in all rows emitted by the scan or join.
 *
 * The clause_relids field lists the base plus outer-join RT indexes that
 * actually appear in the clause.  required_relids lists the minimum set of
 * relids needed to evaluate the clause; while this is often equal to
 * clause_relids, it can be more.  We will add relids to required_relids when
 * we need to force an outer join ON clause to be evaluated exactly at the
 * level of the outer join, which is true except when it is a "degenerate"
 * condition that references only Vars from the nullable side of the join.
 *
 * RestrictInfo nodes contain a flag to indicate whether a qual has been
 * pushed down to a lower level than its original syntactic placement in the
 * join tree would suggest.  If an outer join prevents us from pushing a qual
 * down to its "natural" semantic level (the level associated with just the
 * base rels used in the qual) then we mark the qual with a "required_relids"
 * value including more than just the base rels it actually uses.  By
 * pretending that the qual references all the rels required to form the outer
 * join, we prevent it from being evaluated below the outer join's joinrel.
 * When we do form the outer join's joinrel, we still need to distinguish
 * those quals that are actually in that join's JOIN/ON condition from those
 * that appeared elsewhere in the tree and were pushed down to the join rel
 * because they used no other rels.  That's what the is_pushed_down flag is
 * for; it tells us that a qual is not an OUTER JOIN qual for the set of base
 * rels listed in required_relids.  A clause that originally came from WHERE
 * or an INNER JOIN condition will *always* have its is_pushed_down flag set.
 * It's possible for an OUTER JOIN clause to be marked is_pushed_down too,
 * if we decide that it can be pushed down into the nullable side of the join.
 * In that case it acts as a plain filter qual for wherever it gets evaluated.
 * (In short, is_pushed_down is only false for non-degenerate outer join
 * conditions.  Possibly we should rename it to reflect that meaning?  But
 * see also the comments for RINFO_IS_PUSHED_DOWN, below.)
 *
 * There is also an incompatible_relids field, which is a set of outer-join
 * relids above which we cannot evaluate the clause (because they might null
 * Vars it uses that should not be nulled yet).  In principle this could be
 * filled in any RestrictInfo as the set of OJ relids that appear above the
 * clause and null Vars that it uses.  In practice we only bother to populate
 * it for "clone" clauses, as it's currently only needed to prevent multiple
 * clones of the same clause from being accepted for evaluation at the same
 * join level.
 *
 * There is also an outer_relids field, which is NULL except for outer join
 * clauses; for those, it is the set of relids on the outer side of the
 * clause's outer join.  (These are rels that the clause cannot be applied to
 * in parameterized scans, since pushing it into the join's outer side would
 * lead to wrong answers.)
 *
 * To handle security-barrier conditions efficiently, we mark RestrictInfo
 * nodes with a security_level field, in which higher values identify clauses
 * coming from less-trusted sources.  The exact semantics are that a clause
 * cannot be evaluated before another clause with a lower security_level value
 * unless the first clause is leakproof.  As with outer-join clauses, this
 * creates a reason for clauses to sometimes need to be evaluated higher in
 * the join tree than their contents would suggest; and even at a single plan
 * node, this rule constrains the order of application of clauses.
 *
 * In general, the referenced clause might be arbitrarily complex.  The
 * kinds of clauses we can handle as indexscan quals, mergejoin clauses,
 * or hashjoin clauses are limited (e.g., no volatile functions).  The code
 * for each kind of path is responsible for identifying the restrict clauses
 * it can use and ignoring the rest.  Clauses not implemented by an indexscan,
 * mergejoin, or hashjoin will be placed in the plan qual or joinqual field
 * of the finished Plan node, where they will be enforced by general-purpose
 * qual-expression-evaluation code.  (But we are still entitled to count
 * their selectivity when estimating the result tuple count, if we
 * can guess what it is...)
 *
 * When the referenced clause is an OR clause, we generate a modified copy
 * in which additional RestrictInfo nodes are inserted below the top-level
 * OR/AND structure.  This is a convenience for OR indexscan processing:
 * indexquals taken from either the top level or an OR subclause will have
 * associated RestrictInfo nodes.
 *
 * The can_join flag is set true if the clause looks potentially useful as
 * a merge or hash join clause, that is if it is a binary opclause with
 * nonoverlapping sets of relids referenced in the left and right sides.
 * (Whether the operator is actually merge or hash joinable isn't checked,
 * however.)
 *
 * The pseudoconstant flag is set true if the clause contains no Vars of
 * the current query level and no volatile functions.  Such a clause can be
 * pulled out and used as a one-time qual in a gating Result node.  We keep
 * pseudoconstant clauses in the same lists as other RestrictInfos so that
 * the regular clause-pushing machinery can assign them to the correct join
 * level, but they need to be treated specially for cost and selectivity
 * estimates.  Note that a pseudoconstant clause can never be an indexqual
 * or merge or hash join clause, so it's of no interest to large parts of
 * the planner.
 *
 * When we generate multiple versions of a clause so as to have versions
 * that will work after commuting some left joins per outer join identity 3,
 * we mark the one with the fewest nullingrels bits with has_clone = true,
 * and the rest with is_clone = true.  This allows proper filtering of
 * these redundant clauses, so that we apply only one version of them.
 *
 * When join clauses are generated from EquivalenceClasses, there may be
 * several equally valid ways to enforce join equivalence, of which we need
 * apply only one.  We mark clauses of this kind by setting parent_ec to
 * point to the generating EquivalenceClass.  Multiple clauses with the same
 * parent_ec in the same join are redundant.
 *
 * Most fields are ignored for equality, since they may not be set yet, and
 * should be derivable from the clause anyway.
 *
 * parent_ec, left_ec, right_ec are not printed, lest it lead to infinite
 * recursion in plan tree dump.
 */
 
typedef struct RestrictInfo
{
    pg_node_attr(no_read, no_query_jumble)
 
    NodeTag     type;
 
    /* the represented clause of WHERE or JOIN */
    Expr       *clause;
 
    /* true if clause was pushed down in level */
    bool        is_pushed_down;
 
    /* see comment above */
    bool        can_join pg_node_attr(equal_ignore);
 
    /* see comment above */
    bool        pseudoconstant pg_node_attr(equal_ignore);
 
    /* see comment above */
    bool        has_clone;
    bool        is_clone;
 
    /* true if known to contain no leaked Vars */
    bool        leakproof pg_node_attr(equal_ignore);
 
    /* indicates if clause contains any volatile functions */
    VolatileFunctionStatus has_volatile pg_node_attr(equal_ignore);
 
    /* see comment above */
    Index       security_level;
 
    /* number of base rels in clause_relids */
    int         num_base_rels pg_node_attr(equal_ignore);
 
    /* The relids (varnos+varnullingrels) actually referenced in the clause: */
    Relids      clause_relids pg_node_attr(equal_ignore);
 
    /* The set of relids required to evaluate the clause: */
    Relids      required_relids;
 
    /* Relids above which we cannot evaluate the clause (see comment above) */
    Relids      incompatible_relids;
 
    /* If an outer-join clause, the outer-side relations, else NULL: */
    Relids      outer_relids;
 
    /*
     * Relids in the left/right side of the clause.  These fields are set for
     * any binary opclause.
     */
    Relids      left_relids pg_node_attr(equal_ignore);
    Relids      right_relids pg_node_attr(equal_ignore);
 
    /*
     * Modified clause with RestrictInfos.  This field is NULL unless clause
     * is an OR clause.
     */
    Expr       *orclause pg_node_attr(equal_ignore);
 
    /*----------
     * Serial number of this RestrictInfo.  This is unique within the current
     * PlannerInfo context, with a few critical exceptions:
     * 1. When we generate multiple clones of the same qual condition to
     * cope with outer join identity 3, all the clones get the same serial
     * number.  This reflects that we only want to apply one of them in any
     * given plan.
     * 2. If we manufacture a commuted version of a qual to use as an index
     * condition, it copies the original's rinfo_serial, since it is in
     * practice the same condition.
     * 3. If we reduce a qual to constant-FALSE, the new constant-FALSE qual
     * copies the original's rinfo_serial, since it is in practice the same
     * condition.
     * 4. RestrictInfos made for a child relation copy their parent's
     * rinfo_serial.  Likewise, when an EquivalenceClass makes a derived
     * equality clause for a child relation, it copies the rinfo_serial of
     * the matching equality clause for the parent.  This allows detection
     * of redundant pushed-down equality clauses.
     *----------
     */
    int         rinfo_serial;
 
    /*
     * Generating EquivalenceClass.  This field is NULL unless clause is
     * potentially redundant.
     */
    EquivalenceClass *parent_ec pg_node_attr(copy_as_scalar, equal_ignore, read_write_ignore);
 
    /*
     * cache space for cost and selectivity
     */
 
    /* eval cost of clause; -1 if not yet set */
    QualCost    eval_cost pg_node_attr(equal_ignore);
 
    /* selectivity for "normal" (JOIN_INNER) semantics; -1 if not yet set */
    Selectivity norm_selec pg_node_attr(equal_ignore);
    /* selectivity for outer join semantics; -1 if not yet set */
    Selectivity outer_selec pg_node_attr(equal_ignore);
 
    /*
     * opfamilies containing clause operator; valid if clause is
     * mergejoinable, else NIL
     */
    List       *mergeopfamilies pg_node_attr(equal_ignore);
 
    /*
     * cache space for mergeclause processing; NULL if not yet set
     */
 
    /* EquivalenceClass containing lefthand */
    EquivalenceClass *left_ec pg_node_attr(copy_as_scalar, equal_ignore, read_write_ignore);
    /* EquivalenceClass containing righthand */
    EquivalenceClass *right_ec pg_node_attr(copy_as_scalar, equal_ignore, read_write_ignore);
    /* EquivalenceMember for lefthand */
    EquivalenceMember *left_em pg_node_attr(copy_as_scalar, equal_ignore);
    /* EquivalenceMember for righthand */
    EquivalenceMember *right_em pg_node_attr(copy_as_scalar, equal_ignore);
 
    /*
     * List of MergeScanSelCache structs.  Those aren't Nodes, so hard to
     * copy; instead replace with NIL.  That has the effect that copying will
     * just reset the cache.  Likewise, can't compare or print them.
     */
    List       *scansel_cache pg_node_attr(copy_as(NIL), equal_ignore, read_write_ignore);
 
    /*
     * transient workspace for use while considering a specific join path; T =
     * outer var on left, F = on right
     */
    bool        outer_is_left pg_node_attr(equal_ignore);
 
    /*
     * copy of clause operator; valid if clause is hashjoinable, else
     * InvalidOid
     */
    Oid         hashjoinoperator pg_node_attr(equal_ignore);
 
    /*
     * cache space for hashclause processing; -1 if not yet set
     */
    /* avg bucketsize of left side */
    Selectivity left_bucketsize pg_node_attr(equal_ignore);
    /* avg bucketsize of right side */
    Selectivity right_bucketsize pg_node_attr(equal_ignore);
    /* left side's most common val's freq */
    Selectivity left_mcvfreq pg_node_attr(equal_ignore);
    /* right side's most common val's freq */
    Selectivity right_mcvfreq pg_node_attr(equal_ignore);
 
    /* hash equality operators used for memoize nodes, else InvalidOid */
    Oid         left_hasheqoperator pg_node_attr(equal_ignore);
    Oid         right_hasheqoperator pg_node_attr(equal_ignore);
} RestrictInfo;
 
/*
 * This macro embodies the correct way to test whether a RestrictInfo is
 * "pushed down" to a given outer join, that is, should be treated as a filter
 * clause rather than a join clause at that outer join.  This is certainly so
 * if is_pushed_down is true; but examining that is not sufficient anymore,
 * because outer-join clauses will get pushed down to lower outer joins when
 * we generate a path for the lower outer join that is parameterized by the
 * LHS of the upper one.  We can detect such a clause by noting that its
 * required_relids exceed the scope of the join.
 */
#define RINFO_IS_PUSHED_DOWN(rinfo, joinrelids) \
    ((rinfo)->is_pushed_down || \
     !bms_is_subset((rinfo)->required_relids, joinrelids))
 
/*
 * Since mergejoinscansel() is a relatively expensive function, and would
 * otherwise be invoked many times while planning a large join tree,
 * we go out of our way to cache its results.  Each mergejoinable
 * RestrictInfo carries a list of the specific sort orderings that have
 * been considered for use with it, and the resulting selectivities.
 */
typedef struct MergeScanSelCache
{
    /* Ordering details (cache lookup key) */
    Oid         opfamily;       /* index opfamily defining the ordering */
    Oid         collation;      /* collation for the ordering */
    CompareType cmptype;        /* sort direction (ASC or DESC) */
    bool        nulls_first;    /* do NULLs come before normal values? */
    /* Results */
    Selectivity leftstartsel;   /* first-join fraction for clause left side */
    Selectivity leftendsel;     /* last-join fraction for clause left side */
    Selectivity rightstartsel;  /* first-join fraction for clause right side */
    Selectivity rightendsel;    /* last-join fraction for clause right side */
} MergeScanSelCache;
 
/*
 * Placeholder node for an expression to be evaluated below the top level
 * of a plan tree.  This is used during planning to represent the contained
 * expression.  At the end of the planning process it is replaced by either
 * the contained expression or a Var referring to a lower-level evaluation of
 * the contained expression.  Generally the evaluation occurs below an outer
 * join, and Var references above the outer join might thereby yield NULL
 * instead of the expression value.
 *
 * phrels and phlevelsup correspond to the varno/varlevelsup fields of a
 * plain Var, except that phrels has to be a relid set since the evaluation
 * level of a PlaceHolderVar might be a join rather than a base relation.
 * Likewise, phnullingrels corresponds to varnullingrels.
 *
 * Although the planner treats this as an expression node type, it is not
 * recognized by the parser or executor, so we declare it here rather than
 * in primnodes.h.
 *
 * We intentionally do not compare phexpr.  Two PlaceHolderVars with the
 * same ID and levelsup should be considered equal even if the contained
 * expressions have managed to mutate to different states.  This will
 * happen during final plan construction when there are nested PHVs, since
 * the inner PHV will get replaced by a Param in some copies of the outer
 * PHV.  Another way in which it can happen is that initplan sublinks
 * could get replaced by differently-numbered Params when sublink folding
 * is done.  (The end result of such a situation would be some
 * unreferenced initplans, which is annoying but not really a problem.)
 * On the same reasoning, there is no need to examine phrels.  But we do
 * need to compare phnullingrels, as that represents effects that are
 * external to the original value of the PHV.
 */
 
typedef struct PlaceHolderVar
{
    pg_node_attr(no_query_jumble)
 
    Expr        xpr;
 
    /* the represented expression */
    Expr       *phexpr pg_node_attr(equal_ignore);
 
    /* base+OJ relids syntactically within expr src */
    Relids      phrels pg_node_attr(equal_ignore);
 
    /* RT indexes of outer joins that can null PHV's value */
    Relids      phnullingrels;
 
    /* ID for PHV (unique within planner run) */
    Index       phid;
 
    /* > 0 if PHV belongs to outer query */
    Index       phlevelsup;
} PlaceHolderVar;
 
/*
 * "Special join" info.
 *
 * One-sided outer joins constrain the order of joining partially but not
 * completely.  We flatten such joins into the planner's top-level list of
 * relations to join, but record information about each outer join in a
 * SpecialJoinInfo struct.  These structs are kept in the PlannerInfo node's
 * join_info_list.
 *
 * Similarly, semijoins and antijoins created by flattening IN (subselect)
 * and EXISTS(subselect) clauses create partial constraints on join order.
 * These are likewise recorded in SpecialJoinInfo structs.
 *
 * We make SpecialJoinInfos for FULL JOINs even though there is no flexibility
 * of planning for them, because this simplifies make_join_rel()'s API.
 *
 * min_lefthand and min_righthand are the sets of base+OJ relids that must be
 * available on each side when performing the special join.
 * It is not valid for either min_lefthand or min_righthand to be empty sets;
 * if they were, this would break the logic that enforces join order.
 *
 * syn_lefthand and syn_righthand are the sets of base+OJ relids that are
 * syntactically below this special join.  (These are needed to help compute
 * min_lefthand and min_righthand for higher joins.)
 *
 * jointype is never JOIN_RIGHT; a RIGHT JOIN is handled by switching
 * the inputs to make it a LEFT JOIN.  It's never JOIN_RIGHT_SEMI or
 * JOIN_RIGHT_ANTI either.  So the allowed values of jointype in a
 * join_info_list member are only LEFT, FULL, SEMI, or ANTI.
 *
 * ojrelid is the RT index of the join RTE representing this outer join,
 * if there is one.  It is zero when jointype is INNER or SEMI, and can be
 * zero for jointype ANTI (if the join was transformed from a SEMI join).
 * One use for this field is that when constructing the output targetlist of a
 * join relation that implements this OJ, we add ojrelid to the varnullingrels
 * and phnullingrels fields of nullable (RHS) output columns, so that the
 * output Vars and PlaceHolderVars correctly reflect the nulling that has
 * potentially happened to them.
 *
 * commute_above_l is filled with the relids of syntactically-higher outer
 * joins that have been found to commute with this one per outer join identity
 * 3 (see optimizer/README), when this join is in the LHS of the upper join
 * (so, this is the lower join in the first form of the identity).
 *
 * commute_above_r is filled with the relids of syntactically-higher outer
 * joins that have been found to commute with this one per outer join identity
 * 3, when this join is in the RHS of the upper join (so, this is the lower
 * join in the second form of the identity).
 *
 * commute_below_l is filled with the relids of syntactically-lower outer
 * joins that have been found to commute with this one per outer join identity
 * 3 and are in the LHS of this join (so, this is the upper join in the first
 * form of the identity).
 *
 * commute_below_r is filled with the relids of syntactically-lower outer
 * joins that have been found to commute with this one per outer join identity
 * 3 and are in the RHS of this join (so, this is the upper join in the second
 * form of the identity).
 *
 * lhs_strict is true if the special join's condition cannot succeed when the
 * LHS variables are all NULL (this means that an outer join can commute with
 * upper-level outer joins even if it appears in their RHS).  We don't bother
 * to set lhs_strict for FULL JOINs, however.
 *
 * For a semijoin, we also extract the join operators and their RHS arguments
 * and set semi_operators, semi_rhs_exprs, semi_can_btree, and semi_can_hash.
 * This is done in support of possibly unique-ifying the RHS, so we don't
 * bother unless at least one of semi_can_btree and semi_can_hash can be set
 * true.  (You might expect that this information would be computed during
 * join planning; but it's helpful to have it available during planning of
 * parameterized table scans, so we store it in the SpecialJoinInfo structs.)
 *
 * For purposes of join selectivity estimation, we create transient
 * SpecialJoinInfo structures for regular inner joins; so it is possible
 * to have jointype == JOIN_INNER in such a structure, even though this is
 * not allowed within join_info_list.  We also create transient
 * SpecialJoinInfos with jointype == JOIN_INNER for outer joins, since for
 * cost estimation purposes it is sometimes useful to know the join size under
 * plain innerjoin semantics.  Note that lhs_strict and the semi_xxx fields
 * are not set meaningfully within such structs.
 *
 * We also create transient SpecialJoinInfos for child joins during
 * partitionwise join planning, which are also not present in join_info_list.
 */
typedef struct SpecialJoinInfo
{
    pg_node_attr(no_read, no_query_jumble)
 
    NodeTag     type;
    Relids      min_lefthand;   /* base+OJ relids in minimum LHS for join */
    Relids      min_righthand;  /* base+OJ relids in minimum RHS for join */
    Relids      syn_lefthand;   /* base+OJ relids syntactically within LHS */
    Relids      syn_righthand;  /* base+OJ relids syntactically within RHS */
    JoinType    jointype;       /* always INNER, LEFT, FULL, SEMI, or ANTI */
    Index       ojrelid;        /* outer join's RT index; 0 if none */
    Relids      commute_above_l;    /* commuting OJs above this one, if LHS */
    Relids      commute_above_r;    /* commuting OJs above this one, if RHS */
    Relids      commute_below_l;    /* commuting OJs in this one's LHS */
    Relids      commute_below_r;    /* commuting OJs in this one's RHS */
    bool        lhs_strict;     /* joinclause is strict for some LHS rel */
    /* Remaining fields are set only for JOIN_SEMI jointype: */
    bool        semi_can_btree; /* true if semi_operators are all btree */
    bool        semi_can_hash;  /* true if semi_operators are all hash */
    List       *semi_operators; /* OIDs of equality join operators */
    List       *semi_rhs_exprs; /* righthand-side expressions of these ops */
} SpecialJoinInfo;
 
/*
 * Transient outer-join clause info.
 *
 * We set aside every outer join ON clause that looks mergejoinable,
 * and process it specially at the end of qual distribution.
 */
typedef struct OuterJoinClauseInfo
{
    pg_node_attr(no_copy_equal, no_read, no_query_jumble)
 
    NodeTag     type;
    RestrictInfo *rinfo;        /* a mergejoinable outer-join clause */
    SpecialJoinInfo *sjinfo;    /* the outer join's SpecialJoinInfo */
} OuterJoinClauseInfo;
 
/*
 * Append-relation info.
 *
 * When we expand an inheritable table or a UNION-ALL subselect into an
 * "append relation" (essentially, a list of child RTEs), we build an
 * AppendRelInfo for each child RTE.  The list of AppendRelInfos indicates
 * which child RTEs must be included when expanding the parent, and each node
 * carries information needed to translate between columns of the parent and
 * columns of the child.
 *
 * These structs are kept in the PlannerInfo node's append_rel_list, with
 * append_rel_array[] providing a convenient lookup method for the struct
 * associated with a particular child relid (there can be only one, though
 * parent rels may have many entries in append_rel_list).
 *
 * Note: after completion of the planner prep phase, any given RTE is an
 * append parent having entries in append_rel_list if and only if its
 * "inh" flag is set.  We clear "inh" for plain tables that turn out not
 * to have inheritance children, and (in an abuse of the original meaning
 * of the flag) we set "inh" for subquery RTEs that turn out to be
 * flattenable UNION ALL queries.  This lets us avoid useless searches
 * of append_rel_list.
 *
 * Note: the data structure assumes that append-rel members are single
 * baserels.  This is OK for inheritance, but it prevents us from pulling
 * up a UNION ALL member subquery if it contains a join.  While that could
 * be fixed with a more complex data structure, at present there's not much
 * point because no improvement in the plan could result.
 */
 
typedef struct AppendRelInfo
{
    pg_node_attr(no_query_jumble)
 
    NodeTag     type;
 
    /*
     * These fields uniquely identify this append relationship.  There can be
     * (in fact, always should be) multiple AppendRelInfos for the same
     * parent_relid, but never more than one per child_relid, since a given
     * RTE cannot be a child of more than one append parent.
     */
    Index       parent_relid;   /* RT index of append parent rel */
    Index       child_relid;    /* RT index of append child rel */
 
    /*
     * For an inheritance appendrel, the parent and child are both regular
     * relations, and we store their rowtype OIDs here for use in translating
     * whole-row Vars.  For a UNION-ALL appendrel, the parent and child are
     * both subqueries with no named rowtype, and we store InvalidOid here.
     */
    Oid         parent_reltype; /* OID of parent's composite type */
    Oid         child_reltype;  /* OID of child's composite type */
 
    /*
     * The N'th element of this list is a Var or expression representing the
     * child column corresponding to the N'th column of the parent. This is
     * used to translate Vars referencing the parent rel into references to
     * the child.  A list element is NULL if it corresponds to a dropped
     * column of the parent (this is only possible for inheritance cases, not
     * UNION ALL).  The list elements are always simple Vars for inheritance
     * cases, but can be arbitrary expressions in UNION ALL cases.
     *
     * Notice we only store entries for user columns (attno > 0).  Whole-row
     * Vars are special-cased, and system columns (attno < 0) need no special
     * translation since their attnos are the same for all tables.
     *
     * Caution: the Vars have varlevelsup = 0.  Be careful to adjust as needed
     * when copying into a subquery.
     */
    List       *translated_vars;    /* Expressions in the child's Vars */
 
    /*
     * This array simplifies translations in the reverse direction, from
     * child's column numbers to parent's.  The entry at [ccolno - 1] is the
     * 1-based parent column number for child column ccolno, or zero if that
     * child column is dropped or doesn't exist in the parent.
     */
    int         num_child_cols; /* length of array */
    AttrNumber *parent_colnos pg_node_attr(array_size(num_child_cols));
 
    /*
     * We store the parent table's OID here for inheritance, or InvalidOid for
     * UNION ALL.  This is only needed to help in generating error messages if
     * an attempt is made to reference a dropped parent column.
     */
    Oid         parent_reloid;  /* OID of parent relation */
} AppendRelInfo;
 
/*
 * Information about a row-identity "resjunk" column in UPDATE/DELETE/MERGE.
 *
 * In partitioned UPDATE/DELETE/MERGE it's important for child partitions to
 * share row-identity columns whenever possible, so as not to chew up too many
 * targetlist columns.  We use these structs to track which identity columns
 * have been requested.  In the finished plan, each of these will give rise
 * to one resjunk entry in the targetlist of the ModifyTable's subplan node.
 *
 * All the Vars stored in RowIdentityVarInfos must have varno ROWID_VAR, for
 * convenience of detecting duplicate requests.  We'll replace that, in the
 * final plan, with the varno of the generating rel.
 *
 * Outside this list, a Var with varno ROWID_VAR and varattno k is a reference
 * to the k-th element of the row_identity_vars list (k counting from 1).
 * We add such a reference to root->processed_tlist when creating the entry,
 * and it propagates into the plan tree from there.
 */
typedef struct RowIdentityVarInfo
{
    pg_node_attr(no_copy_equal, no_read, no_query_jumble)
 
    NodeTag     type;
 
    Var        *rowidvar;       /* Var to be evaluated (but varno=ROWID_VAR) */
    int32       rowidwidth;     /* estimated average width */
    char       *rowidname;      /* name of the resjunk column */
    Relids      rowidrels;      /* RTE indexes of target rels using this */
} RowIdentityVarInfo;
 
/*
 * For each distinct placeholder expression generated during planning, we
 * store a PlaceHolderInfo node in the PlannerInfo node's placeholder_list.
 * This stores info that is needed centrally rather than in each copy of the
 * PlaceHolderVar.  The phid fields identify which PlaceHolderInfo goes with
 * each PlaceHolderVar.  Note that phid is unique throughout a planner run,
 * not just within a query level --- this is so that we need not reassign ID's
 * when pulling a subquery into its parent.
 *
 * The idea is to evaluate the expression at (only) the ph_eval_at join level,
 * then allow it to bubble up like a Var until the ph_needed join level.
 * ph_needed has the same definition as attr_needed for a regular Var.
 *
 * The PlaceHolderVar's expression might contain LATERAL references to vars
 * coming from outside its syntactic scope.  If so, those rels are *not*
 * included in ph_eval_at, but they are recorded in ph_lateral.
 *
 * Notice that when ph_eval_at is a join rather than a single baserel, the
 * PlaceHolderInfo may create constraints on join order: the ph_eval_at join
 * has to be formed below any outer joins that should null the PlaceHolderVar.
 *
 * We create a PlaceHolderInfo only after determining that the PlaceHolderVar
 * is actually referenced in the plan tree, so that unreferenced placeholders
 * don't result in unnecessary constraints on join order.
 */
 
typedef struct PlaceHolderInfo
{
    pg_node_attr(no_read, no_query_jumble)
 
    NodeTag     type;
 
    /* ID for PH (unique within planner run) */
    Index       phid;
 
    /*
     * copy of PlaceHolderVar tree (should be redundant for comparison, could
     * be ignored)
     */
    PlaceHolderVar *ph_var;
 
    /* lowest level we can evaluate value at */
    Relids      ph_eval_at;
 
    /* relids of contained lateral refs, if any */
    Relids      ph_lateral;
 
    /* highest level the value is needed at */
    Relids      ph_needed;
 
    /* estimated attribute width */
    int32       ph_width;
} PlaceHolderInfo;
 
/*
 * This struct describes one potentially index-optimizable MIN/MAX aggregate
 * function.  MinMaxAggPath contains a list of these, and if we accept that
 * path, the list is stored into root->minmax_aggs for use during setrefs.c.
 */
typedef struct MinMaxAggInfo
{
    pg_node_attr(no_copy_equal, no_read, no_query_jumble)
 
    NodeTag     type;
 
    /* pg_proc Oid of the aggregate */
    Oid         aggfnoid;
 
    /* Oid of its sort operator */
    Oid         aggsortop;
 
    /* expression we are aggregating on */
    Expr       *target;
 
    /*
     * modified "root" for planning the subquery; not printed, too large, not
     * interesting enough
     */
    PlannerInfo *subroot pg_node_attr(read_write_ignore);
 
    /* access path for subquery */
    Path       *path;
 
    /* estimated cost to fetch first row */
    Cost        pathcost;
 
    /* param for subplan's output */
    Param      *param;
} MinMaxAggInfo;
 
/*
 * For each distinct Aggref node that appears in the targetlist and HAVING
 * clauses, we store an AggClauseInfo node in the PlannerInfo node's
 * agg_clause_list.  Each AggClauseInfo records the set of relations referenced
 * by the aggregate expression.  This information is used to determine how far
 * the aggregate can be safely pushed down in the join tree.
 */
typedef struct AggClauseInfo
{
    pg_node_attr(no_read, no_query_jumble)
 
    NodeTag     type;
 
    /* the Aggref expr */
    Aggref     *aggref;
 
    /* lowest level we can evaluate this aggregate at */
    Relids      agg_eval_at;
} AggClauseInfo;
 
/*
 * For each grouping expression that appears in grouping clauses, we store a
 * GroupingExprInfo node in the PlannerInfo node's group_expr_list.  Each
 * GroupingExprInfo records the expression being grouped on, its sortgroupref,
 * and the EquivalenceClass it belongs to.  This information is necessary to
 * reproduce correct grouping semantics at different levels of the join tree.
 */
typedef struct GroupingExprInfo
{
    pg_node_attr(no_read, no_query_jumble)
 
    NodeTag     type;
 
    /* the represented expression */
    Expr       *expr;
 
    /* the tleSortGroupRef of the corresponding SortGroupClause */
    Index       sortgroupref;
 
    /* the equivalence class the expression belongs to */
    EquivalenceClass *ec pg_node_attr(copy_as_scalar, equal_as_scalar);
} GroupingExprInfo;
 
/*
 * At runtime, PARAM_EXEC slots are used to pass values around from one plan
 * node to another.  They can be used to pass values down into subqueries (for
 * outer references in subqueries), or up out of subqueries (for the results
 * of a subplan), or from a NestLoop plan node into its inner relation (when
 * the inner scan is parameterized with values from the outer relation).
 * The planner is responsible for assigning nonconflicting PARAM_EXEC IDs to
 * the PARAM_EXEC Params it generates.
 *
 * Outer references are managed via root->plan_params, which is a list of
 * PlannerParamItems.  While planning a subquery, each parent query level's
 * plan_params contains the values required from it by the current subquery.
 * During create_plan(), we use plan_params to track values that must be
 * passed from outer to inner sides of NestLoop plan nodes.
 *
 * The item a PlannerParamItem represents can be one of three kinds:
 *
 * A Var: the slot represents a variable of this level that must be passed
 * down because subqueries have outer references to it, or must be passed
 * from a NestLoop node to its inner scan.  The varlevelsup value in the Var
 * will always be zero.
 *
 * A PlaceHolderVar: this works much like the Var case, except that the
 * entry is a PlaceHolderVar node with a contained expression.  The PHV
 * will have phlevelsup = 0, and the contained expression is adjusted
 * to match in level.
 *
 * An Aggref (with an expression tree representing its argument): the slot
 * represents an aggregate expression that is an outer reference for some
 * subquery.  The Aggref itself has agglevelsup = 0, and its argument tree
 * is adjusted to match in level.
 *
 * Note: we detect duplicate Var and PlaceHolderVar parameters and coalesce
 * them into one slot, but we do not bother to do that for Aggrefs.
 * The scope of duplicate-elimination only extends across the set of
 * parameters passed from one query level into a single subquery, or for
 * nestloop parameters across the set of nestloop parameters used in a single
 * query level.  So there is no possibility of a PARAM_EXEC slot being used
 * for conflicting purposes.
 *
 * In addition, PARAM_EXEC slots are assigned for Params representing outputs
 * from subplans (values that are setParam items for those subplans).  These
 * IDs need not be tracked via PlannerParamItems, since we do not need any
 * duplicate-elimination nor later processing of the represented expressions.
 * Instead, we just record the assignment of the slot number by appending to
 * root->glob->paramExecTypes.
 */
typedef struct PlannerParamItem
{
    pg_node_attr(no_copy_equal, no_read, no_query_jumble)
 
    NodeTag     type;
 
    Node       *item;           /* the Var, PlaceHolderVar, or Aggref */
    int         paramId;        /* its assigned PARAM_EXEC slot number */
} PlannerParamItem;
 
/*
 * When making cost estimates for a SEMI/ANTI/inner_unique join, there are
 * some correction factors that are needed in both nestloop and hash joins
 * to account for the fact that the executor can stop scanning inner rows
 * as soon as it finds a match to the current outer row.  These numbers
 * depend only on the selected outer and inner join relations, not on the
 * particular paths used for them, so it's worthwhile to calculate them
 * just once per relation pair not once per considered path.  This struct
 * is filled by compute_semi_anti_join_factors and must be passed along
 * to the join cost estimation functions.
 *
 * outer_match_frac is the fraction of the outer tuples that are
 *      expected to have at least one match.
 * match_count is the average number of matches expected for
 *      outer tuples that have at least one match.
 */
typedef struct SemiAntiJoinFactors
{
    Selectivity outer_match_frac;
    Selectivity match_count;
} SemiAntiJoinFactors;
 
/*
 * Struct for extra information passed to subroutines of add_paths_to_joinrel
 *
 * restrictlist contains all of the RestrictInfo nodes for restriction
 *      clauses that apply to this join
 * mergeclause_list is a list of RestrictInfo nodes for available
 *      mergejoin clauses in this join
 * inner_unique is true if each outer tuple provably matches no more
 *      than one inner tuple
 * sjinfo is extra info about special joins for selectivity estimation
 * semifactors is as shown above (only valid for SEMI/ANTI/inner_unique joins)
 * param_source_rels are OK targets for parameterization of result paths
 * pgs_mask is a bitmask of PGS_* constants to limit the join strategy
 */
typedef struct JoinPathExtraData
{
    List       *restrictlist;
    List       *mergeclause_list;
    bool        inner_unique;
    SpecialJoinInfo *sjinfo;
    SemiAntiJoinFactors semifactors;
    Relids      param_source_rels;
    uint64      pgs_mask;
} JoinPathExtraData;
 
/*
 * Various flags indicating what kinds of grouping are possible.
 *
 * GROUPING_CAN_USE_SORT should be set if it's possible to perform
 * sort-based implementations of grouping.  When grouping sets are in use,
 * this will be true if sorting is potentially usable for any of the grouping
 * sets, even if it's not usable for all of them.
 *
 * GROUPING_CAN_USE_HASH should be set if it's possible to perform
 * hash-based implementations of grouping.
 *
 * GROUPING_CAN_PARTIAL_AGG should be set if the aggregation is of a type
 * for which we support partial aggregation (not, for example, grouping sets).
 * It says nothing about parallel-safety or the availability of suitable paths.
 */
#define GROUPING_CAN_USE_SORT       0x0001
#define GROUPING_CAN_USE_HASH       0x0002
#define GROUPING_CAN_PARTIAL_AGG    0x0004
 
/*
 * What kind of partitionwise aggregation is in use?
 *
 * PARTITIONWISE_AGGREGATE_NONE: Not used.
 *
 * PARTITIONWISE_AGGREGATE_FULL: Aggregate each partition separately, and
 * append the results.
 *
 * PARTITIONWISE_AGGREGATE_PARTIAL: Partially aggregate each partition
 * separately, append the results, and then finalize aggregation.
 */
typedef enum
{
    PARTITIONWISE_AGGREGATE_NONE,
    PARTITIONWISE_AGGREGATE_FULL,
    PARTITIONWISE_AGGREGATE_PARTIAL,
} PartitionwiseAggregateType;
 
/*
 * Struct for extra information passed to subroutines of create_grouping_paths
 *
 * flags indicating what kinds of grouping are possible.
 * partial_costs_set is true if the agg_partial_costs and agg_final_costs
 *      have been initialized.
 * agg_partial_costs gives partial aggregation costs.
 * agg_final_costs gives finalization costs.
 * target_parallel_safe is true if target is parallel safe.
 * havingQual gives list of quals to be applied after aggregation.
 * targetList gives list of columns to be projected.
 * patype is the type of partitionwise aggregation that is being performed.
 */
typedef struct
{
    /* Data which remains constant once set. */
    int         flags;
    bool        partial_costs_set;
    AggClauseCosts agg_partial_costs;
    AggClauseCosts agg_final_costs;
 
    /* Data which may differ across partitions. */
    bool        target_parallel_safe;
    Node       *havingQual;
    List       *targetList;
    PartitionwiseAggregateType patype;
} GroupPathExtraData;
 
/*
 * Struct for extra information passed to subroutines of grouping_planner
 *
 * limit_needed is true if we actually need a Limit plan node.
 * limit_tuples is an estimated bound on the number of output tuples,
 *      or -1 if no LIMIT or couldn't estimate.
 * count_est and offset_est are the estimated values of the LIMIT and OFFSET
 *      expressions computed by preprocess_limit() (see comments for
 *      preprocess_limit() for more information).
 */
typedef struct
{
    bool        limit_needed;
    Cardinality limit_tuples;
    int64       count_est;
    int64       offset_est;
} FinalPathExtraData;
 
/*
 * For speed reasons, cost estimation for join paths is performed in two
 * phases: the first phase tries to quickly derive a lower bound for the
 * join cost, and then we check if that's sufficient to reject the path.
 * If not, we come back for a more refined cost estimate.  The first phase
 * fills a JoinCostWorkspace struct with its preliminary cost estimates
 * and possibly additional intermediate values.  The second phase takes
 * these values as inputs to avoid repeating work.
 *
 * (Ideally we'd declare this in cost.h, but it's also needed in pathnode.h,
 * so seems best to put it here.)
 */
typedef struct JoinCostWorkspace
{
    /* Preliminary cost estimates --- must not be larger than final ones! */
    int         disabled_nodes;
    Cost        startup_cost;   /* cost expended before fetching any tuples */
    Cost        total_cost;     /* total cost (assuming all tuples fetched) */
 
    /* Fields below here should be treated as private to costsize.c */
    Cost        run_cost;       /* non-startup cost components */
 
    /* private for cost_nestloop code */
    Cost        inner_run_cost; /* also used by cost_mergejoin code */
    Cost        inner_rescan_run_cost;
 
    /* private for cost_mergejoin code */
    Cardinality outer_rows;
    Cardinality inner_rows;
    Cardinality outer_skip_rows;
    Cardinality inner_skip_rows;
 
    /* private for cost_hashjoin code */
    int         numbuckets;
    int         numbatches;
    Cardinality inner_rows_total;
} JoinCostWorkspace;
 
/*
 * AggInfo holds information about an aggregate that needs to be computed.
 * Multiple Aggrefs in a query can refer to the same AggInfo by having the
 * same 'aggno' value, so that the aggregate is computed only once.
 */
typedef struct AggInfo
{
    pg_node_attr(no_copy_equal, no_read, no_query_jumble)
 
    NodeTag     type;
 
    /*
     * List of Aggref exprs that this state value is for.
     *
     * There will always be at least one, but there can be multiple identical
     * Aggref's sharing the same per-agg.
     */
    List       *aggrefs;
 
    /* Transition state number for this aggregate */
    int         transno;
 
    /*
     * "shareable" is false if this agg cannot share state values with other
     * aggregates because the final function is read-write.
     */
    bool        shareable;
 
    /* Oid of the final function, or InvalidOid if none */
    Oid         finalfn_oid;
} AggInfo;
 
/*
 * AggTransInfo holds information about transition state that is used by one
 * or more aggregates in the query.  Multiple aggregates can share the same
 * transition state, if they have the same inputs and the same transition
 * function.  Aggrefs that share the same transition info have the same
 * 'aggtransno' value.
 */
typedef struct AggTransInfo
{
    pg_node_attr(no_copy_equal, no_read, no_query_jumble)
 
    NodeTag     type;
 
    /* Inputs for this transition state */
    List       *args;
    Expr       *aggfilter;
 
    /* Oid of the state transition function */
    Oid         transfn_oid;
 
    /* Oid of the serialization function, or InvalidOid if none */
    Oid         serialfn_oid;
 
    /* Oid of the deserialization function, or InvalidOid if none */
    Oid         deserialfn_oid;
 
    /* Oid of the combine function, or InvalidOid if none */
    Oid         combinefn_oid;
 
    /* Oid of state value's datatype */
    Oid         aggtranstype;
 
    /* Additional data about transtype */
    int32       aggtranstypmod;
    int         transtypeLen;
    bool        transtypeByVal;
 
    /* Space-consumption estimate */
    int32       aggtransspace;
 
    /* Initial value from pg_aggregate entry */
    Datum       initValue pg_node_attr(read_write_ignore);
    bool        initValueIsNull;
} AggTransInfo;
 
/*
 * UniqueRelInfo caches a fact that a relation is unique when being joined
 * to other relation(s).
 */
typedef struct UniqueRelInfo
{
    pg_node_attr(no_copy_equal, no_read, no_query_jumble)
 
    NodeTag     type;
 
    /*
     * The relation in consideration is unique when being joined with this set
     * of other relation(s).
     */
    Relids      outerrelids;
 
    /*
     * The relation in consideration is unique when considering only clauses
     * suitable for self-join (passed split_selfjoin_quals()).
     */
    bool        self_join;
 
    /*
     * Additional clauses from a baserestrictinfo list that were used to prove
     * the uniqueness.   We cache it for the self-join checking procedure: a
     * self-join can be removed if the outer relation contains strictly the
     * same set of clauses.
     */
    List       *extra_clauses;
} UniqueRelInfo;
 
#endif                          /* PATHNODES_H */

◆ get_pathtarget_sortgroupref

#define get_pathtarget_sortgroupref	(	target,
		colno
	)	((target)->sortgrouprefs ? (target)->sortgrouprefs[colno] : (Index) 0)

Definition at line 1894 of file pathnodes.h.

1895 : (Index) 0)

◆ GROUPING_CAN_PARTIAL_AGG

#define GROUPING_CAN_PARTIAL_AGG 0x0004

Definition at line 3632 of file pathnodes.h.

◆ GROUPING_CAN_USE_HASH

#define GROUPING_CAN_USE_HASH 0x0002

Definition at line 3631 of file pathnodes.h.

◆ GROUPING_CAN_USE_SORT

#define GROUPING_CAN_USE_SORT 0x0001

Definition at line 3630 of file pathnodes.h.

◆ IS_DUMMY_APPEND

#define IS_DUMMY_APPEND ( p ) (IsA((p), AppendPath) && ((AppendPath *) (p))->subpaths == NIL)

Definition at line 2291 of file pathnodes.h.

◆ IS_DUMMY_REL

#define IS_DUMMY_REL ( r ) is_dummy_rel(r)

Definition at line 2299 of file pathnodes.h.

◆ IS_GROUPED_REL

#define IS_GROUPED_REL ( rel ) ((rel)->agg_info != NULL)

Definition at line 1257 of file pathnodes.h.

◆ IS_JOIN_REL

#define IS_JOIN_REL ( rel )

Value:

((rel)->reloptkind == RELOPT_JOINREL || \

(rel)->reloptkind == RELOPT_OTHER_JOINREL)

RELOPT_JOINREL

@ RELOPT_JOINREL

Definition pathnodes.h:978

RELOPT_OTHER_JOINREL

@ RELOPT_OTHER_JOINREL

Definition pathnodes.h:980

Definition at line 994 of file pathnodes.h.

◆ IS_OTHER_REL

#define IS_OTHER_REL ( rel )

Value:

    ((rel)->reloptkind == RELOPT_OTHER_MEMBER_REL || \
     (rel)->reloptkind == RELOPT_OTHER_JOINREL || \
     (rel)->reloptkind == RELOPT_OTHER_UPPER_REL)

Definition at line 1004 of file pathnodes.h.

◆ IS_PARTITIONED_REL

#define IS_PARTITIONED_REL ( rel )

Value:

((rel)->part_scheme && (rel)->boundinfo && (rel)->nparts > 0 && \

(rel)->part_rels && !IS_DUMMY_REL(rel))

IS_DUMMY_REL

#define IS_DUMMY_REL(r)

Definition pathnodes.h:2299

Definition at line 1231 of file pathnodes.h.

◆ IS_SIMPLE_REL

#define IS_SIMPLE_REL ( rel )

Value:

((rel)->reloptkind == RELOPT_BASEREL || \

(rel)->reloptkind == RELOPT_OTHER_MEMBER_REL)

RELOPT_BASEREL

@ RELOPT_BASEREL

Definition pathnodes.h:977

Definition at line 989 of file pathnodes.h.

◆ IS_UPPER_REL

#define IS_UPPER_REL ( rel )

Value:

((rel)->reloptkind == RELOPT_UPPER_REL || \

(rel)->reloptkind == RELOPT_OTHER_UPPER_REL)

RELOPT_UPPER_REL

@ RELOPT_UPPER_REL

Definition pathnodes.h:981

Definition at line 999 of file pathnodes.h.

◆ PATH_REQ_OUTER

#define PATH_REQ_OUTER ( path ) ((path)->param_info ? (path)->param_info->ppi_req_outer : (Relids) NULL)

Definition at line 2015 of file pathnodes.h.

2016 : (Relids) NULL)

Relids

Bitmapset * Relids

Definition pathnodes.h:103

◆ PGS_APPEND

#define PGS_APPEND 0x00001000

Definition at line 78 of file pathnodes.h.

◆ PGS_BITMAPSCAN

#define PGS_BITMAPSCAN 0x00000008

Definition at line 69 of file pathnodes.h.

◆ PGS_CONSIDER_INDEXONLY

#define PGS_CONSIDER_INDEXONLY 0x00010000

Definition at line 82 of file pathnodes.h.

◆ PGS_CONSIDER_NONPARTIAL

#define PGS_CONSIDER_NONPARTIAL 0x00040000

Definition at line 84 of file pathnodes.h.

◆ PGS_CONSIDER_PARTITIONWISE

#define PGS_CONSIDER_PARTITIONWISE 0x00020000

Definition at line 83 of file pathnodes.h.

◆ PGS_FOREIGNJOIN

#define PGS_FOREIGNJOIN 0x00000020

Definition at line 71 of file pathnodes.h.

◆ PGS_GATHER

#define PGS_GATHER 0x00004000

Definition at line 80 of file pathnodes.h.

◆ PGS_GATHER_MERGE

#define PGS_GATHER_MERGE 0x00008000

Definition at line 81 of file pathnodes.h.

◆ PGS_HASHJOIN

#define PGS_HASHJOIN 0x00000800

Definition at line 77 of file pathnodes.h.

◆ PGS_INDEXONLYSCAN

#define PGS_INDEXONLYSCAN 0x00000004

Definition at line 68 of file pathnodes.h.

◆ PGS_INDEXSCAN

#define PGS_INDEXSCAN 0x00000002

Definition at line 67 of file pathnodes.h.

◆ PGS_JOIN_ANY

#define PGS_JOIN_ANY (PGS_FOREIGNJOIN | PGS_MERGEJOIN_ANY | PGS_NESTLOOP_ANY | PGS_HASHJOIN)

Definition at line 96 of file pathnodes.h.

◆ PGS_MERGE_APPEND

#define PGS_MERGE_APPEND 0x00002000

Definition at line 79 of file pathnodes.h.

◆ PGS_MERGEJOIN_ANY

#define PGS_MERGEJOIN_ANY (PGS_MERGEJOIN_PLAIN | PGS_MERGEJOIN_MATERIALIZE)

Definition at line 92 of file pathnodes.h.

◆ PGS_MERGEJOIN_MATERIALIZE

#define PGS_MERGEJOIN_MATERIALIZE 0x00000080

Definition at line 73 of file pathnodes.h.

◆ PGS_MERGEJOIN_PLAIN

#define PGS_MERGEJOIN_PLAIN 0x00000040

Definition at line 72 of file pathnodes.h.

◆ PGS_NESTLOOP_ANY

#define PGS_NESTLOOP_ANY (PGS_NESTLOOP_PLAIN | PGS_NESTLOOP_MATERIALIZE | PGS_NESTLOOP_MEMOIZE)

Definition at line 94 of file pathnodes.h.

◆ PGS_NESTLOOP_MATERIALIZE

#define PGS_NESTLOOP_MATERIALIZE 0x00000200

Definition at line 75 of file pathnodes.h.

◆ PGS_NESTLOOP_MEMOIZE

#define PGS_NESTLOOP_MEMOIZE 0x00000400

Definition at line 76 of file pathnodes.h.

◆ PGS_NESTLOOP_PLAIN

#define PGS_NESTLOOP_PLAIN 0x00000100

Definition at line 74 of file pathnodes.h.

◆ PGS_SCAN_ANY

#define PGS_SCAN_ANY

Value:

(PGS_SEQSCAN | PGS_INDEXSCAN | PGS_INDEXONLYSCAN | PGS_BITMAPSCAN | \

PGS_TIDSCAN)

PGS_TIDSCAN

#define PGS_TIDSCAN

Definition pathnodes.h:70

PGS_SEQSCAN

#define PGS_SEQSCAN

Definition pathnodes.h:66

PGS_BITMAPSCAN

#define PGS_BITMAPSCAN

Definition pathnodes.h:69

PGS_INDEXONLYSCAN

#define PGS_INDEXONLYSCAN

Definition pathnodes.h:68

PGS_INDEXSCAN

#define PGS_INDEXSCAN

Definition pathnodes.h:67

Definition at line 89 of file pathnodes.h.

◆ PGS_SEQSCAN

#define PGS_SEQSCAN 0x00000001

Definition at line 66 of file pathnodes.h.

◆ PGS_TIDSCAN

#define PGS_TIDSCAN 0x00000010

Definition at line 70 of file pathnodes.h.

◆ planner_rt_fetch

#define planner_rt_fetch	(	rti,
		root
	)

Value:

((root)->simple_rte_array ? (root)->simple_rte_array[rti] : \

rt_fetch(rti, (root)->parse->rtable))

parse

void parse(int)

Definition parse.c:49

root

tree ctl root

Definition radixtree.h:1857

Definition at line 704 of file pathnodes.h.

705 : \

706 rt_fetch(rti, (root)->parse->rtable))

◆ planner_subplan_get_plan

#define planner_subplan_get_plan	(	root,
		subplan
	)	((Plan *) list_nth((root)->glob->subplans, (subplan)->plan_id - 1))

Definition at line 277 of file pathnodes.h.

◆ REL_HAS_ALL_PART_PROPS

#define REL_HAS_ALL_PART_PROPS ( rel )

Value:

((rel)->part_scheme && (rel)->boundinfo && (rel)->nparts > 0 && \

(rel)->part_rels && (rel)->partexprs && (rel)->nullable_partexprs)

Definition at line 1239 of file pathnodes.h.

◆ RELATION_WAS_MADE_UNIQUE

#define RELATION_WAS_MADE_UNIQUE	(	rel,
		sjinfo,
		nominal_jointype
	)

Value:

((nominal_jointype) == JOIN_INNER && (sjinfo)->jointype == JOIN_SEMI && \

bms_equal((sjinfo)->syn_righthand, (rel)->relids))

JOIN_SEMI

@ JOIN_SEMI

Definition nodes.h:317

JOIN_INNER

@ JOIN_INNER

Definition nodes.h:303

Definition at line 1250 of file pathnodes.h.

◆ RINFO_IS_PUSHED_DOWN

#define RINFO_IS_PUSHED_DOWN	(	rinfo,
		joinrelids
	)

Value:

((rinfo)->is_pushed_down || \

!bms_is_subset((rinfo)->required_relids, joinrelids))

bms_is_subset

bool bms_is_subset(const Bitmapset *a, const Bitmapset *b)

Definition bitmapset.c:412

Definition at line 3058 of file pathnodes.h.

Typedef Documentation

◆ AggClauseCosts

typedef struct AggClauseCosts AggClauseCosts

◆ AggClauseInfo

typedef struct AggClauseInfo AggClauseInfo

◆ AggInfo

typedef struct AggInfo AggInfo

◆ AggPath

typedef struct AggPath AggPath

◆ AggTransInfo

typedef struct AggTransInfo AggTransInfo

◆ AppendPath

typedef struct AppendPath AppendPath

◆ AppendRelInfo

typedef struct AppendRelInfo AppendRelInfo

◆ BitmapAndPath

typedef struct BitmapAndPath BitmapAndPath

◆ BitmapHeapPath

typedef struct BitmapHeapPath BitmapHeapPath

◆ BitmapOrPath

typedef struct BitmapOrPath BitmapOrPath

◆ CostSelector

typedef enum CostSelector CostSelector

◆ CustomPath

typedef struct CustomPath CustomPath

◆ EquivalenceClass

typedef struct EquivalenceClass EquivalenceClass

◆ EquivalenceMember

typedef struct EquivalenceMember EquivalenceMember

◆ ForeignKeyOptInfo

typedef struct ForeignKeyOptInfo ForeignKeyOptInfo

◆ ForeignPath

typedef struct ForeignPath ForeignPath

◆ GatherMergePath

typedef struct GatherMergePath GatherMergePath

◆ GatherPath

typedef struct GatherPath GatherPath

◆ GroupByOrdering

typedef struct GroupByOrdering GroupByOrdering

◆ GroupingExprInfo

typedef struct GroupingExprInfo GroupingExprInfo

◆ GroupingSetData

typedef struct GroupingSetData GroupingSetData

◆ GroupingSetsPath

typedef struct GroupingSetsPath GroupingSetsPath

◆ GroupPath

typedef struct GroupPath GroupPath

◆ GroupResultPath

typedef struct GroupResultPath GroupResultPath

◆ HashPath

typedef struct HashPath HashPath

◆ IncrementalSortPath

typedef struct IncrementalSortPath IncrementalSortPath

◆ IndexClause

typedef struct IndexClause IndexClause

◆ IndexOptInfo

typedef struct IndexOptInfo IndexOptInfo

◆ IndexPath

typedef struct IndexPath IndexPath

◆ JoinCostWorkspace

typedef struct JoinCostWorkspace JoinCostWorkspace

◆ JoinDomain

typedef struct JoinDomain JoinDomain

◆ JoinPath

typedef struct JoinPath JoinPath

◆ JoinPathExtraData

typedef struct JoinPathExtraData JoinPathExtraData

◆ LimitPath

typedef struct LimitPath LimitPath

◆ LockRowsPath

typedef struct LockRowsPath LockRowsPath

◆ MaterialPath

typedef struct MaterialPath MaterialPath

◆ MemoizePath

typedef struct MemoizePath MemoizePath

◆ MergeAppendPath

typedef struct MergeAppendPath MergeAppendPath

◆ MergePath

typedef struct MergePath MergePath

◆ MergeScanSelCache

typedef struct MergeScanSelCache MergeScanSelCache

◆ MinMaxAggInfo

typedef struct MinMaxAggInfo MinMaxAggInfo

◆ MinMaxAggPath

typedef struct MinMaxAggPath MinMaxAggPath

◆ ModifyTablePath

typedef struct ModifyTablePath ModifyTablePath

◆ NestPath

typedef struct NestPath NestPath

◆ OuterJoinClauseInfo

typedef struct OuterJoinClauseInfo OuterJoinClauseInfo

◆ ParamPathInfo

typedef struct ParamPathInfo ParamPathInfo

◆ PartitionScheme

typedef struct PartitionSchemeData* PartitionScheme

Definition at line 738 of file pathnodes.h.

◆ PartitionSchemeData

typedef struct PartitionSchemeData PartitionSchemeData

◆ Path

typedef struct Path Path

◆ PathKey

typedef struct PathKey PathKey

◆ PathTarget

typedef struct PathTarget PathTarget

◆ PlaceHolderInfo

typedef struct PlaceHolderInfo PlaceHolderInfo

◆ PlaceHolderVar

typedef struct PlaceHolderVar PlaceHolderVar

◆ PlannerGlobal

typedef struct PlannerGlobal PlannerGlobal

◆ PlannerInfo

typedef struct PlannerInfo PlannerInfo

Definition at line 300 of file pathnodes.h.

◆ PlannerParamItem

typedef struct PlannerParamItem PlannerParamItem

◆ ProjectionPath

typedef struct ProjectionPath ProjectionPath

◆ ProjectSetPath

typedef struct ProjectSetPath ProjectSetPath

◆ QualCost

typedef struct QualCost QualCost

◆ RecursiveUnionPath

typedef struct RecursiveUnionPath RecursiveUnionPath

◆ RelAggInfo

typedef struct RelAggInfo RelAggInfo

◆ Relids

typedef Bitmapset* Relids

Definition at line 103 of file pathnodes.h.

◆ RelOptInfo

typedef struct RelOptInfo RelOptInfo

◆ RelOptKind

typedef enum RelOptKind RelOptKind

◆ RestrictInfo

typedef struct RestrictInfo RestrictInfo

◆ RollupData

typedef struct RollupData RollupData

◆ RowIdentityVarInfo

typedef struct RowIdentityVarInfo RowIdentityVarInfo

◆ SemiAntiJoinFactors

typedef struct SemiAntiJoinFactors SemiAntiJoinFactors

◆ SetOpPath

typedef struct SetOpPath SetOpPath

◆ SortPath

typedef struct SortPath SortPath

◆ SpecialJoinInfo

typedef struct SpecialJoinInfo SpecialJoinInfo

◆ StatisticExtInfo

typedef struct StatisticExtInfo StatisticExtInfo

◆ SubqueryScanPath

typedef struct SubqueryScanPath SubqueryScanPath

◆ TidPath

typedef struct TidPath TidPath

◆ TidRangePath

typedef struct TidRangePath TidRangePath

◆ UniquePath

typedef struct UniquePath UniquePath

◆ UniqueRelInfo

typedef struct UniqueRelInfo UniqueRelInfo

◆ UpperRelationKind

typedef enum UpperRelationKind UpperRelationKind

◆ VolatileFunctionStatus

typedef enum VolatileFunctionStatus VolatileFunctionStatus

◆ WindowAggPath

typedef struct WindowAggPath WindowAggPath

Enumeration Type Documentation

◆ CostSelector

enum CostSelector

Enumerator
STARTUP_COST
TOTAL_COST

Definition at line 109 of file pathnodes.h.

{
    STARTUP_COST, TOTAL_COST
} CostSelector;

◆ PartitionwiseAggregateType

enum PartitionwiseAggregateType

Enumerator
PARTITIONWISE_AGGREGATE_NONE
PARTITIONWISE_AGGREGATE_FULL
PARTITIONWISE_AGGREGATE_PARTIAL

Definition at line 3645 of file pathnodes.h.

{
    PARTITIONWISE_AGGREGATE_NONE,
    PARTITIONWISE_AGGREGATE_FULL,
    PARTITIONWISE_AGGREGATE_PARTIAL,
} PartitionwiseAggregateType;

◆ RelOptKind

enum RelOptKind

Enumerator
RELOPT_BASEREL
RELOPT_JOINREL
RELOPT_OTHER_MEMBER_REL
RELOPT_OTHER_JOINREL
RELOPT_UPPER_REL
RELOPT_OTHER_UPPER_REL

Definition at line 975 of file pathnodes.h.

{
    RELOPT_BASEREL,
    RELOPT_JOINREL,
    RELOPT_OTHER_MEMBER_REL,
    RELOPT_OTHER_JOINREL,
    RELOPT_UPPER_REL,
    RELOPT_OTHER_UPPER_REL,
} RelOptKind;

◆ UpperRelationKind

enum UpperRelationKind

Enumerator
UPPERREL_SETOP
UPPERREL_PARTIAL_GROUP_AGG
UPPERREL_GROUP_AGG
UPPERREL_WINDOW
UPPERREL_PARTIAL_DISTINCT
UPPERREL_DISTINCT
UPPERREL_ORDERED
UPPERREL_FINAL

Definition at line 142 of file pathnodes.h.

{
    UPPERREL_SETOP,             /* result of UNION/INTERSECT/EXCEPT, if any */
    UPPERREL_PARTIAL_GROUP_AGG, /* result of partial grouping/aggregation, if
                                 * any */
    UPPERREL_GROUP_AGG,         /* result of grouping/aggregation, if any */
    UPPERREL_WINDOW,            /* result of window functions, if any */
    UPPERREL_PARTIAL_DISTINCT,  /* result of partial "SELECT DISTINCT", if any */
    UPPERREL_DISTINCT,          /* result of "SELECT DISTINCT", if any */
    UPPERREL_ORDERED,           /* result of ORDER BY, if any */
    UPPERREL_FINAL,             /* result of any remaining top-level actions */
    /* NB: UPPERREL_FINAL must be last enum entry; it's used to size arrays */
} UpperRelationKind;

◆ VolatileFunctionStatus

enum VolatileFunctionStatus

Enumerator
VOLATILITY_UNKNOWN
VOLATILITY_VOLATILE
VOLATILITY_NOVOLATILE

Definition at line 1841 of file pathnodes.h.

{
    VOLATILITY_UNKNOWN = 0,
    VOLATILITY_VOLATILE,
    VOLATILITY_NOVOLATILE,
} VolatileFunctionStatus;

Function Documentation

◆ is_dummy_rel()

bool is_dummy_rel ( RelOptInfo * rel )

extern

Definition at line 1464 of file joinrels.c.

{
    Path       *path;
 
    /*
     * A rel that is known dummy will have just one path that is a childless
     * Append.  (Even if somehow it has more paths, a childless Append will
     * have cost zero and hence should be at the front of the pathlist.)
     */
    if (rel->pathlist == NIL)
        return false;
    path = (Path *) linitial(rel->pathlist);
 
    /*
     * Initially, a dummy path will just be a childless Append.  But in later
     * planning stages we might stick a ProjectSetPath and/or ProjectionPath
     * on top, since Append can't project.  Rather than make assumptions about
     * which combinations can occur, just descend through whatever we find.
     */
    for (;;)
    {
        if (IsA(path, ProjectionPath))
            path = ((ProjectionPath *) path)->subpath;
        else if (IsA(path, ProjectSetPath))
            path = ((ProjectSetPath *) path)->subpath;
        else
            break;
    }
    if (IS_DUMMY_APPEND(path))
        return true;
    return false;
}

References IS_DUMMY_APPEND, IsA, linitial, NIL, RelOptInfo::pathlist, and subpath().

Referenced by build_setop_child_paths(), generate_nonunion_paths(), generate_union_paths(), make_join_rel(), mark_dummy_rel(), and populate_joinrel_with_paths().

Data Structures

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ AMFLAG_HAS_TID_RANGE

◆ EC_MUST_BE_REDUNDANT

◆ get_pathtarget_sortgroupref

◆ GROUPING_CAN_PARTIAL_AGG

◆ GROUPING_CAN_USE_HASH

◆ GROUPING_CAN_USE_SORT

◆ IS_DUMMY_APPEND

◆ IS_DUMMY_REL

◆ IS_GROUPED_REL

◆ IS_JOIN_REL

◆ IS_OTHER_REL

◆ IS_PARTITIONED_REL

◆ IS_SIMPLE_REL

◆ IS_UPPER_REL

◆ PATH_REQ_OUTER

◆ PGS_APPEND

◆ PGS_BITMAPSCAN

◆ PGS_CONSIDER_INDEXONLY

◆ PGS_CONSIDER_NONPARTIAL

◆ PGS_CONSIDER_PARTITIONWISE

◆ PGS_FOREIGNJOIN

◆ PGS_GATHER

◆ PGS_GATHER_MERGE

◆ PGS_HASHJOIN

◆ PGS_INDEXONLYSCAN

◆ PGS_INDEXSCAN

◆ PGS_JOIN_ANY

◆ PGS_MERGE_APPEND

◆ PGS_MERGEJOIN_ANY

◆ PGS_MERGEJOIN_MATERIALIZE

◆ PGS_MERGEJOIN_PLAIN

◆ PGS_NESTLOOP_ANY

◆ PGS_NESTLOOP_MATERIALIZE

◆ PGS_NESTLOOP_MEMOIZE

◆ PGS_NESTLOOP_PLAIN

◆ PGS_SCAN_ANY

◆ PGS_SEQSCAN

◆ PGS_TIDSCAN

◆ planner_rt_fetch

◆ planner_subplan_get_plan

◆ REL_HAS_ALL_PART_PROPS

◆ RELATION_WAS_MADE_UNIQUE

◆ RINFO_IS_PUSHED_DOWN

Typedef Documentation

◆ AggClauseCosts

◆ AggClauseInfo

◆ AggInfo

◆ AggPath

◆ AggTransInfo

◆ AppendPath

◆ AppendRelInfo

◆ BitmapAndPath

◆ BitmapHeapPath

◆ BitmapOrPath

◆ CostSelector

◆ CustomPath

◆ EquivalenceClass

◆ EquivalenceMember

◆ ForeignKeyOptInfo

◆ ForeignPath

◆ GatherMergePath

◆ GatherPath

◆ GroupByOrdering

◆ GroupingExprInfo

◆ GroupingSetData

◆ GroupingSetsPath

◆ GroupPath

◆ GroupResultPath

◆ HashPath

◆ IncrementalSortPath

◆ IndexClause

◆ IndexOptInfo

◆ IndexPath

◆ JoinCostWorkspace