74 double dNumGroups,
double dNumOutputRows,
75 const char *construct);
81 List *refnames_tlist);
85 List *refnames_tlist);
109 Query *leftmostQuery;
148 leftmostQuery = leftmostRTE->
subquery;
149 Assert(leftmostQuery != NULL);
169 topop->colTypes, topop->colCollations,
208 List *colTypes,
List *colCollations,
249 elog(
ERROR,
"unexpected outer reference in set operation subquery");
261 *pTargetList = tlist;
306 Path *partial_subpath;
310 partial_path = (
Path *)
359 *pNumGroups = rel->
rows;
420 elog(
ERROR,
"unrecognized node type: %d",
435 List *refnames_tlist,
452 elog(
ERROR,
"only UNION queries can be recursive");
485 *pTargetList = tlist;
508 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
509 errmsg(
"could not implement recursive UNION"),
510 errdetail(
"All column datatypes must be hashable.")));
516 dNumGroups = lpath->
rows + rpath->
rows * 10;
541 List *refnames_tlist,
550 bool partial_paths_valid =
true;
551 bool consider_parallel =
true;
587 tlist_list, refnames_tlist);
589 *pTargetList = tlist;
598 if (consider_parallel)
602 consider_parallel =
false;
603 partial_paths_valid =
false;
606 partial_paths_valid =
false;
608 partial_pathlist =
lappend(partial_pathlist,
624 NIL, NULL, 0,
false, -1);
646 if (partial_paths_valid)
650 int parallel_workers = 0;
653 foreach(lc, partial_pathlist)
659 Assert(parallel_workers > 0);
670 parallel_workers =
Max(parallel_workers,
672 parallel_workers =
Min(parallel_workers,
675 Assert(parallel_workers > 0);
701 List *refnames_tlist,
758 tlist_list =
list_make2(lpath_tlist, rpath_tlist);
764 tlist_list =
list_make2(rpath_tlist, lpath_tlist);
778 tlist_list, refnames_tlist);
780 *pTargetList = tlist;
791 NIL, NULL, 0,
false, -1);
806 dNumGroups = dLeftGroups;
807 dNumOutputRows = op->
all ? lpath->
rows : dNumGroups;
811 dNumGroups =
Min(dLeftGroups, dRightGroups);
812 dNumOutputRows = op->
all ?
Min(lpath->
rows, rpath->
rows) : dNumGroups;
819 dNumGroups, dNumOutputRows,
822 if (groupList && !use_hash)
843 elog(
ERROR,
"unrecognized set op: %d", (
int) op->
op);
854 use_hash ? firstFlag : -1,
879 List *refnames_tlist,
888 while (pending_rels !=
NIL)
898 if (op->
op == top_union->
op &&
899 (op->
all == top_union->
all || op->
all) &&
903 pending_rels =
lcons(op->
rarg, pending_rels);
904 pending_rels =
lcons(op->
larg, pending_rels);
926 *tlist_list =
lappend(*tlist_list, child_tlist);
953 dNumGroups = path->
rows;
957 dNumGroups, dNumGroups,
1018 double dNumGroups,
double dNumOutputRows,
1019 const char *construct)
1028 double tuple_fraction;
1033 if (can_hash && can_sort)
1043 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1045 errmsg(
"could not implement %s", construct),
1046 errdetail(
"Some of the datatypes only support hashing, while others only support sorting.")));
1058 if (hashentrysize * dNumGroups > hash_mem_limit)
1073 numGroupCols, dNumGroups,
1088 cost_group(&sorted_p, root, numGroupCols, dNumGroups,
1098 if (tuple_fraction >= 1.0)
1099 tuple_fraction /= dNumOutputRows;
1102 tuple_fraction) < 0)
1125 bool hack_constants,
1127 List *refnames_tlist)
1138 forfour(ctlc, colTypes, cclc, colCollations,
1139 itlc, input_tlist, rtlc, refnames_tlist)
1187 "UNION/INTERSECT/EXCEPT");
1263 List *refnames_tlist)
1284 foreach(tlistl, input_tlists)
1291 foreach(subtlistl, subtlist)
1297 Assert(curColType != NULL);
1304 colTypmods[colindex] = subtypmod;
1305 else if (subtypmod != colTypmods[colindex])
1306 colTypmods[colindex] = -1;
1311 colTypmods[colindex] = -1;
1313 curColType =
lnext(colTypes, curColType);
1316 Assert(curColType == NULL);
1323 forthree(curColType, colTypes, curColCollation, colCollations,
1324 ref_tl_item, refnames_tlist)
1327 int32 colTypmod = colTypmods[colindex++];
1395 foreach(lt, targetlist)
1413 lg =
lnext(grouplist, lg);
Bitmapset * bms_union(const Bitmapset *a, const Bitmapset *b)
bool bms_is_empty(const Bitmapset *a)
int max_parallel_workers_per_gather
void cost_agg(Path *path, PlannerInfo *root, AggStrategy aggstrategy, const AggClauseCosts *aggcosts, int numGroupCols, double numGroups, List *quals, Cost input_startup_cost, Cost input_total_cost, double input_tuples, double input_width)
void set_subquery_size_estimates(PlannerInfo *root, RelOptInfo *rel)
bool enable_parallel_append
void cost_sort(Path *path, PlannerInfo *root, List *pathkeys, Cost input_cost, double tuples, int width, Cost comparison_cost, int sort_mem, double limit_tuples)
void cost_group(Path *path, PlannerInfo *root, int numGroupCols, double numGroups, List *quals, Cost input_startup_cost, Cost input_total_cost, double input_tuples)
int errdetail(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
bool equal(const void *a, const void *b)
#define SizeofMinimalTupleHeader
Assert(fmt[strlen(fmt) - 1] !='\n')
List * lappend(List *list, void *datum)
List * list_delete_first(List *list)
List * lcons(void *datum, List *list)
Datum subpath(PG_FUNCTION_ARGS)
TargetEntry * makeTargetEntry(Expr *expr, AttrNumber resno, char *resname, bool resjunk)
Const * makeConst(Oid consttype, int32 consttypmod, Oid constcollid, int constlen, Datum constvalue, bool constisnull, bool constbyval)
Var * makeVar(int varno, AttrNumber varattno, Oid vartype, int32 vartypmod, Oid varcollid, Index varlevelsup)
char * pstrdup(const char *in)
void pfree(void *pointer)
Oid exprType(const Node *expr)
int32 exprTypmod(const Node *expr)
Oid exprCollation(const Node *expr)
Node * applyRelabelType(Node *arg, Oid rtype, int32 rtypmod, Oid rcollid, CoercionForm rformat, int rlocation, bool overwrite_ok)
size_t get_hash_memory_limit(void)
#define IsA(nodeptr, _type_)
#define castNode(_type_, nodeptr)
Node * coerce_to_common_type(ParseState *pstate, Node *node, Oid targetTypeId, const char *context)
List * make_pathkeys_for_sortclauses(PlannerInfo *root, List *sortclauses, List *tlist)
AppendPath * create_append_path(PlannerInfo *root, RelOptInfo *rel, List *subpaths, List *partial_subpaths, List *pathkeys, Relids required_outer, int parallel_workers, bool parallel_aware, double rows)
SortPath * create_sort_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *pathkeys, double limit_tuples)
ProjectionPath * create_projection_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target)
UpperUniquePath * create_upper_unique_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, int numCols, double numGroups)
GatherPath * create_gather_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, Relids required_outer, double *rows)
void set_cheapest(RelOptInfo *parent_rel)
void add_partial_path(RelOptInfo *parent_rel, Path *new_path)
int compare_fractional_path_costs(Path *path1, Path *path2, double fraction)
SetOpPath * create_setop_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, SetOpCmd cmd, SetOpStrategy strategy, List *distinctList, AttrNumber flagColIdx, int firstFlag, double numGroups, double outputRows)
SubqueryScanPath * create_subqueryscan_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *pathkeys, Relids required_outer)
RecursiveUnionPath * create_recursiveunion_path(PlannerInfo *root, RelOptInfo *rel, Path *leftpath, Path *rightpath, PathTarget *target, List *distinctList, int wtParam, double numGroups)
AggPath * create_agg_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, AggStrategy aggstrategy, AggSplit aggsplit, List *groupClause, List *qual, const AggClauseCosts *aggcosts, double numGroups)
void add_path(RelOptInfo *parent_rel, Path *new_path)
Path * apply_projection_to_path(PlannerInfo *root, RelOptInfo *rel, Path *path, PathTarget *target)
static int list_length(const List *l)
#define forthree(cell1, list1, cell2, list2, cell3, list3)
static ListCell * list_head(const List *l)
#define forfour(cell1, list1, cell2, list2, cell3, list3, cell4, list4)
static ListCell * lnext(const List *l, const ListCell *c)
#define list_make2(x1, x2)
PlannerInfo * subquery_planner(PlannerGlobal *glob, Query *parse, PlannerInfo *parent_root, bool hasRecursion, double tuple_fraction)
create_upper_paths_hook_type create_upper_paths_hook
Path * get_cheapest_fractional_path(RelOptInfo *rel, double tuple_fraction)
void check_stack_depth(void)
static Path * make_union_unique(SetOperationStmt *op, Path *path, List *tlist, PlannerInfo *root)
static List * generate_setop_grouplist(SetOperationStmt *op, List *targetlist)
static RelOptInfo * generate_union_paths(SetOperationStmt *op, PlannerInfo *root, List *refnames_tlist, List **pTargetList)
static List * plan_union_children(PlannerInfo *root, SetOperationStmt *top_union, List *refnames_tlist, List **tlist_list)
static RelOptInfo * generate_nonunion_paths(SetOperationStmt *op, PlannerInfo *root, List *refnames_tlist, List **pTargetList)
static void postprocess_setop_rel(PlannerInfo *root, RelOptInfo *rel)
static bool choose_hashed_setop(PlannerInfo *root, List *groupClauses, Path *input_path, double dNumGroups, double dNumOutputRows, const char *construct)
static List * generate_append_tlist(List *colTypes, List *colCollations, bool flag, List *input_tlists, List *refnames_tlist)
static RelOptInfo * generate_recursion_path(SetOperationStmt *setOp, PlannerInfo *root, List *refnames_tlist, List **pTargetList)
static RelOptInfo * recurse_set_operations(Node *setOp, PlannerInfo *root, List *colTypes, List *colCollations, bool junkOK, int flag, List *refnames_tlist, List **pTargetList, double *pNumGroups)
static List * generate_setop_tlist(List *colTypes, List *colCollations, int flag, Index varno, bool hack_constants, List *input_tlist, List *refnames_tlist)
RelOptInfo * plan_set_operations(PlannerInfo *root)
static struct subre * parse(struct vars *, int, int, struct state *, struct state *)
void setup_simple_rel_arrays(PlannerInfo *root)
RelOptInfo * build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
RelOptInfo * fetch_upper_rel(PlannerInfo *root, UpperRelationKind kind, Relids relids)
double estimate_num_groups(PlannerInfo *root, List *groupExprs, double input_rows, List **pgset, EstimationInfo *estinfo)
struct Path * non_recursive_path
RangeTblEntry ** simple_rte_array
Selectivity tuple_fraction
struct PathTarget * reltarget
struct Path * cheapest_total_path
bool tlist_same_collations(List *tlist, List *colCollations, bool junkOK)
List * get_tlist_exprs(List *tlist, bool includeJunk)
bool grouping_is_sortable(List *groupClause)
bool grouping_is_hashable(List *groupClause)
bool tlist_same_datatypes(List *tlist, List *colTypes, bool junkOK)
#define create_pathtarget(root, tlist)