*
* relation.h
* Definitions for planner's internal data structures.
*
*
* Portions Copyright (c) 2021, openGauss Contributors
* Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* src/include/nodes/relation.h
*
* -------------------------------------------------------------------------
*/
#ifndef RELATION_H
#define RELATION_H
#include "access/sdir.h"
#include "lib/stringinfo.h"
#include "nodes/params.h"
#include "nodes/parsenodes.h"
#include "storage/buf/block.h"
#include "utils/partitionmap.h"
#include "utils/partitionmap_gs.h"
#include "optimizer/bucketinfo.h"
#ifdef USE_SPQ
* ApplyShareInputContext is used in different stages of ShareInputScan
* processing. This is mostly used as working area during the stages, but
* some information is also carried through multiple stages.
*/
typedef struct ApplyShareInputContextPerShare {
int producer_slice_id;
Bitmapset *participant_slices;
} ApplyShareInputContextPerShare;
struct PlanSlice;
struct Plan;
typedef struct ApplyShareInputContext {
List *curr_rtable;
* Populated in dag_to_tree() (or collect_shareinput_producers() for ORCA),
* used in replace_shareinput_targetlists()
*/
Plan **shared_plans;
int shared_input_count;
* State for replace_shareinput_targetlists()
*/
int *share_refcounts;
int share_refcounts_sz;
* State for apply_sharinput_xslice() walkers.
*/
PlanSlice *slices;
List *motStack;
ApplyShareInputContextPerShare *shared_inputs;
Bitmapset *qdShares;
} ApplyShareInputContext;
#endif
* Determines if query has to be launched
* on Coordinators only (SEQUENCE DDL),
* on Datanodes (normal Remote Queries),
* or on all openGauss nodes (Utilities and DDL).
*/
typedef enum
{
EXEC_ON_DATANODES,
EXEC_ON_COORDS,
EXEC_ON_ALL_NODES,
EXEC_ON_NONE
} RemoteQueryExecType;
#define EXEC_CONTAIN_COORDINATOR(exec_type) \
((exec_type) == EXEC_ON_ALL_NODES || (exec_type) == EXEC_ON_COORDS)
#define EXEC_CONTAIN_DATANODE(exec_type) \
((exec_type) == EXEC_ON_ALL_NODES || (exec_type) == EXEC_ON_DATANODES)
* When looking for a "cheapest path", this enum specifies whether we want
* cheapest startup cost or cheapest total cost.
*/
typedef enum CostSelector { STARTUP_COST, TOTAL_COST } CostSelector;
typedef enum {
NO_PATH_GEN_RULE = 0,
BTREE_INDEX_CONTAIN_UNIQUE_COLS = 1
} RulesForPathGen;
* The cost estimate produced by cost_qual_eval() includes both a one-time
* (startup) cost, and a per-tuple cost.
*/
typedef struct QualCost {
Cost startup;
Cost per_tuple;
} QualCost;
* Costing aggregate function execution requires these statistics about
* the aggregates to be executed by a given Agg node. Note that transCost
* includes the execution costs of the aggregates' input expressions.
*/
typedef struct AggClauseCosts {
int numAggs;
int numOrderedAggs;
List* exprAggs;
QualCost transCost;
Cost finalCost;
Size transitionSpace;
bool hasdctDnAggs;
bool hasDnAggs;
bool unhashable;
bool hasPolymorphicType;
int aggWidth;
} AggClauseCosts;
* This enum identifies the different types of "upper" (post-scan/join)
* relations that we might deal with during planning.
*/
typedef enum UpperRelationKind {
UPPERREL_INIT,
UPPERREL_SETOP,
UPPERREL_GROUP_AGG,
UPPERREL_WINDOW,
UPPERREL_DISTINCT,
UPPERREL_ORDERED,
UPPERREL_ROWMARKS,
UPPERREL_LIMIT,
UPPERREL_FINAL
} UpperRelationKind;
* For global path optimization, we should keep all paths with interesting distribute
* keys. There are two kinds of such keys: super set (taking effect for intermediate
* relation and before agg) and exact match (taking effect for intermediate resultset
* with all referenced tables (no group by or subset of group by), or final result set
* after agg). Super set key is used for aggregation redistribution optimization, and
* matching key is used for insert/ delete/ update redistribution optimization.
* Also, we should keep corresponding positions for each interesting key, in order to
* redistribute in positions in sub level, to avoid redistribute in current level
*/
typedef struct ItstDisKey {
List* superset_keys;
List* matching_keys;
} ItstDisKey;
typedef struct {
int bloomfilter_index;
bool add_index;
} bloomfilter_context;
typedef struct PlannerContext {
MemoryContext plannerMemContext;
MemoryContext dataSkewMemContext;
MemoryContext tempMemCxt;
int refCounter;
} PlannerContext;
* For query mem-based optimization, we should record current memory usage,
* memory usage with no disk, with maximum disk possible (no severe influence
* to operator. We allow hashjoin and hashagg to use at most 32 disk files, and
* sort 256 files. For materialize, we don't want it to spill to disk unless it exceeds
* memory allowed), and the performance degression ratio between them.
* (Assume it's linear)
*/
typedef struct OpMemInfo {
double opMem;
double minMem;
double maxMem;
double regressCost;
} OpMemInfo;
#define HASH_MAX_DISK_SIZE 32
#define SORT_MAX_DISK_SIZE 256
#define DFS_MIN_MEM_SIZE 128 * 1024
#define PARTITION_MAX_SIZE (2 * 1024 * 1024L)
#define MAX_BATCH_ROWS 60000
#define PARTIAL_CLUSTER_ROWS 4200000
#define SORT_MIM_MEM 16 * 1024
#define MEM_KB 1024L
#define PSORT_SPREAD_MAXMEM_RATIO 1.2
* PlannerGlobal
* Global information for planning/optimization
*
* PlannerGlobal holds state for an entire planner invocation; this state
* is shared across all levels of sub-Queries that exist in the command being
* planned.
* ----------
*/
typedef struct PlannerGlobal {
NodeTag type;
ParamListInfo boundParams;
List* paramlist;
List* subplans;
List* subroots;
Bitmapset* rewindPlanIDs;
List* finalrtable;
List* finalrowmarks;
List* resultRelations;
* Notice: be careful to use relationOids as it may contain non-table OID
* in some scenarios, e.g. assignment of relationOids in fix_expr_common.
*/
List* relationOids;
List* invalItems;
Index lastPHId;
Index lastRowMarkId;
bool transientPlan;
bool dependsOnRole;
int nParamExec;
bool insideRecursion;
bloomfilter_context bloomfilter;
bool vectorized;
int minopmem;
int estiopmem;
Cost IOTotalCost;
List* hint_warning;
PlannerContext* plannerContext;
int sublink_counter;
#ifdef USE_SPQ
ApplyShareInputContext share;
#endif
} PlannerGlobal;
#define planner_subplan_get_plan(root, subplan) ((Plan*)list_nth((root)->glob->subplans, (subplan)->plan_id - 1))
#define SUBQUERY_NORMAL 0x1
#define SUBQUERY_PARAM 0x2
#define SUBQUERY_RESULT 0x3
#define SUBQUERY_TYPE_BITMAP 0x3
#define SUBQUERY_SUBLINK 0x4
#define SUBQUERY_IS_NORMAL(pr) (((pr->subquery_type & SUBQUERY_TYPE_BITMAP) == SUBQUERY_NORMAL))
#define SUBQUERY_IS_PARAM(pr) (((pr->subquery_type & SUBQUERY_TYPE_BITMAP) == SUBQUERY_PARAM))
#define SUBQUERY_IS_RESULT(pr) (((pr->subquery_type & SUBQUERY_TYPE_BITMAP) == SUBQUERY_RESULT))
#define SUBQUERY_IS_SUBLINK(pr) (((pr->subquery_type & SUBQUERY_SUBLINK) == SUBQUERY_SUBLINK))
#define SUBQUERY_PREDPUSH(pr) ((SUBQUERY_IS_RESULT(pr)) || (SUBQUERY_IS_PARAM(pr)))
#define WITHIN_SUBQUERY(root, rte) (IS_STREAM_PLAN && root->is_correlated && \
(GetLocatorType(rte->relid) != LOCATOR_TYPE_REPLICATED || ng_is_multiple_nodegroup_scenario()))
struct PlannerTargets;
* PlannerInfo
* Per-query information for planning/optimization
*
* This struct is conventionally called "root" in all the planner routines.
* It holds links to all of the planner's working state, in addition to the
* original Query. Note that at present the planner extensively modifies
* the passed-in Query data structure; someday that should stop.
* ----------
*/
typedef struct PlannerInfo {
NodeTag type;
Query* parse;
PlannerGlobal* glob;
Index query_level;
struct PlannerInfo* parent_root;
* simple_rel_array holds pointers to "base rels" and "other rels" (see
* comments for RelOptInfo for more info). It is indexed by rangetable
* index (so entry 0 is always wasted). Entries can be NULL when an RTE
* does not correspond to a base relation, such as a join RTE or an
* unreferenced view RTE; or if the RelOptInfo hasn't been made yet.
*/
struct RelOptInfo** simple_rel_array;
int simple_rel_array_size;
* List of changed var that mutated during cost-based rewrite optimization, the
* element in the list is "struct RewriteVarMapping", for example:
* - inlist2join
* - pushjoin2union (will implemented)
* _ ...
*
*/
List* var_mappings;
Relids var_mapping_rels;
* simple_rte_array is the same length as simple_rel_array and holds
* pointers to the associated rangetable entries. This lets us avoid
* rt_fetch(), which can be a bit slow once large inheritance sets have
* been expanded.
*/
RangeTblEntry** simple_rte_array;
* append_rel_array is the same length as the above arrays, and holds
* pointers to the corresponding AppendRelInfo entry indexed by
* child_relid, or NULL if the rel is not an appendrel child. The array
* itself is not allocated if append_rel_list is empty.
*/
struct AppendRelInfo **append_rel_array;
* all_baserels is a Relids set of all base relids (but not "other"
* relids) in the query; that is, the Relids identifier of the final join
* we need to form.
*/
Relids all_baserels;
* join_rel_list is a list of all join-relation RelOptInfos we have
* considered in this planning run. For small problems we just scan the
* list to do lookups, but when there are many join relations we build a
* hash table for faster lookups. The hash table is present and valid
* when join_rel_hash is not NULL. Note that we still maintain the list
* even when using the hash table for lookups; this simplifies life for
* GEQO.
*/
List* join_rel_list;
struct HTAB* join_rel_hash;
* When doing a dynamic-programming-style join search, join_rel_level[k]
* is a list of all join-relation RelOptInfos of level k, and
* join_cur_level is the current level. New join-relation RelOptInfos are
* automatically added to the join_rel_level[join_cur_level] list.
* join_rel_level is NULL if not in use.
*/
List** join_rel_level;
int join_cur_level;
List* init_plans;
List* cte_plan_ids;
List* eq_classes;
List* canon_pathkeys;
List* left_join_clauses;
* mergejoinable outer join clauses
* w/nonnullable var on left */
List* right_join_clauses;
* mergejoinable outer join clauses
* w/nonnullable var on right */
List* full_join_clauses;
* mergejoinable full join clauses */
List* join_info_list;
List* lateral_info_list;
List* append_rel_list;
List* rowMarks;
List* placeholder_list;
List* query_pathkeys;
* actual pathkeys afterwards */
List* group_pathkeys;
List* window_pathkeys;
List* distinct_pathkeys;
List* sort_pathkeys;
List *upper_rels[UPPERREL_FINAL + 1];
struct PathTarget *upper_targets[UPPERREL_FINAL + 1];
List* minmax_aggs;
List* initial_rels;
MemoryContext planner_cxt;
double total_table_pages;
double tuple_fraction;
double limit_tuples;
bool hasInheritedTarget;
* inheritance child rel */
bool hasJoinRTEs;
bool hasLateralRTEs;
bool hasHavingQual;
bool hasPseudoConstantQuals;
* pseudoconstant = true */
bool hasRecursion;
bool consider_sortgroup_agg;
Index qualSecurityLevel;
#ifdef PGXC
int rs_alias_index;
* In openGauss Coordinators are supposed to skip the handling of
* row marks of type ROW_MARK_EXCLUSIVE & ROW_MARK_SHARE.
* In order to do that we simply remove such type
* of row marks from the list rowMarks. Instead they are saved
* in xc_rowMarks list that is then handeled to add
* FOR UPDATE/SHARE in the remote query
*/
List* xc_rowMarks;
#endif
int wt_param_id;
struct Plan* non_recursive_plan;
Relids curOuterRels;
List* curOuterParams;
Index curIteratorParamIndex;
bool isPartIteratorPruning;
Index curSubPartIteratorParamIndex;
bool isPartIteratorPlanning;
int curItrs;
List* subqueryRestrictInfo;
void* join_search_private;
List* plan_params;
List* join_null_info;
* grouping_planner passes back its final processed targetlist here, for
* use in relabeling the topmost tlist of the finished Plan.
*/
List *processed_tlist;
AttrNumber* grouping_map;
bool is_correlated;
* dataDestRelIndex is index into the range table. This variable
* will take effect on data redistribution state.
* The effective value must be greater than 0.
*/
Index dataDestRelIndex;
ItstDisKey dis_keys;
* indicate if the subquery planning root (PlannerInfo) is under or rooted from
* recursive-cte planning.
*/
bool is_under_recursive_cte;
* indicate if the subquery planning root (PlannerInfo) is under recursive-cte's
* recursive branch
*/
bool is_under_recursive_tree;
bool has_recursive_correlated_rte;
int subquery_type;
Bitmapset *param_upper;
bool hasRownumQual;
bool hasRownumCheck;
List *origin_tlist;
struct PlannerTargets *planner_targets;
bool ru_is_under_start_with;
} PlannerInfo;
* In places where it's known that simple_rte_array[] must have been prepared
* already, we just index into it to fetch RTEs. In code that might be
* executed before or after entering query_planner(), use this macro.
*/
#define planner_rt_fetch(rti, root) \
((root)->simple_rte_array ? (root)->simple_rte_array[rti] : rt_fetch(rti, (root)->parse->rtable))
* RelOptInfo
* Per-relation information for planning/optimization
*
* For planning purposes, a "base rel" is either a plain relation (a table)
* or the output of a sub-SELECT or function that appears in the range table.
* In either case it is uniquely identified by an RT index. A "joinrel"
* is the joining of two or more base rels. A joinrel is identified by
* the set of RT indexes for its component baserels. We create RelOptInfo
* nodes for each baserel and joinrel, and store them in the PlannerInfo's
* simple_rel_array and join_rel_list respectively.
*
* Note that there is only one joinrel for any given set of component
* baserels, no matter what order we assemble them in; so an unordered
* set is the right datatype to identify it with.
*
* We also have "other rels", which are like base rels in that they refer to
* single RT indexes; but they are not part of the join tree, and are given
* a different RelOptKind to identify them.
* There is also a RelOptKind for "upper" relations, which are RelOptInfos
* that describe post-scan/join processing steps, such as aggregation.
* Many of the fields in these RelOptInfos are meaningless, but their Path
* fields always hold Paths showing ways to do that processing step, currently
* this kind is only used for fdw to search path.
* Lastly, there is a RelOptKind for "dead" relations, which are base rels
* that we have proven we don't need to join after all.
*
* Currently the only kind of otherrels are those made for member relations
* of an "append relation", that is an inheritance set or UNION ALL subquery.
* An append relation has a parent RTE that is a base rel, which represents
* the entire append relation. The member RTEs are otherrels. The parent
* is present in the query join tree but the members are not. The member
* RTEs and otherrels are used to plan the scans of the individual tables or
* subqueries of the append set; then the parent baserel is given Append
* and/or MergeAppend paths comprising the best paths for the individual
* member rels. (See comments for AppendRelInfo for more information.)
*
* At one time we also made otherrels to represent join RTEs, for use in
* handling join alias Vars. Currently this is not needed because all join
* alias Vars are expanded to non-aliased form during preprocess_expression.
*
* Parts of this data structure are specific to various scan and join
* mechanisms. It didn't seem worth creating new node types for them.
*
* relids - Set of base-relation identifiers; it is a base relation
* if there is just one, a join relation if more than one
* rows - estimated number of tuples in the relation after restriction
* clauses have been applied (ie, output rows of a plan for it)
* reltarget - Default Path output tlist for this rel; normally contains
* Var and PlaceHolderVar nodes for the values we need to
* output from this relation.
* List is in no particular order, but all rels of an
* appendrel set must use corresponding orders.
* NOTE: in an appendrel child relation, may contain
* arbitrary expressions pulled up from a subquery!
* pathlist - List of Path nodes, one for each potentially useful
* method of generating the relation
* ppilist - ParamPathInfo nodes for parameterized Paths, if any
* cheapest_startup_path - the pathlist member with lowest startup cost
* (regardless of its ordering; but must be
* unparameterized)
* cheapest_total_path - the pathlist member with lowest total cost
* (regardless of its ordering; but must be
* unparameterized)
* cheapest_unique_path - for caching cheapest path to produce unique
* (no duplicates) output from relation
* cheapest_parameterized_paths - paths with cheapest total costs for
* their parameterizations; always includes
* cheapest_total_path
*
* If the relation is a base relation it will have these fields set:
*
* relid - RTE index (this is redundant with the relids field, but
* is provided for convenience of access)
* rtekind - distinguishes plain relation, subquery, or function RTE
* min_attr, max_attr - range of valid AttrNumbers for rel
* attr_needed - array of bitmapsets indicating the highest joinrel
* in which each attribute is needed; if bit 0 is set then
* the attribute is needed as part of final targetlist
* attr_widths - cache space for per-attribute width estimates;
* zero means not computed yet
* indexlist - list of IndexOptInfo nodes for relation's indexes
* (always NIL if it's not a table)
* pages - number of disk pages in relation (zero if not a table)
* tuples - number of tuples in relation (not considering restrictions)
* allvisfrac - fraction of disk pages that are marked all-visible
* subplan - plan for subquery (NULL if it's not a subquery)
* subroot - PlannerInfo for subquery (NULL if it's not a subquery)
*
* Note: for a subquery, tuples, subplan, subroot are not set immediately
* upon creation of the RelOptInfo object; they are filled in when
* set_subquery_pathlist processes the object. Likewise, fdwroutine
* and fdw_private are filled during initial path creation.
*
* For otherrels that are appendrel members, these fields are filled
* in just as for a baserel.
* If the relation is either a foreign table or a join of foreign tables that
* all belong to the same foreign server and are assigned to the same user to
* check access permissions as (cf checkAsUser), these fields will be set:
*
* serverid - OID of foreign server, if foreign table (else InvalidOid)
* userid - OID of user to check access as (InvalidOid means current user)
* useridiscurrent - we've assumed that userid equals current user
* fdwroutine - function hooks for FDW, if foreign table (else NULL)
* fdw_private - private state for FDW, if foreign table (else NULL)
*
* The presence of the remaining fields depends on the restrictions
* and joins that the relation participates in:
*
* baserestrictinfo - List of RestrictInfo nodes, containing info about
* each non-join qualification clause in which this relation
* participates (only used for base rels)
* baserestrictcost - Estimated cost of evaluating the baserestrictinfo
* clauses at a single tuple (only used for base rels)
* baserestrict_min_security - Smallest security_level found among
* clauses in baserestrictinfo
* joininfo - List of RestrictInfo nodes, containing info about each
* join clause in which this relation participates (but
* note this excludes clauses that might be derivable from
* EquivalenceClasses)
* has_eclass_joins - flag that EquivalenceClass joins are possible
*
* Note: Keeping a restrictinfo list in the RelOptInfo is useful only for
* base rels, because for a join rel the set of clauses that are treated as
* restrict clauses varies depending on which sub-relations we choose to join.
* (For example, in a 3-base-rel join, a clause relating rels 1 and 2 must be
* treated as a restrictclause if we join {1} and {2 3} to make {1 2 3}; but
* if we join {1 2} and {3} then that clause will be a restrictclause in {1 2}
* and should not be processed again at the level of {1 2 3}.) Therefore,
* the restrictinfo list in the join case appears in individual JoinPaths
* (field joinrestrictinfo), not in the parent relation. But it's OK for
* the RelOptInfo to store the joininfo list, because that is the same
* for a given rel no matter how we form it.
*
* We store baserestrictcost in the RelOptInfo (for base relations) because
* we know we will need it at least once (to price the sequential scan)
* and may need it multiple times to price index scans.
* ----------
*/
typedef enum RelOptKind { RELOPT_BASEREL, RELOPT_JOINREL, RELOPT_OTHER_MEMBER_REL, RELOPT_UPPER_REL, RELOPT_DEADREL } RelOptKind;
typedef enum PartitionFlag { PARTITION_NONE, PARTITION_REQURIED, PARTITION_ANCESOR } PartitionFlag;
typedef enum StatisticFlag {
UNKOWN_LEVEL_STATISTIC = 0,
TABLE_LEVEL_STATISTIC,
PARTITION_LEVEL_STATISTIC,
SUBPARTITION_LEVEL_STATISTIC
} StatisticFlag;
* Is the given relation a simple relation i.e a base or "other" member
* relation?
*/
#define IS_SIMPLE_REL(rel) ((rel)->reloptkind == RELOPT_BASEREL || (rel)->reloptkind == RELOPT_OTHER_MEMBER_REL)
#define IS_JOIN_REL(rel) ((rel)->reloptkind == RELOPT_JOINREL)
#define IS_UPPER_REL(rel) ((rel)->reloptkind == RELOPT_UPPER_REL)
* 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 {
NodeTag type;
List *exprs;
Index *sortgrouprefs;
QualCost cost;
int width;
} PathTarget;
typedef struct PlannerTargets {
bool final_contains_srfs;
PathTarget *final_target;
List *final_targets;
List *final_targets_contain_srfs;
bool sort_input_contains_srfs;
PathTarget *sort_input_target;
List *sort_input_targets;
List *sort_input_targets_contain_srfs;
bool have_postponed_srfs = false;
bool grouping_contains_srfs;
PathTarget *grouping_target;
List *grouping_targets;
List *grouping_targets_contain_srfs;
bool scanjoin_contains_srfs;
PathTarget *scanjoin_target;
List *scanjoin_targets;
List *scanjoin_targets_contain_srfs;
} PlannerTargets;
#define get_pathtarget_sortgroupref(target, colno) ((target)->sortgrouprefs ? (target)->sortgrouprefs[colno] : (Index)0)
#define AMFLAG_HAS_TID_RANGE (1 << 0)
typedef struct RelOptInfo {
NodeTag type;
RelOptKind reloptkind;
Relids relids;
bool isPartitionedTable;
it is a 'baserel' (reloptkind = RELOPT_BASEREL) */
PartitionFlag partflag;
double rows;
int encodedwidth;
AttrNumber encodednum;
struct PathTarget *reltarget;
List* distribute_keys;
List* pathlist;
List* ppilist;
struct Path* cheapest_gather_path;
struct Path* cheapest_startup_path;
List* cheapest_total_path;
struct Path* cheapest_total_parallel_path;
struct Path* cheapest_total_single_path;
struct Path* cheapest_unique_path;
List* cheapest_parameterized_paths;
Relids direct_lateral_relids;
Index relid;
Oid reltablespace;
RTEKind rtekind;
AttrNumber min_attr;
AttrNumber max_attr;
Relids* attr_needed;
int32* attr_widths;
List* lateral_vars;
Relids lateral_relids;
Relids lateral_referencers;
List* indexlist;
#ifndef ENABLE_MULTIPLE_NODES
List* statlist;
#endif
RelPageType pages;
double tuples;
double multiple;
double allvisfrac;
StatisticFlag statisticFlag;
struct PruningResult* pruning_result;
baserestrictinfo,it is meaningless unless it
is a 'baserel' (reloptkind = RELOPT_BASEREL) */
int partItrs;
struct PruningResult* pruning_result_for_index_usable;
int partItrs_for_index_usable;
struct PruningResult* pruning_result_for_index_unusable;
int partItrs_for_index_unusable;
BucketInfo *bucketInfo;
struct Plan* subplan;
PlannerInfo* subroot;
List *subplan_params;
Oid serverid;
Oid userid;
bool useridiscurrent;
struct FdwRoutine* fdwroutine;
void* fdw_private;
List *unique_for_rels;
List *non_unique_for_rels;
List* baserestrictinfo;
* rel) */
QualCost baserestrictcost;
Index baserestrict_min_security;
* baserestrictinfo */
List* joininfo;
* involving this rel */
bool has_eclass_joins;
Relids top_parent_relids;
RelOrientation orientation;
RelstoreType relStoreLocation;
char locator_type;
Oid rangelistOid;
List* subplanrestrictinfo;
ItstDisKey rel_dis_keys;
List* varratio;
List* varEqRatio;
bool is_ustore;
uint32 amflags;
* the table AM */
* The alternative rel for cost-based query rewrite
*
* Note: Only base rel have valid pointer of this fields, set to NULL for alternative rel
*/
List* alternatives;
* Rel opinter to base rel that in plannerinfo->simple_rel_array[x].
*
* Note: Only alternative rels has valid pointer of this field, set to NULL for the
* origin rel.
*/
RelOptInfo* base_rel;
unsigned int num_data_nodes = 0;
List* partial_pathlist;
int cursorDop;
} RelOptInfo;
* IndexOptInfo
* Per-index information for planning/optimization
*
* indexkeys[], indexcollations[], opfamily[], and opcintype[]
* each have ncolumns entries.
*
* sortopfamily[], reverse_sort[], and nulls_first[] likewise have
* ncolumns entries, if the index is ordered; but if it is unordered,
* those pointers are NULL.
*
* Zeroes in the indexkeys[] array indicate index columns that are
* expressions; there is one element in indexprs for each such column.
*
* For an ordered index, reverse_sort[] and nulls_first[] describe the
* sort ordering of a forward indexscan; we can also consider a backward
* indexscan, which will generate the reverse ordering.
*
* The indexprs and indpred expressions have been run through
* prepqual.c and eval_const_expressions() for ease of matching to
* WHERE clauses. indpred is in implicit-AND form.
*
* indextlist is a TargetEntry list representing the index columns.
* It provides an equivalent base-relation Var for each simple column,
* and links to the matching indexprs element for each expression column.
*/
typedef struct IndexOptInfo {
NodeTag type;
Oid indexoid;
bool ispartitionedindex;
Oid partitionindex;
Oid reltablespace;
RelOptInfo* rel;
RelPageType pages;
double tuples;
int ncolumns;
int nkeycolumns;
int* indexkeys;
Oid* indexcollations;
Oid* opfamily;
Oid* opcintype;
Oid* sortopfamily;
bool* reverse_sort;
bool* nulls_first;
Oid relam;
RegProcedure amcostestimate;
List* indexprs;
List* indpred;
List* indextlist;
bool isGlobal;
bool isAnnIndex;
bool crossbucket;
bool predOK;
bool unique;
bool immediate;
bool hypothetical;
bool canreturn;
bool amcanorderbyop;
bool amoptionalkey;
bool amsearcharray;
bool amsearchnulls;
bool amhasgettuple;
bool amhasgetbitmap;
List* indrestrictinfo;
} IndexOptInfo;
* EquivalenceClasses
*
* Whenever we can determine that a mergejoinable equality clause A = B is
* not delayed by any outer join, we create an EquivalenceClass containing
* the expressions A and B to record this knowledge. If we later find another
* equivalence B = C, we add C to the existing EquivalenceClass; this may
* require merging two existing EquivalenceClasses. At the end of the qual
* distribution process, we have sets of values that are known all transitively
* equal to each other, where "equal" is according to the rules of the btree
* operator family(s) shown in ec_opfamilies, as well as the collation shown
* by ec_collation. (We restrict an EC to contain only equalities whose
* operators belong to the same set of opfamilies. This could probably be
* relaxed, but for now it's not worth the trouble, since nearly all equality
* operators belong to only one btree opclass anyway. Similarly, we suppose
* that all or none of the input datatypes are collatable, so that a single
* collation value is sufficient.)
*
* We also use EquivalenceClasses as the base structure for PathKeys, letting
* us represent knowledge about different sort orderings being equivalent.
* Since every PathKey must reference an EquivalenceClass, we will end up
* with single-member EquivalenceClasses whenever a sort key expression has
* not been equivalenced to anything else. It is also possible that such an
* EquivalenceClass will contain a volatile expression ("ORDER BY random()"),
* which is a case that can't arise otherwise since clauses containing
* volatile functions are never considered mergejoinable. We mark such
* EquivalenceClasses specially to prevent them from being merged with
* ordinary EquivalenceClasses. Also, for volatile expressions we have
* to be careful to match the EquivalenceClass to the correct targetlist
* entry: consider SELECT random() AS a, random() AS b ... ORDER BY b,a.
* So we record the SortGroupRef of the originating sort clause.
*
* We allow equality clauses appearing below the nullable side of an outer join
* to form EquivalenceClasses, but these have a slightly different meaning:
* the included values might be all NULL rather than all the same non-null
* values. See src/backend/optimizer/README for more on that point.
*
* NB: if ec_merged isn't NULL, this class has been merged into another, and
* should be ignored in favor of using the pointed-to class.
*/
typedef struct EquivalenceClass {
NodeTag type;
List* ec_opfamilies;
Oid ec_collation;
List* ec_members;
List* ec_sources;
List* ec_derives;
Relids ec_relids;
bool ec_has_const;
bool ec_has_volatile;
bool ec_below_outer_join;
bool ec_group_set;
bool ec_broken;
Index ec_sortref;
Index ec_min_security;
Index ec_max_security;
struct EquivalenceClass* ec_merged;
} EquivalenceClass;
* If an EC contains a const and isn't below-outer-join, any PathKey depending
* on it must be redundant, since there's only one possible value of the key.
*/
#define EC_MUST_BE_REDUNDANT(eclass) ((eclass)->ec_has_const && !(eclass)->ec_below_outer_join)
#define IS_EC_FUNC(rte) \
(rte->rtekind == RTE_FUNCTION && (((FuncExpr*)rte->funcexpr)->funcid == ECEXTENSIONFUNCOID || \
((FuncExpr*)rte->funcexpr)->funcid == ECHADOOPFUNCOID))
* EquivalenceMember - one member expression of an EquivalenceClass
*
* em_is_child signifies that this element was built by transposing a member
* for an appendrel parent relation to represent the corresponding expression
* for an appendrel child. These members are used for determining the
* pathkeys of scans on the child relation and for explicitly sorting the
* child when necessary to build a MergeAppend path for the whole appendrel
* tree. An em_is_child member has no impact on the properties of the EC as a
* whole; in particular the EC's ec_relids field does NOT include the child
* relation. An em_is_child member should never be marked em_is_const nor
* cause ec_has_const or ec_has_volatile to be set, either. Thus, em_is_child
* members are not really full-fledged members of the EC, but just reflections
* or doppelgangers of real members. Most operations on EquivalenceClasses
* should ignore em_is_child members, and those that don't should test
* em_relids to make sure they only consider relevant members.
*
* em_datatype is usually the same as exprType(em_expr), but can be
* different when dealing with a binary-compatible opfamily; in particular
* anyarray_ops would never work without this. Use em_datatype when
* looking up a specific btree operator to work with this expression.
*/
typedef struct EquivalenceMember {
NodeTag type;
Expr* em_expr;
Relids em_relids;
Relids em_nullable_relids;
bool em_is_const;
bool em_is_child;
Oid em_datatype;
} EquivalenceMember;
* 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_strategy is either BTLessStrategyNumber (for ASC) or
* BTGreaterStrategyNumber (for DESC). We assume that all ordering-capable
* index types will use btree-compatible strategy numbers.
*/
typedef struct PathKey {
NodeTag type;
EquivalenceClass* pk_eclass;
Oid pk_opfamily;
int pk_strategy;
bool pk_nulls_first;
} PathKey;
* 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.
*/
typedef struct ParamPathInfo {
NodeTag type;
Relids ppi_req_outer;
double ppi_rows;
List* ppi_clauses;
Bitmapset* ppi_req_upper;
} 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 point 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 and UniquePaths it can be less than parent->rows, reflecting the
* fact that we've filtered by extra join conditions or removed duplicates.
*
* "pathkeys" is a List of PathKey nodes (see above), describing the sort
* ordering of the path's output rows.
*/
typedef struct Path {
NodeTag type;
NodeTag pathtype;
RelOptInfo* parent;
PathTarget *pathtarget;
ParamPathInfo* param_info;
double rows;
double multiple;
Cost startup_cost;
Cost total_cost;
Cost stream_cost;
List* pathkeys;
List* distribute_keys;
char locator_type;
RemoteQueryExecType exec_type;
Oid rangelistOid;
int dop;
Distribution distribution;
int hint_value;
double innerdistinct;
double outerdistinct;
} Path;
#define PATH_REQ_OUTER(path) ((path)->param_info ? (path)->param_info->ppi_req_outer : (Relids)NULL)
#define PATH_REQ_UPPER(path) ((path)->param_info ? (path)->param_info->ppi_req_upper : (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 index qualification clauses, with implicit
* AND semantics across the list. Each clause is a RestrictInfo node from
* the query's WHERE or JOIN conditions. An empty list implies a full
* index scan.
*
* 'indexquals' has the same structure as 'indexclauses', but it contains
* the actual index qual conditions that can be used with the index.
* In simple cases this is identical to 'indexclauses', but when special
* indexable operators appear in 'indexclauses', they are replaced by the
* derived indexscannable conditions in 'indexquals'.
*
* 'indexqualcols' is an integer list of index column numbers (zero-based)
* of the same length as 'indexquals', showing which index column each qual
* is meant to be used with. 'indexquals' is required to be ordered by
* index column, so 'indexqualcols' must form a nondecreasing sequence.
* (The order of multiple quals for the same index column is unspecified.)
*
* '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. Also, unlike the case for
* quals, 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.)
*
* 'rulesforindexgen' is a bitmapset. It is used for recording some rules which
* are satisfied in current index path. These recorded rules will be used for
* filtering paths. We can consider it as the supplement of CBO (cost based optimize).
*
* 'indexscandir' is one of:
* ForwardScanDirection: forward scan of an ordered index
* BackwardScanDirection: backward scan of an ordered index
* NoMovementScanDirection: scan of an unordered index, or don't care
* (The executor doesn't care whether it gets ForwardScanDirection or
* NoMovementScanDirection for an indexscan, but the planner wants to
* distinguish ordered from unordered indexes for building pathkeys.)
*
* '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* indexquals;
List* indexqualcols;
List* indexorderbys;
List* indexorderbycols;
int rulesforindexgen = NO_PATH_GEN_RULE;
ScanDirection indexscandir;
Cost indextotalcost;
Selectivity indexselectivity;
bool isAnnIndex;
List* annQuals;
List* annQualCols;
Cost annQualTotalCost;
Selectivity annQualSelectivity;
double annCount;
Cost allcost;
bool is_ustore;
} IndexPath;
typedef struct PartIteratorPath {
Path path;
PartitionType partType;
Path* subPath;
int itrs;
ScanDirection direction;
bool ispwj;
List* upperboundary;
List* lowerboundary;
bool needSortNode;
} PartIteratorPath;
* 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;
} 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;
Selectivity bitmapselectivity;
bool is_ustore;
} 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;
Selectivity bitmapselectivity;
bool is_ustore;
} 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)".
* Note they are bare expressions, not RestrictInfos.
*/
typedef struct TidPath {
Path path;
List* tidquals;
} TidPath;
* TidRangePath represents a scan by a continguous 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.
* NOTE: GaussDB keep an subplan other than the sub-path
*/
typedef struct SubqueryScanPath
{
Path path;
List *subplan_params;
PlannerInfo *subroot;
struct Plan *subplan;
} SubqueryScanPath;
* ForeignPath represents a potential scan of a foreign table
*
* 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_private;
} ForeignPath;
* ExtensiblePath represents a table scan 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. For example, a provider might provide GPU acceleration, a
* cache-based scan, or some other kind of logic we haven't dreamed up yet.
*
* ExtensiblePaths can be injected into the planning process for a relation by
* set_rel_pathlist_hook functions.
*
* Core code must avoid assuming that the ExtensiblePath 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 "extensible_private" field in ExtensiblePath; providers
* may prefer to use that rather than define another struct type.
*/
struct ExtensiblePath;
typedef struct ExtensiblePathMethods {
const char* ExtensibleName;
struct Plan* (*PlanExtensiblePath)(PlannerInfo* root, RelOptInfo* rel, struct ExtensiblePath* best_path,
List* tlist, List* clauses, List* extensible_plans);
} ExtensiblePathMethods;
typedef struct ExtensiblePath {
Path path;
uint32 flags;
List* extensible_paths;
List* extensible_private;
const struct ExtensiblePathMethods* methods;
} ExtensiblePath;
* AppendPath represents an Append plan, ie, successive execution of
* several member plans.
*
* 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.
*/
typedef struct AppendPath {
Path path;
List* subpaths;
} AppendPath;
#define IS_DUMMY_PATH(p) (IsA((p), AppendPath) && ((AppendPath*)(p))->subpaths == NIL)
#define IS_DUMMY_REL(r) ((r)->cheapest_total_path != NIL && IS_DUMMY_PATH(linitial((r)->cheapest_total_path)))
* MergeAppendPath represents a MergeAppend plan, ie, the merging of sorted
* results from several member plans to produce similarly-sorted output.
*/
typedef struct MergeAppendPath {
Path path;
List* subpaths;
double limit_tuples;
OpMemInfo* mem_info;
} MergeAppendPath;
* ResultPath represents use of a Result plan node to compute a variable-free
* targetlist with no underlying tables (a "SELECT expressions" query).
* The query could have a WHERE clause, too, represented by "quals".
*
* Note that quals is a list of bare clauses, not RestrictInfos.
*/
typedef struct ResultPath {
Path path;
List* quals;
Path* subpath;
List* pathqual;
bool ispulledupqual;
} ResultPath;
* 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;
bool materialize_all;
OpMemInfo mem_info;
} MaterialPath;
* UniquePath represents elimination of distinct rows from the output of
* its subpath.
*
* This is unlike the other Path nodes in that it can actually generate
* different plans: either hash-based or sort-based implementation, or a
* no-op if the input path can be proven distinct already. The decision
* is sufficiently localized that it's not worth having separate Path node
* types. (Note: in the no-op case, we could eliminate the UniquePath node
* entirely and just return the subpath; but it's convenient to have a
* UniquePath in the path tree to signal upper-level routines that the input
* is known distinct.)
*/
typedef enum {
UNIQUE_PATH_NOOP,
UNIQUE_PATH_HASH,
UNIQUE_PATH_SORT
} UniquePathMethod;
typedef struct UniquePath {
Path path;
Path* subpath;
UniquePathMethod umethod;
List* in_operators;
List* uniq_exprs;
bool both_method;
bool hold_tlist;
OpMemInfo mem_info;
} UniquePath;
* All join-type paths share these fields.
*/
typedef struct JoinPath {
Path path;
JoinType jointype;
bool inner_unique;
* than one inner tuple */
Path* outerjoinpath;
Path* innerjoinpath;
List* joinrestrictinfo;
* See the notes for RelOptInfo and ParamPathInfo to understand why
* joinrestrictinfo is needed in JoinPath, and can't be merged into the
* parent RelOptInfo.
*/
int skewoptimize;
} JoinPath;
* A nested-loop path needs no special fields.
*/
typedef JoinPath NestPath;
* 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;
bool dummypp;
} 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;
} ProjectSetPath;
* 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.
*
* 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;
List* outersortkeys;
List* innersortkeys;
bool skip_mark_restore;
bool materialize_inner;
OpMemInfo outer_mem_info;
OpMemInfo inner_mem_info;
OpMemInfo mat_mem_info;
} 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;
int num_batches;
OpMemInfo mem_info;
double joinRows;
} HashPath;
* A asofjoin 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 AsofPath {
JoinPath jpath;
List *path_hashclauses;
List *path_mergeclauses;
List *outersortkeys;
List *innersortkeys;
OpMemInfo outer_mem_info;
OpMemInfo inner_mem_info;
} AsofPath;
#ifdef PGXC
* A remotequery path represents the queries to be sent to the datanode/s
*
* When RemoteQuery plan is created from RemoteQueryPath, we build the query to
* be executed at the datanode. For building such a query, it's important to get
* the RHS relation and LHS relation of the JOIN clause. So, instead of storing
* the outer and inner paths, we find out the RHS and LHS paths and store those
* here.
*/
typedef struct RemoteQueryPath {
Path path;
ExecNodes* rqpath_en;
* If the path represents a JOIN rel, leftpath and rightpath represent the
* RemoteQuery paths for left (outer) and right (inner) side of the JOIN
* resp. jointype and join_restrictlist pertains to such JOINs.
*/
struct RemoteQueryPath* leftpath;
struct RemoteQueryPath* rightpath;
JoinType jointype;
List* join_restrictlist;
* only considered if rest of
* the JOIN information is
* available
*/
bool rqhas_unshippable_qual;
* one qual which can not be
* shipped to the datanodes
*/
bool rqhas_temp_rel;
* involved in this path is a temporary
* table.
*/
bool rqhas_unshippable_tlist;
* targetlist entry which is
* not completely shippable.
*/
} RemoteQueryPath;
#endif
* Cached bucket selectivity for hashjoin.
*
* Since bucket selectivity is limited by hashjoin bucket size, so we should only use the cache
* when bucket size is the same.
*/
typedef struct BucketSelectivity {
double nbuckets;
Selectivity bucket_size;
double ndistinct;
} BucketSelectivity;
* Cached bucket selectivity for one side of restrictinfo.
*
* Since bucket selectivity differs among different data georgraphy, so we should cache three
* stream cases for one side of restrictinfo: non-stream, broadcast, redistribute.
*/
typedef struct BucketSize {
BucketSelectivity normal;
BucketSelectivity broadcast;
BucketSelectivity redistribute;
} BucketSize;
* 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 rel, it will
* appear in the joininfo list of every RelOptInfo that describes a strict
* subset of the base rels 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 base rels it references, however.
*
* When we construct a join rel that includes all the base rels 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 base rels 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.
*
* When dealing with outer joins we have to be very careful about pushing qual
* clauses up and down the tree. An outer join's own JOIN/ON conditions must
* be evaluated exactly at that join node, unless they are "degenerate"
* conditions that reference only Vars from the nullable side of the join.
* Quals appearing in WHERE or in a JOIN above the outer join cannot be pushed
* down below the outer join, if they reference any nullable Vars.
* 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?)
*
* RestrictInfo nodes also contain an outerjoin_delayed flag, which is true
* if the clause's applicability must be delayed due to any outer joins
* appearing below it (ie, it has to be postponed to some join level higher
* than the set of relations it actually references).
*
* 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.)
*
* There is also a nullable_relids field, which is the set of rels the clause
* references that can be forced null by some outer join below the clause.
*
* outerjoin_delayed = true is subtly different from nullable_relids != NULL:
* a clause might reference some nullable rels and yet not be
* outerjoin_delayed because it also references all the other rels of the
* outer join(s). A clause that is not outerjoin_delayed can be enforced
* anywhere it is computable.
*
* 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 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.
*/
typedef struct RestrictInfo {
NodeTag type;
Expr* clause;
bool is_pushed_down;
bool outerjoin_delayed;
bool can_join;
bool pseudoconstant;
bool leakproof;
Index security_level;
Relids clause_relids;
Relids required_relids;
Relids outer_relids;
Relids nullable_relids;
Relids left_relids;
Relids right_relids;
Expr* orclause;
EquivalenceClass* parent_ec;
QualCost eval_cost;
Selectivity norm_selec;
* semantics; -1 if not yet set; >1 means a
* redundant clause */
Selectivity outer_selec;
* not yet set */
List* mergeopfamilies;
EquivalenceClass* left_ec;
EquivalenceClass* right_ec;
EquivalenceMember* left_em;
EquivalenceMember* right_em;
List* scansel_cache;
bool outer_is_left;
bool is_asof;
Oid hashjoinoperator;
BucketSize left_bucketsize;
BucketSize right_bucketsize;
} RestrictInfo;
* 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 {
Oid opfamily;
Oid collation;
int strategy;
bool nulls_first;
Selectivity leftstartsel;
Selectivity leftendsel;
Selectivity rightstartsel;
Selectivity rightendsel;
} 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. Typically the evaluation occurs below an outer
* join, and Var references above the outer join might thereby yield NULL
* instead of the expression value.
*
* 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.
*/
typedef struct PlaceHolderVar {
Expr xpr;
Expr* phexpr;
Relids phrels;
Index phid;
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 relids that must be
* available on each side when performing the special join. 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.
*
* 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 relids that are
* syntactically below this special join. (These are needed to help compute
* min_lefthand and min_righthand for higher joins.)
*
* delay_upper_joins is set TRUE if we detect a pushed-down clause that has
* to be evaluated after this join is formed (because it references the RHS).
* Any outer joins that have such a clause and this join in their RHS cannot
* commute with this join, because that would leave noplace to check the
* pushed-down clause. (We don't track this for FULL JOINs, either.)
*
* join_quals is an implicit-AND list of the quals syntactically associated
* with the join (they may or may not end up being applied at the join level).
* This is just a side list and does not drive actual application of quals.
* For JOIN_SEMI joins, this is cleared to NIL in create_unique_path() if
* the join is found not to be suitable for a uniqueify-the-RHS plan.
*
* jointype is never JOIN_RIGHT; a RIGHT JOIN is handled by switching
* the inputs to make it a LEFT JOIN. So the allowed values of jointype
* in a join_info_list member are only LEFT, FULL, SEMI, or ANTI.
*
* 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, delay_upper_joins, and
* join_quals are not set meaningfully within such structs.
*/
typedef struct SpecialJoinInfo {
NodeTag type;
Relids min_lefthand;
Relids min_righthand;
Relids syn_lefthand;
Relids syn_righthand;
JoinType jointype;
bool lhs_strict;
bool delay_upper_joins;
List* join_quals;
bool varratio_cached;
bool is_straight_join;
} SpecialJoinInfo;
* "Lateral join" info.
*
* Lateral references in subqueries constrain the join order in a way that's
* somewhat like outer joins, though different in detail. We construct one or
* more LateralJoinInfos for each RTE with lateral references, and add them to
* the PlannerInfo node's lateral_info_list.
*
* lateral_rhs is the relid of a baserel with lateral references, and
* lateral_lhs is a set of relids of baserels it references, all of which
* must be present on the LHS to compute a parameter needed by the RHS.
* Typically, lateral_lhs is a singleton, but it can include multiple rels
* if the RHS references a PlaceHolderVar with a multi-rel ph_eval_at level.
* We disallow joining to only part of the LHS in such cases, since that would
* result in a join tree with no convenient place to compute the PHV.
*
* When an appendrel contains lateral references (eg "LATERAL (SELECT x.col1
* UNION ALL SELECT y.col2)"), the LateralJoinInfos reference the parent
* baserel not the member otherrels, since it is the parent relid that is
* considered for joining purposes.
*/
typedef struct LateralJoinInfo
{
NodeTag type;
Relids lateral_lhs;
Relids lateral_rhs;
} LateralJoinInfo;
* 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 Vars referencing the parent
* into Vars referencing that child.
*
* These structs are kept in the PlannerInfo node's append_rel_list.
* Note that we just throw all the structs into one list, and scan the
* whole list when desiring to expand any one parent. We could have used
* a more complex data structure (eg, one list per parent), but this would
* be harder to update during operations such as pulling up subqueries,
* and not really any easier to scan. Considering that typical queries
* will not have many different append parents, it doesn't seem worthwhile
* to complicate things.
*
* 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 {
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;
Index child_relid;
* 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 child_reltype;
* 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;
* 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;
} AppendRelInfo;
* 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.
*
* ph_may_need is an initial estimate of ph_needed, formed using the
* syntactic locations of references to the PHV. We need this in order to
* determine whether the PHV reference forces a join ordering constraint:
* if the PHV has to be evaluated below the nullable side of an outer join,
* and then used above that outer join, we must constrain join order to ensure
* there's a valid place to evaluate the PHV below the join. The final
* actual ph_needed level might be lower than ph_may_need, but we can't
* determine that until later on. Fortunately this doesn't matter for what
* we need ph_may_need for: if there's a PHV reference syntactically
* above the outer join, it's not going to be allowed to drop below the outer
* join, so we would come to the same conclusions about join order even if
* we had the final ph_needed value to compare to.
*
* 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 {
NodeTag type;
Index phid;
PlaceHolderVar* ph_var;
Relids ph_eval_at;
Relids ph_lateral;
Relids ph_needed;
int32 ph_width;
} PlaceHolderInfo;
* For each potentially index-optimizable MIN/MAX aggregate function,
* root->minmax_aggs stores a MinMaxAggInfo describing it.
*/
typedef struct MinMaxAggInfo {
NodeTag type;
Oid aggfnoid;
Oid aggsortop;
Expr* target;
PlannerInfo* subroot;
Path* path;
Cost pathcost;
Param* param;
Aggref* aggref;
} MinMaxAggInfo;
* 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 incrementing
* root->glob->nParamExec.
*/
typedef struct PlannerParamItem {
NodeTag type;
Node* item;
int paramId;
} 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.
*
* Note: For right-semi/anti join, match_count is the fraction of the inner tuples
* that are expected to have at least one match in outer tuples.
*/
typedef struct SemiAntiJoinFactors {
Selectivity outer_match_frac;
Selectivity match_count;
} SemiAntiJoinFactors;
typedef struct JoinPathExtraData
{
bool inner_unique;
SpecialJoinInfo *sjinfo;
SemiAntiJoinFactors semifactors;
} JoinPathExtraData;
* 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 {
Cost startup_cost;
Cost total_cost;
Cost run_cost;
Cost inner_rescan_run_cost;
double outer_matched_rows;
Selectivity inner_scan_frac;
Cost inner_run_cost;
double outer_rows;
double inner_rows;
double outer_skip_rows;
double inner_skip_rows;
int numbuckets;
int numbatches;
double inner_distinct_num;
double outer_distinct_num;
OpMemInfo outer_mem_info;
OpMemInfo inner_mem_info;
} JoinCostWorkspace;
#endif
