mirror of
https://github.com/postgres/postgres.git
synced 2025-09-06 13:46:51 +03:00
Phase 2 pgindent run for v12.
Switch to 2.1 version of pg_bsd_indent. This formats multiline function declarations "correctly", that is with additional lines of parameter declarations indented to match where the first line's left parenthesis is. Discussion: https://postgr.es/m/CAEepm=0P3FeTXRcU5B2W3jv3PgRVZ-kGUXLGfd42FFhUROO3ug@mail.gmail.com
This commit is contained in:
Tom Lane
@@ -40,9 +40,9 @@ typedef struct
|
||||
} Clump;
|
||||
|
||||
static List *merge_clump(PlannerInfo *root, List *clumps, Clump *new_clump,
|
||||
int num_gene, bool force);
|
||||
int num_gene, bool force);
|
||||
static bool desirable_join(PlannerInfo *root,
|
||||
RelOptInfo *outer_rel, RelOptInfo *inner_rel);
|
||||
RelOptInfo *outer_rel, RelOptInfo *inner_rel);
|
||||
|
||||
|
||||
/*
|
||||
|
||||
@@ -75,71 +75,71 @@ static void set_base_rel_consider_startup(PlannerInfo *root);
|
||||
static void set_base_rel_sizes(PlannerInfo *root);
|
||||
static void set_base_rel_pathlists(PlannerInfo *root);
|
||||
static void set_rel_size(PlannerInfo *root, RelOptInfo *rel,
|
||||
Index rti, RangeTblEntry *rte);
|
||||
Index rti, RangeTblEntry *rte);
|
||||
static void set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
Index rti, RangeTblEntry *rte);
|
||||
Index rti, RangeTblEntry *rte);
|
||||
static void set_plain_rel_size(PlannerInfo *root, RelOptInfo *rel,
|
||||
RangeTblEntry *rte);
|
||||
RangeTblEntry *rte);
|
||||
static void create_plain_partial_paths(PlannerInfo *root, RelOptInfo *rel);
|
||||
static void set_rel_consider_parallel(PlannerInfo *root, RelOptInfo *rel,
|
||||
RangeTblEntry *rte);
|
||||
RangeTblEntry *rte);
|
||||
static void set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
RangeTblEntry *rte);
|
||||
RangeTblEntry *rte);
|
||||
static void set_tablesample_rel_size(PlannerInfo *root, RelOptInfo *rel,
|
||||
RangeTblEntry *rte);
|
||||
RangeTblEntry *rte);
|
||||
static void set_tablesample_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
RangeTblEntry *rte);
|
||||
RangeTblEntry *rte);
|
||||
static void set_foreign_size(PlannerInfo *root, RelOptInfo *rel,
|
||||
RangeTblEntry *rte);
|
||||
RangeTblEntry *rte);
|
||||
static void set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
RangeTblEntry *rte);
|
||||
RangeTblEntry *rte);
|
||||
static void set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
|
||||
Index rti, RangeTblEntry *rte);
|
||||
Index rti, RangeTblEntry *rte);
|
||||
static void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
Index rti, RangeTblEntry *rte);
|
||||
Index rti, RangeTblEntry *rte);
|
||||
static void generate_orderedappend_paths(PlannerInfo *root, RelOptInfo *rel,
|
||||
List *live_childrels,
|
||||
List *all_child_pathkeys,
|
||||
List *partitioned_rels);
|
||||
List *live_childrels,
|
||||
List *all_child_pathkeys,
|
||||
List *partitioned_rels);
|
||||
static Path *get_cheapest_parameterized_child_path(PlannerInfo *root,
|
||||
RelOptInfo *rel,
|
||||
Relids required_outer);
|
||||
RelOptInfo *rel,
|
||||
Relids required_outer);
|
||||
static void accumulate_append_subpath(Path *path,
|
||||
List **subpaths, List **special_subpaths);
|
||||
List **subpaths, List **special_subpaths);
|
||||
static Path *get_singleton_append_subpath(Path *path);
|
||||
static void set_dummy_rel_pathlist(RelOptInfo *rel);
|
||||
static void set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
Index rti, RangeTblEntry *rte);
|
||||
Index rti, RangeTblEntry *rte);
|
||||
static void set_function_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
RangeTblEntry *rte);
|
||||
RangeTblEntry *rte);
|
||||
static void set_values_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
RangeTblEntry *rte);
|
||||
RangeTblEntry *rte);
|
||||
static void set_tablefunc_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
RangeTblEntry *rte);
|
||||
RangeTblEntry *rte);
|
||||
static void set_cte_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
RangeTblEntry *rte);
|
||||
static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
RangeTblEntry *rte);
|
||||
static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
RangeTblEntry *rte);
|
||||
static void set_result_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
RangeTblEntry *rte);
|
||||
RangeTblEntry *rte);
|
||||
static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
RangeTblEntry *rte);
|
||||
RangeTblEntry *rte);
|
||||
static RelOptInfo *make_rel_from_joinlist(PlannerInfo *root, List *joinlist);
|
||||
static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery,
|
||||
pushdown_safety_info *safetyInfo);
|
||||
pushdown_safety_info *safetyInfo);
|
||||
static bool recurse_pushdown_safe(Node *setOp, Query *topquery,
|
||||
pushdown_safety_info *safetyInfo);
|
||||
pushdown_safety_info *safetyInfo);
|
||||
static void check_output_expressions(Query *subquery,
|
||||
pushdown_safety_info *safetyInfo);
|
||||
pushdown_safety_info *safetyInfo);
|
||||
static void compare_tlist_datatypes(List *tlist, List *colTypes,
|
||||
pushdown_safety_info *safetyInfo);
|
||||
pushdown_safety_info *safetyInfo);
|
||||
static bool targetIsInAllPartitionLists(TargetEntry *tle, Query *query);
|
||||
static bool qual_is_pushdown_safe(Query *subquery, Index rti, Node *qual,
|
||||
pushdown_safety_info *safetyInfo);
|
||||
pushdown_safety_info *safetyInfo);
|
||||
static void subquery_push_qual(Query *subquery,
|
||||
RangeTblEntry *rte, Index rti, Node *qual);
|
||||
RangeTblEntry *rte, Index rti, Node *qual);
|
||||
static void recurse_push_qual(Node *setOp, Query *topquery,
|
||||
RangeTblEntry *rte, Index rti, Node *qual);
|
||||
RangeTblEntry *rte, Index rti, Node *qual);
|
||||
static void remove_unused_subquery_outputs(Query *subquery, RelOptInfo *rel);
|
||||
|
||||
|
||||
|
||||
@@ -42,9 +42,9 @@ typedef struct RangeQueryClause
|
||||
} RangeQueryClause;
|
||||
|
||||
static void addRangeClause(RangeQueryClause **rqlist, Node *clause,
|
||||
bool varonleft, bool isLTsel, Selectivity s2);
|
||||
bool varonleft, bool isLTsel, Selectivity s2);
|
||||
static RelOptInfo *find_single_rel_for_clauses(PlannerInfo *root,
|
||||
List *clauses);
|
||||
List *clauses);
|
||||
|
||||
/****************************************************************************
|
||||
* ROUTINES TO COMPUTE SELECTIVITIES
|
||||
|
||||
@@ -147,32 +147,32 @@ typedef struct
|
||||
|
||||
static List *extract_nonindex_conditions(List *qual_clauses, List *indexclauses);
|
||||
static MergeScanSelCache *cached_scansel(PlannerInfo *root,
|
||||
RestrictInfo *rinfo,
|
||||
PathKey *pathkey);
|
||||
RestrictInfo *rinfo,
|
||||
PathKey *pathkey);
|
||||
static void cost_rescan(PlannerInfo *root, Path *path,
|
||||
Cost *rescan_startup_cost, Cost *rescan_total_cost);
|
||||
Cost *rescan_startup_cost, Cost *rescan_total_cost);
|
||||
static bool cost_qual_eval_walker(Node *node, cost_qual_eval_context *context);
|
||||
static void get_restriction_qual_cost(PlannerInfo *root, RelOptInfo *baserel,
|
||||
ParamPathInfo *param_info,
|
||||
QualCost *qpqual_cost);
|
||||
ParamPathInfo *param_info,
|
||||
QualCost *qpqual_cost);
|
||||
static bool has_indexed_join_quals(NestPath *joinpath);
|
||||
static double approx_tuple_count(PlannerInfo *root, JoinPath *path,
|
||||
List *quals);
|
||||
List *quals);
|
||||
static double calc_joinrel_size_estimate(PlannerInfo *root,
|
||||
RelOptInfo *joinrel,
|
||||
RelOptInfo *outer_rel,
|
||||
RelOptInfo *inner_rel,
|
||||
double outer_rows,
|
||||
double inner_rows,
|
||||
SpecialJoinInfo *sjinfo,
|
||||
List *restrictlist);
|
||||
RelOptInfo *joinrel,
|
||||
RelOptInfo *outer_rel,
|
||||
RelOptInfo *inner_rel,
|
||||
double outer_rows,
|
||||
double inner_rows,
|
||||
SpecialJoinInfo *sjinfo,
|
||||
List *restrictlist);
|
||||
static Selectivity get_foreign_key_join_selectivity(PlannerInfo *root,
|
||||
Relids outer_relids,
|
||||
Relids inner_relids,
|
||||
SpecialJoinInfo *sjinfo,
|
||||
List **restrictlist);
|
||||
Relids outer_relids,
|
||||
Relids inner_relids,
|
||||
SpecialJoinInfo *sjinfo,
|
||||
List **restrictlist);
|
||||
static Cost append_nonpartial_cost(List *subpaths, int numpaths,
|
||||
int parallel_workers);
|
||||
int parallel_workers);
|
||||
static void set_rel_width(PlannerInfo *root, RelOptInfo *rel);
|
||||
static double relation_byte_size(double tuples, int width);
|
||||
static double page_size(double tuples, int width);
|
||||
|
||||
@@ -33,37 +33,37 @@
|
||||
|
||||
|
||||
static EquivalenceMember *add_eq_member(EquivalenceClass *ec,
|
||||
Expr *expr, Relids relids, Relids nullable_relids,
|
||||
bool is_child, Oid datatype);
|
||||
Expr *expr, Relids relids, Relids nullable_relids,
|
||||
bool is_child, Oid datatype);
|
||||
static void generate_base_implied_equalities_const(PlannerInfo *root,
|
||||
EquivalenceClass *ec);
|
||||
EquivalenceClass *ec);
|
||||
static void generate_base_implied_equalities_no_const(PlannerInfo *root,
|
||||
EquivalenceClass *ec);
|
||||
EquivalenceClass *ec);
|
||||
static void generate_base_implied_equalities_broken(PlannerInfo *root,
|
||||
EquivalenceClass *ec);
|
||||
EquivalenceClass *ec);
|
||||
static List *generate_join_implied_equalities_normal(PlannerInfo *root,
|
||||
EquivalenceClass *ec,
|
||||
Relids join_relids,
|
||||
Relids outer_relids,
|
||||
Relids inner_relids);
|
||||
EquivalenceClass *ec,
|
||||
Relids join_relids,
|
||||
Relids outer_relids,
|
||||
Relids inner_relids);
|
||||
static List *generate_join_implied_equalities_broken(PlannerInfo *root,
|
||||
EquivalenceClass *ec,
|
||||
Relids nominal_join_relids,
|
||||
Relids outer_relids,
|
||||
Relids nominal_inner_relids,
|
||||
RelOptInfo *inner_rel);
|
||||
static Oid select_equality_operator(EquivalenceClass *ec,
|
||||
Oid lefttype, Oid righttype);
|
||||
EquivalenceClass *ec,
|
||||
Relids nominal_join_relids,
|
||||
Relids outer_relids,
|
||||
Relids nominal_inner_relids,
|
||||
RelOptInfo *inner_rel);
|
||||
static Oid select_equality_operator(EquivalenceClass *ec,
|
||||
Oid lefttype, Oid righttype);
|
||||
static RestrictInfo *create_join_clause(PlannerInfo *root,
|
||||
EquivalenceClass *ec, Oid opno,
|
||||
EquivalenceMember *leftem,
|
||||
EquivalenceMember *rightem,
|
||||
EquivalenceClass *parent_ec);
|
||||
EquivalenceClass *ec, Oid opno,
|
||||
EquivalenceMember *leftem,
|
||||
EquivalenceMember *rightem,
|
||||
EquivalenceClass *parent_ec);
|
||||
static bool reconsider_outer_join_clause(PlannerInfo *root,
|
||||
RestrictInfo *rinfo,
|
||||
bool outer_on_left);
|
||||
RestrictInfo *rinfo,
|
||||
bool outer_on_left);
|
||||
static bool reconsider_full_join_clause(PlannerInfo *root,
|
||||
RestrictInfo *rinfo);
|
||||
RestrictInfo *rinfo);
|
||||
|
||||
|
||||
/*
|
||||
|
||||
@@ -75,120 +75,120 @@ typedef struct
|
||||
|
||||
|
||||
static void consider_index_join_clauses(PlannerInfo *root, RelOptInfo *rel,
|
||||
IndexOptInfo *index,
|
||||
IndexClauseSet *rclauseset,
|
||||
IndexClauseSet *jclauseset,
|
||||
IndexClauseSet *eclauseset,
|
||||
List **bitindexpaths);
|
||||
IndexOptInfo *index,
|
||||
IndexClauseSet *rclauseset,
|
||||
IndexClauseSet *jclauseset,
|
||||
IndexClauseSet *eclauseset,
|
||||
List **bitindexpaths);
|
||||
static void consider_index_join_outer_rels(PlannerInfo *root, RelOptInfo *rel,
|
||||
IndexOptInfo *index,
|
||||
IndexClauseSet *rclauseset,
|
||||
IndexClauseSet *jclauseset,
|
||||
IndexClauseSet *eclauseset,
|
||||
List **bitindexpaths,
|
||||
List *indexjoinclauses,
|
||||
int considered_clauses,
|
||||
List **considered_relids);
|
||||
IndexOptInfo *index,
|
||||
IndexClauseSet *rclauseset,
|
||||
IndexClauseSet *jclauseset,
|
||||
IndexClauseSet *eclauseset,
|
||||
List **bitindexpaths,
|
||||
List *indexjoinclauses,
|
||||
int considered_clauses,
|
||||
List **considered_relids);
|
||||
static void get_join_index_paths(PlannerInfo *root, RelOptInfo *rel,
|
||||
IndexOptInfo *index,
|
||||
IndexClauseSet *rclauseset,
|
||||
IndexClauseSet *jclauseset,
|
||||
IndexClauseSet *eclauseset,
|
||||
List **bitindexpaths,
|
||||
Relids relids,
|
||||
List **considered_relids);
|
||||
IndexOptInfo *index,
|
||||
IndexClauseSet *rclauseset,
|
||||
IndexClauseSet *jclauseset,
|
||||
IndexClauseSet *eclauseset,
|
||||
List **bitindexpaths,
|
||||
Relids relids,
|
||||
List **considered_relids);
|
||||
static bool eclass_already_used(EquivalenceClass *parent_ec, Relids oldrelids,
|
||||
List *indexjoinclauses);
|
||||
List *indexjoinclauses);
|
||||
static bool bms_equal_any(Relids relids, List *relids_list);
|
||||
static void get_index_paths(PlannerInfo *root, RelOptInfo *rel,
|
||||
IndexOptInfo *index, IndexClauseSet *clauses,
|
||||
List **bitindexpaths);
|
||||
IndexOptInfo *index, IndexClauseSet *clauses,
|
||||
List **bitindexpaths);
|
||||
static List *build_index_paths(PlannerInfo *root, RelOptInfo *rel,
|
||||
IndexOptInfo *index, IndexClauseSet *clauses,
|
||||
bool useful_predicate,
|
||||
ScanTypeControl scantype,
|
||||
bool *skip_nonnative_saop,
|
||||
bool *skip_lower_saop);
|
||||
IndexOptInfo *index, IndexClauseSet *clauses,
|
||||
bool useful_predicate,
|
||||
ScanTypeControl scantype,
|
||||
bool *skip_nonnative_saop,
|
||||
bool *skip_lower_saop);
|
||||
static List *build_paths_for_OR(PlannerInfo *root, RelOptInfo *rel,
|
||||
List *clauses, List *other_clauses);
|
||||
List *clauses, List *other_clauses);
|
||||
static List *generate_bitmap_or_paths(PlannerInfo *root, RelOptInfo *rel,
|
||||
List *clauses, List *other_clauses);
|
||||
List *clauses, List *other_clauses);
|
||||
static Path *choose_bitmap_and(PlannerInfo *root, RelOptInfo *rel,
|
||||
List *paths);
|
||||
List *paths);
|
||||
static int path_usage_comparator(const void *a, const void *b);
|
||||
static Cost bitmap_scan_cost_est(PlannerInfo *root, RelOptInfo *rel,
|
||||
Path *ipath);
|
||||
Path *ipath);
|
||||
static Cost bitmap_and_cost_est(PlannerInfo *root, RelOptInfo *rel,
|
||||
List *paths);
|
||||
List *paths);
|
||||
static PathClauseUsage *classify_index_clause_usage(Path *path,
|
||||
List **clauselist);
|
||||
List **clauselist);
|
||||
static Relids get_bitmap_tree_required_outer(Path *bitmapqual);
|
||||
static void find_indexpath_quals(Path *bitmapqual, List **quals, List **preds);
|
||||
static int find_list_position(Node *node, List **nodelist);
|
||||
static bool check_index_only(RelOptInfo *rel, IndexOptInfo *index);
|
||||
static double get_loop_count(PlannerInfo *root, Index cur_relid, Relids outer_relids);
|
||||
static double adjust_rowcount_for_semijoins(PlannerInfo *root,
|
||||
Index cur_relid,
|
||||
Index outer_relid,
|
||||
double rowcount);
|
||||
Index cur_relid,
|
||||
Index outer_relid,
|
||||
double rowcount);
|
||||
static double approximate_joinrel_size(PlannerInfo *root, Relids relids);
|
||||
static void match_restriction_clauses_to_index(PlannerInfo *root,
|
||||
IndexOptInfo *index,
|
||||
IndexClauseSet *clauseset);
|
||||
static void match_join_clauses_to_index(PlannerInfo *root,
|
||||
RelOptInfo *rel, IndexOptInfo *index,
|
||||
IndexClauseSet *clauseset,
|
||||
List **joinorclauses);
|
||||
static void match_eclass_clauses_to_index(PlannerInfo *root,
|
||||
IndexOptInfo *index,
|
||||
IndexClauseSet *clauseset);
|
||||
static void match_clauses_to_index(PlannerInfo *root,
|
||||
List *clauses,
|
||||
IndexOptInfo *index,
|
||||
IndexClauseSet *clauseset);
|
||||
static void match_join_clauses_to_index(PlannerInfo *root,
|
||||
RelOptInfo *rel, IndexOptInfo *index,
|
||||
IndexClauseSet *clauseset,
|
||||
List **joinorclauses);
|
||||
static void match_eclass_clauses_to_index(PlannerInfo *root,
|
||||
IndexOptInfo *index,
|
||||
IndexClauseSet *clauseset);
|
||||
static void match_clauses_to_index(PlannerInfo *root,
|
||||
List *clauses,
|
||||
IndexOptInfo *index,
|
||||
IndexClauseSet *clauseset);
|
||||
static void match_clause_to_index(PlannerInfo *root,
|
||||
RestrictInfo *rinfo,
|
||||
IndexOptInfo *index,
|
||||
IndexClauseSet *clauseset);
|
||||
RestrictInfo *rinfo,
|
||||
IndexOptInfo *index,
|
||||
IndexClauseSet *clauseset);
|
||||
static IndexClause *match_clause_to_indexcol(PlannerInfo *root,
|
||||
RestrictInfo *rinfo,
|
||||
int indexcol,
|
||||
IndexOptInfo *index);
|
||||
RestrictInfo *rinfo,
|
||||
int indexcol,
|
||||
IndexOptInfo *index);
|
||||
static IndexClause *match_boolean_index_clause(RestrictInfo *rinfo,
|
||||
int indexcol, IndexOptInfo *index);
|
||||
int indexcol, IndexOptInfo *index);
|
||||
static IndexClause *match_opclause_to_indexcol(PlannerInfo *root,
|
||||
RestrictInfo *rinfo,
|
||||
int indexcol,
|
||||
IndexOptInfo *index);
|
||||
RestrictInfo *rinfo,
|
||||
int indexcol,
|
||||
IndexOptInfo *index);
|
||||
static IndexClause *match_funcclause_to_indexcol(PlannerInfo *root,
|
||||
RestrictInfo *rinfo,
|
||||
int indexcol,
|
||||
IndexOptInfo *index);
|
||||
RestrictInfo *rinfo,
|
||||
int indexcol,
|
||||
IndexOptInfo *index);
|
||||
static IndexClause *get_index_clause_from_support(PlannerInfo *root,
|
||||
RestrictInfo *rinfo,
|
||||
Oid funcid,
|
||||
int indexarg,
|
||||
int indexcol,
|
||||
IndexOptInfo *index);
|
||||
RestrictInfo *rinfo,
|
||||
Oid funcid,
|
||||
int indexarg,
|
||||
int indexcol,
|
||||
IndexOptInfo *index);
|
||||
static IndexClause *match_saopclause_to_indexcol(RestrictInfo *rinfo,
|
||||
int indexcol,
|
||||
IndexOptInfo *index);
|
||||
int indexcol,
|
||||
IndexOptInfo *index);
|
||||
static IndexClause *match_rowcompare_to_indexcol(RestrictInfo *rinfo,
|
||||
int indexcol,
|
||||
IndexOptInfo *index);
|
||||
int indexcol,
|
||||
IndexOptInfo *index);
|
||||
static IndexClause *expand_indexqual_rowcompare(RestrictInfo *rinfo,
|
||||
int indexcol,
|
||||
IndexOptInfo *index,
|
||||
Oid expr_op,
|
||||
bool var_on_left);
|
||||
int indexcol,
|
||||
IndexOptInfo *index,
|
||||
Oid expr_op,
|
||||
bool var_on_left);
|
||||
static void match_pathkeys_to_index(IndexOptInfo *index, List *pathkeys,
|
||||
List **orderby_clauses_p,
|
||||
List **clause_columns_p);
|
||||
List **orderby_clauses_p,
|
||||
List **clause_columns_p);
|
||||
static Expr *match_clause_to_ordering_op(IndexOptInfo *index,
|
||||
int indexcol, Expr *clause, Oid pk_opfamily);
|
||||
int indexcol, Expr *clause, Oid pk_opfamily);
|
||||
static bool ec_member_matches_indexcol(PlannerInfo *root, RelOptInfo *rel,
|
||||
EquivalenceClass *ec, EquivalenceMember *em,
|
||||
void *arg);
|
||||
EquivalenceClass *ec, EquivalenceMember *em,
|
||||
void *arg);
|
||||
|
||||
|
||||
/*
|
||||
|
||||
@@ -40,54 +40,54 @@ set_join_pathlist_hook_type set_join_pathlist_hook = NULL;
|
||||
(PATH_PARAM_BY_REL_SELF(path, rel) || PATH_PARAM_BY_PARENT(path, rel))
|
||||
|
||||
static void try_partial_mergejoin_path(PlannerInfo *root,
|
||||
RelOptInfo *joinrel,
|
||||
Path *outer_path,
|
||||
Path *inner_path,
|
||||
List *pathkeys,
|
||||
List *mergeclauses,
|
||||
List *outersortkeys,
|
||||
List *innersortkeys,
|
||||
JoinType jointype,
|
||||
JoinPathExtraData *extra);
|
||||
RelOptInfo *joinrel,
|
||||
Path *outer_path,
|
||||
Path *inner_path,
|
||||
List *pathkeys,
|
||||
List *mergeclauses,
|
||||
List *outersortkeys,
|
||||
List *innersortkeys,
|
||||
JoinType jointype,
|
||||
JoinPathExtraData *extra);
|
||||
static void sort_inner_and_outer(PlannerInfo *root, RelOptInfo *joinrel,
|
||||
RelOptInfo *outerrel, RelOptInfo *innerrel,
|
||||
JoinType jointype, JoinPathExtraData *extra);
|
||||
RelOptInfo *outerrel, RelOptInfo *innerrel,
|
||||
JoinType jointype, JoinPathExtraData *extra);
|
||||
static void match_unsorted_outer(PlannerInfo *root, RelOptInfo *joinrel,
|
||||
RelOptInfo *outerrel, RelOptInfo *innerrel,
|
||||
JoinType jointype, JoinPathExtraData *extra);
|
||||
RelOptInfo *outerrel, RelOptInfo *innerrel,
|
||||
JoinType jointype, JoinPathExtraData *extra);
|
||||
static void consider_parallel_nestloop(PlannerInfo *root,
|
||||
RelOptInfo *joinrel,
|
||||
RelOptInfo *outerrel,
|
||||
RelOptInfo *innerrel,
|
||||
JoinType jointype,
|
||||
JoinPathExtraData *extra);
|
||||
RelOptInfo *joinrel,
|
||||
RelOptInfo *outerrel,
|
||||
RelOptInfo *innerrel,
|
||||
JoinType jointype,
|
||||
JoinPathExtraData *extra);
|
||||
static void consider_parallel_mergejoin(PlannerInfo *root,
|
||||
RelOptInfo *joinrel,
|
||||
RelOptInfo *outerrel,
|
||||
RelOptInfo *innerrel,
|
||||
JoinType jointype,
|
||||
JoinPathExtraData *extra,
|
||||
Path *inner_cheapest_total);
|
||||
RelOptInfo *joinrel,
|
||||
RelOptInfo *outerrel,
|
||||
RelOptInfo *innerrel,
|
||||
JoinType jointype,
|
||||
JoinPathExtraData *extra,
|
||||
Path *inner_cheapest_total);
|
||||
static void hash_inner_and_outer(PlannerInfo *root, RelOptInfo *joinrel,
|
||||
RelOptInfo *outerrel, RelOptInfo *innerrel,
|
||||
JoinType jointype, JoinPathExtraData *extra);
|
||||
RelOptInfo *outerrel, RelOptInfo *innerrel,
|
||||
JoinType jointype, JoinPathExtraData *extra);
|
||||
static List *select_mergejoin_clauses(PlannerInfo *root,
|
||||
RelOptInfo *joinrel,
|
||||
RelOptInfo *outerrel,
|
||||
RelOptInfo *innerrel,
|
||||
List *restrictlist,
|
||||
JoinType jointype,
|
||||
bool *mergejoin_allowed);
|
||||
RelOptInfo *joinrel,
|
||||
RelOptInfo *outerrel,
|
||||
RelOptInfo *innerrel,
|
||||
List *restrictlist,
|
||||
JoinType jointype,
|
||||
bool *mergejoin_allowed);
|
||||
static void generate_mergejoin_paths(PlannerInfo *root,
|
||||
RelOptInfo *joinrel,
|
||||
RelOptInfo *innerrel,
|
||||
Path *outerpath,
|
||||
JoinType jointype,
|
||||
JoinPathExtraData *extra,
|
||||
bool useallclauses,
|
||||
Path *inner_cheapest_total,
|
||||
List *merge_pathkeys,
|
||||
bool is_partial);
|
||||
RelOptInfo *joinrel,
|
||||
RelOptInfo *innerrel,
|
||||
Path *outerpath,
|
||||
JoinType jointype,
|
||||
JoinPathExtraData *extra,
|
||||
bool useallclauses,
|
||||
Path *inner_cheapest_total,
|
||||
List *merge_pathkeys,
|
||||
bool is_partial);
|
||||
|
||||
|
||||
/*
|
||||
|
||||
@@ -25,28 +25,28 @@
|
||||
|
||||
|
||||
static void make_rels_by_clause_joins(PlannerInfo *root,
|
||||
RelOptInfo *old_rel,
|
||||
ListCell *other_rels);
|
||||
RelOptInfo *old_rel,
|
||||
ListCell *other_rels);
|
||||
static void make_rels_by_clauseless_joins(PlannerInfo *root,
|
||||
RelOptInfo *old_rel,
|
||||
ListCell *other_rels);
|
||||
RelOptInfo *old_rel,
|
||||
ListCell *other_rels);
|
||||
static bool has_join_restriction(PlannerInfo *root, RelOptInfo *rel);
|
||||
static bool has_legal_joinclause(PlannerInfo *root, RelOptInfo *rel);
|
||||
static bool restriction_is_constant_false(List *restrictlist,
|
||||
RelOptInfo *joinrel,
|
||||
bool only_pushed_down);
|
||||
RelOptInfo *joinrel,
|
||||
bool only_pushed_down);
|
||||
static void populate_joinrel_with_paths(PlannerInfo *root, RelOptInfo *rel1,
|
||||
RelOptInfo *rel2, RelOptInfo *joinrel,
|
||||
SpecialJoinInfo *sjinfo, List *restrictlist);
|
||||
RelOptInfo *rel2, RelOptInfo *joinrel,
|
||||
SpecialJoinInfo *sjinfo, List *restrictlist);
|
||||
static void try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1,
|
||||
RelOptInfo *rel2, RelOptInfo *joinrel,
|
||||
SpecialJoinInfo *parent_sjinfo,
|
||||
List *parent_restrictlist);
|
||||
RelOptInfo *rel2, RelOptInfo *joinrel,
|
||||
SpecialJoinInfo *parent_sjinfo,
|
||||
List *parent_restrictlist);
|
||||
static SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
|
||||
SpecialJoinInfo *parent_sjinfo,
|
||||
Relids left_relids, Relids right_relids);
|
||||
static int match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel,
|
||||
bool strict_op);
|
||||
SpecialJoinInfo *parent_sjinfo,
|
||||
Relids left_relids, Relids right_relids);
|
||||
static int match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel,
|
||||
bool strict_op);
|
||||
|
||||
|
||||
/*
|
||||
|
||||
@@ -31,8 +31,8 @@
|
||||
|
||||
static bool pathkey_is_redundant(PathKey *new_pathkey, List *pathkeys);
|
||||
static bool matches_boolean_partition_clause(RestrictInfo *rinfo,
|
||||
RelOptInfo *partrel,
|
||||
int partkeycol);
|
||||
RelOptInfo *partrel,
|
||||
int partkeycol);
|
||||
static Var *find_var_for_subquery_tle(RelOptInfo *rel, TargetEntry *tle);
|
||||
static bool right_merge_direction(PlannerInfo *root, PathKey *pathkey);
|
||||
|
||||
|
||||
@@ -35,18 +35,18 @@
|
||||
/* local functions */
|
||||
static bool join_is_removable(PlannerInfo *root, SpecialJoinInfo *sjinfo);
|
||||
static void remove_rel_from_query(PlannerInfo *root, int relid,
|
||||
Relids joinrelids);
|
||||
Relids joinrelids);
|
||||
static List *remove_rel_from_joinlist(List *joinlist, int relid, int *nremoved);
|
||||
static bool rel_supports_distinctness(PlannerInfo *root, RelOptInfo *rel);
|
||||
static bool rel_is_distinct_for(PlannerInfo *root, RelOptInfo *rel,
|
||||
List *clause_list);
|
||||
List *clause_list);
|
||||
static Oid distinct_col_search(int colno, List *colnos, List *opids);
|
||||
static bool is_innerrel_unique_for(PlannerInfo *root,
|
||||
Relids joinrelids,
|
||||
Relids outerrelids,
|
||||
RelOptInfo *innerrel,
|
||||
JoinType jointype,
|
||||
List *restrictlist);
|
||||
Relids joinrelids,
|
||||
Relids outerrelids,
|
||||
RelOptInfo *innerrel,
|
||||
JoinType jointype,
|
||||
List *restrictlist);
|
||||
|
||||
|
||||
/*
|
||||
|
||||
@@ -72,223 +72,223 @@
|
||||
|
||||
|
||||
static Plan *create_plan_recurse(PlannerInfo *root, Path *best_path,
|
||||
int flags);
|
||||
int flags);
|
||||
static Plan *create_scan_plan(PlannerInfo *root, Path *best_path,
|
||||
int flags);
|
||||
int flags);
|
||||
static List *build_path_tlist(PlannerInfo *root, Path *path);
|
||||
static bool use_physical_tlist(PlannerInfo *root, Path *path, int flags);
|
||||
static List *get_gating_quals(PlannerInfo *root, List *quals);
|
||||
static Plan *create_gating_plan(PlannerInfo *root, Path *path, Plan *plan,
|
||||
List *gating_quals);
|
||||
List *gating_quals);
|
||||
static Plan *create_join_plan(PlannerInfo *root, JoinPath *best_path);
|
||||
static Plan *create_append_plan(PlannerInfo *root, AppendPath *best_path,
|
||||
int flags);
|
||||
int flags);
|
||||
static Plan *create_merge_append_plan(PlannerInfo *root, MergeAppendPath *best_path,
|
||||
int flags);
|
||||
int flags);
|
||||
static Result *create_group_result_plan(PlannerInfo *root,
|
||||
GroupResultPath *best_path);
|
||||
GroupResultPath *best_path);
|
||||
static ProjectSet *create_project_set_plan(PlannerInfo *root, ProjectSetPath *best_path);
|
||||
static Material *create_material_plan(PlannerInfo *root, MaterialPath *best_path,
|
||||
int flags);
|
||||
int flags);
|
||||
static Plan *create_unique_plan(PlannerInfo *root, UniquePath *best_path,
|
||||
int flags);
|
||||
int flags);
|
||||
static Gather *create_gather_plan(PlannerInfo *root, GatherPath *best_path);
|
||||
static Plan *create_projection_plan(PlannerInfo *root,
|
||||
ProjectionPath *best_path,
|
||||
int flags);
|
||||
ProjectionPath *best_path,
|
||||
int flags);
|
||||
static Plan *inject_projection_plan(Plan *subplan, List *tlist, bool parallel_safe);
|
||||
static Sort *create_sort_plan(PlannerInfo *root, SortPath *best_path, int flags);
|
||||
static Group *create_group_plan(PlannerInfo *root, GroupPath *best_path);
|
||||
static Unique *create_upper_unique_plan(PlannerInfo *root, UpperUniquePath *best_path,
|
||||
int flags);
|
||||
int flags);
|
||||
static Agg *create_agg_plan(PlannerInfo *root, AggPath *best_path);
|
||||
static Plan *create_groupingsets_plan(PlannerInfo *root, GroupingSetsPath *best_path);
|
||||
static Result *create_minmaxagg_plan(PlannerInfo *root, MinMaxAggPath *best_path);
|
||||
static WindowAgg *create_windowagg_plan(PlannerInfo *root, WindowAggPath *best_path);
|
||||
static SetOp *create_setop_plan(PlannerInfo *root, SetOpPath *best_path,
|
||||
int flags);
|
||||
int flags);
|
||||
static RecursiveUnion *create_recursiveunion_plan(PlannerInfo *root, RecursiveUnionPath *best_path);
|
||||
static LockRows *create_lockrows_plan(PlannerInfo *root, LockRowsPath *best_path,
|
||||
int flags);
|
||||
int flags);
|
||||
static ModifyTable *create_modifytable_plan(PlannerInfo *root, ModifyTablePath *best_path);
|
||||
static Limit *create_limit_plan(PlannerInfo *root, LimitPath *best_path,
|
||||
int flags);
|
||||
int flags);
|
||||
static SeqScan *create_seqscan_plan(PlannerInfo *root, Path *best_path,
|
||||
List *tlist, List *scan_clauses);
|
||||
List *tlist, List *scan_clauses);
|
||||
static SampleScan *create_samplescan_plan(PlannerInfo *root, Path *best_path,
|
||||
List *tlist, List *scan_clauses);
|
||||
List *tlist, List *scan_clauses);
|
||||
static Scan *create_indexscan_plan(PlannerInfo *root, IndexPath *best_path,
|
||||
List *tlist, List *scan_clauses, bool indexonly);
|
||||
List *tlist, List *scan_clauses, bool indexonly);
|
||||
static BitmapHeapScan *create_bitmap_scan_plan(PlannerInfo *root,
|
||||
BitmapHeapPath *best_path,
|
||||
List *tlist, List *scan_clauses);
|
||||
BitmapHeapPath *best_path,
|
||||
List *tlist, List *scan_clauses);
|
||||
static Plan *create_bitmap_subplan(PlannerInfo *root, Path *bitmapqual,
|
||||
List **qual, List **indexqual, List **indexECs);
|
||||
List **qual, List **indexqual, List **indexECs);
|
||||
static void bitmap_subplan_mark_shared(Plan *plan);
|
||||
static TidScan *create_tidscan_plan(PlannerInfo *root, TidPath *best_path,
|
||||
List *tlist, List *scan_clauses);
|
||||
List *tlist, List *scan_clauses);
|
||||
static SubqueryScan *create_subqueryscan_plan(PlannerInfo *root,
|
||||
SubqueryScanPath *best_path,
|
||||
List *tlist, List *scan_clauses);
|
||||
SubqueryScanPath *best_path,
|
||||
List *tlist, List *scan_clauses);
|
||||
static FunctionScan *create_functionscan_plan(PlannerInfo *root, Path *best_path,
|
||||
List *tlist, List *scan_clauses);
|
||||
List *tlist, List *scan_clauses);
|
||||
static ValuesScan *create_valuesscan_plan(PlannerInfo *root, Path *best_path,
|
||||
List *tlist, List *scan_clauses);
|
||||
List *tlist, List *scan_clauses);
|
||||
static TableFuncScan *create_tablefuncscan_plan(PlannerInfo *root, Path *best_path,
|
||||
List *tlist, List *scan_clauses);
|
||||
List *tlist, List *scan_clauses);
|
||||
static CteScan *create_ctescan_plan(PlannerInfo *root, Path *best_path,
|
||||
List *tlist, List *scan_clauses);
|
||||
List *tlist, List *scan_clauses);
|
||||
static NamedTuplestoreScan *create_namedtuplestorescan_plan(PlannerInfo *root,
|
||||
Path *best_path, List *tlist, List *scan_clauses);
|
||||
Path *best_path, List *tlist, List *scan_clauses);
|
||||
static Result *create_resultscan_plan(PlannerInfo *root, Path *best_path,
|
||||
List *tlist, List *scan_clauses);
|
||||
List *tlist, List *scan_clauses);
|
||||
static WorkTableScan *create_worktablescan_plan(PlannerInfo *root, Path *best_path,
|
||||
List *tlist, List *scan_clauses);
|
||||
List *tlist, List *scan_clauses);
|
||||
static ForeignScan *create_foreignscan_plan(PlannerInfo *root, ForeignPath *best_path,
|
||||
List *tlist, List *scan_clauses);
|
||||
List *tlist, List *scan_clauses);
|
||||
static CustomScan *create_customscan_plan(PlannerInfo *root,
|
||||
CustomPath *best_path,
|
||||
List *tlist, List *scan_clauses);
|
||||
CustomPath *best_path,
|
||||
List *tlist, List *scan_clauses);
|
||||
static NestLoop *create_nestloop_plan(PlannerInfo *root, NestPath *best_path);
|
||||
static MergeJoin *create_mergejoin_plan(PlannerInfo *root, MergePath *best_path);
|
||||
static HashJoin *create_hashjoin_plan(PlannerInfo *root, HashPath *best_path);
|
||||
static Node *replace_nestloop_params(PlannerInfo *root, Node *expr);
|
||||
static Node *replace_nestloop_params_mutator(Node *node, PlannerInfo *root);
|
||||
static void fix_indexqual_references(PlannerInfo *root, IndexPath *index_path,
|
||||
List **stripped_indexquals_p,
|
||||
List **fixed_indexquals_p);
|
||||
List **stripped_indexquals_p,
|
||||
List **fixed_indexquals_p);
|
||||
static List *fix_indexorderby_references(PlannerInfo *root, IndexPath *index_path);
|
||||
static Node *fix_indexqual_clause(PlannerInfo *root,
|
||||
IndexOptInfo *index, int indexcol,
|
||||
Node *clause, List *indexcolnos);
|
||||
IndexOptInfo *index, int indexcol,
|
||||
Node *clause, List *indexcolnos);
|
||||
static Node *fix_indexqual_operand(Node *node, IndexOptInfo *index, int indexcol);
|
||||
static List *get_switched_clauses(List *clauses, Relids outerrelids);
|
||||
static List *order_qual_clauses(PlannerInfo *root, List *clauses);
|
||||
static void copy_generic_path_info(Plan *dest, Path *src);
|
||||
static void copy_plan_costsize(Plan *dest, Plan *src);
|
||||
static void label_sort_with_costsize(PlannerInfo *root, Sort *plan,
|
||||
double limit_tuples);
|
||||
double limit_tuples);
|
||||
static SeqScan *make_seqscan(List *qptlist, List *qpqual, Index scanrelid);
|
||||
static SampleScan *make_samplescan(List *qptlist, List *qpqual, Index scanrelid,
|
||||
TableSampleClause *tsc);
|
||||
TableSampleClause *tsc);
|
||||
static IndexScan *make_indexscan(List *qptlist, List *qpqual, Index scanrelid,
|
||||
Oid indexid, List *indexqual, List *indexqualorig,
|
||||
List *indexorderby, List *indexorderbyorig,
|
||||
List *indexorderbyops,
|
||||
ScanDirection indexscandir);
|
||||
Oid indexid, List *indexqual, List *indexqualorig,
|
||||
List *indexorderby, List *indexorderbyorig,
|
||||
List *indexorderbyops,
|
||||
ScanDirection indexscandir);
|
||||
static IndexOnlyScan *make_indexonlyscan(List *qptlist, List *qpqual,
|
||||
Index scanrelid, Oid indexid,
|
||||
List *indexqual, List *indexorderby,
|
||||
List *indextlist,
|
||||
ScanDirection indexscandir);
|
||||
Index scanrelid, Oid indexid,
|
||||
List *indexqual, List *indexorderby,
|
||||
List *indextlist,
|
||||
ScanDirection indexscandir);
|
||||
static BitmapIndexScan *make_bitmap_indexscan(Index scanrelid, Oid indexid,
|
||||
List *indexqual,
|
||||
List *indexqualorig);
|
||||
List *indexqual,
|
||||
List *indexqualorig);
|
||||
static BitmapHeapScan *make_bitmap_heapscan(List *qptlist,
|
||||
List *qpqual,
|
||||
Plan *lefttree,
|
||||
List *bitmapqualorig,
|
||||
Index scanrelid);
|
||||
List *qpqual,
|
||||
Plan *lefttree,
|
||||
List *bitmapqualorig,
|
||||
Index scanrelid);
|
||||
static TidScan *make_tidscan(List *qptlist, List *qpqual, Index scanrelid,
|
||||
List *tidquals);
|
||||
List *tidquals);
|
||||
static SubqueryScan *make_subqueryscan(List *qptlist,
|
||||
List *qpqual,
|
||||
Index scanrelid,
|
||||
Plan *subplan);
|
||||
List *qpqual,
|
||||
Index scanrelid,
|
||||
Plan *subplan);
|
||||
static FunctionScan *make_functionscan(List *qptlist, List *qpqual,
|
||||
Index scanrelid, List *functions, bool funcordinality);
|
||||
Index scanrelid, List *functions, bool funcordinality);
|
||||
static ValuesScan *make_valuesscan(List *qptlist, List *qpqual,
|
||||
Index scanrelid, List *values_lists);
|
||||
Index scanrelid, List *values_lists);
|
||||
static TableFuncScan *make_tablefuncscan(List *qptlist, List *qpqual,
|
||||
Index scanrelid, TableFunc *tablefunc);
|
||||
Index scanrelid, TableFunc *tablefunc);
|
||||
static CteScan *make_ctescan(List *qptlist, List *qpqual,
|
||||
Index scanrelid, int ctePlanId, int cteParam);
|
||||
Index scanrelid, int ctePlanId, int cteParam);
|
||||
static NamedTuplestoreScan *make_namedtuplestorescan(List *qptlist, List *qpqual,
|
||||
Index scanrelid, char *enrname);
|
||||
Index scanrelid, char *enrname);
|
||||
static WorkTableScan *make_worktablescan(List *qptlist, List *qpqual,
|
||||
Index scanrelid, int wtParam);
|
||||
Index scanrelid, int wtParam);
|
||||
static RecursiveUnion *make_recursive_union(List *tlist,
|
||||
Plan *lefttree,
|
||||
Plan *righttree,
|
||||
int wtParam,
|
||||
List *distinctList,
|
||||
long numGroups);
|
||||
Plan *lefttree,
|
||||
Plan *righttree,
|
||||
int wtParam,
|
||||
List *distinctList,
|
||||
long numGroups);
|
||||
static BitmapAnd *make_bitmap_and(List *bitmapplans);
|
||||
static BitmapOr *make_bitmap_or(List *bitmapplans);
|
||||
static NestLoop *make_nestloop(List *tlist,
|
||||
List *joinclauses, List *otherclauses, List *nestParams,
|
||||
Plan *lefttree, Plan *righttree,
|
||||
JoinType jointype, bool inner_unique);
|
||||
List *joinclauses, List *otherclauses, List *nestParams,
|
||||
Plan *lefttree, Plan *righttree,
|
||||
JoinType jointype, bool inner_unique);
|
||||
static HashJoin *make_hashjoin(List *tlist,
|
||||
List *joinclauses, List *otherclauses,
|
||||
List *hashclauses,
|
||||
Plan *lefttree, Plan *righttree,
|
||||
JoinType jointype, bool inner_unique);
|
||||
List *joinclauses, List *otherclauses,
|
||||
List *hashclauses,
|
||||
Plan *lefttree, Plan *righttree,
|
||||
JoinType jointype, bool inner_unique);
|
||||
static Hash *make_hash(Plan *lefttree,
|
||||
Oid skewTable,
|
||||
AttrNumber skewColumn,
|
||||
bool skewInherit);
|
||||
Oid skewTable,
|
||||
AttrNumber skewColumn,
|
||||
bool skewInherit);
|
||||
static MergeJoin *make_mergejoin(List *tlist,
|
||||
List *joinclauses, List *otherclauses,
|
||||
List *mergeclauses,
|
||||
Oid *mergefamilies,
|
||||
Oid *mergecollations,
|
||||
int *mergestrategies,
|
||||
bool *mergenullsfirst,
|
||||
Plan *lefttree, Plan *righttree,
|
||||
JoinType jointype, bool inner_unique,
|
||||
bool skip_mark_restore);
|
||||
List *joinclauses, List *otherclauses,
|
||||
List *mergeclauses,
|
||||
Oid *mergefamilies,
|
||||
Oid *mergecollations,
|
||||
int *mergestrategies,
|
||||
bool *mergenullsfirst,
|
||||
Plan *lefttree, Plan *righttree,
|
||||
JoinType jointype, bool inner_unique,
|
||||
bool skip_mark_restore);
|
||||
static Sort *make_sort(Plan *lefttree, int numCols,
|
||||
AttrNumber *sortColIdx, Oid *sortOperators,
|
||||
Oid *collations, bool *nullsFirst);
|
||||
AttrNumber *sortColIdx, Oid *sortOperators,
|
||||
Oid *collations, bool *nullsFirst);
|
||||
static Plan *prepare_sort_from_pathkeys(Plan *lefttree, List *pathkeys,
|
||||
Relids relids,
|
||||
const AttrNumber *reqColIdx,
|
||||
bool adjust_tlist_in_place,
|
||||
int *p_numsortkeys,
|
||||
AttrNumber **p_sortColIdx,
|
||||
Oid **p_sortOperators,
|
||||
Oid **p_collations,
|
||||
bool **p_nullsFirst);
|
||||
Relids relids,
|
||||
const AttrNumber *reqColIdx,
|
||||
bool adjust_tlist_in_place,
|
||||
int *p_numsortkeys,
|
||||
AttrNumber **p_sortColIdx,
|
||||
Oid **p_sortOperators,
|
||||
Oid **p_collations,
|
||||
bool **p_nullsFirst);
|
||||
static EquivalenceMember *find_ec_member_for_tle(EquivalenceClass *ec,
|
||||
TargetEntry *tle,
|
||||
Relids relids);
|
||||
TargetEntry *tle,
|
||||
Relids relids);
|
||||
static Sort *make_sort_from_pathkeys(Plan *lefttree, List *pathkeys,
|
||||
Relids relids);
|
||||
Relids relids);
|
||||
static Sort *make_sort_from_groupcols(List *groupcls,
|
||||
AttrNumber *grpColIdx,
|
||||
Plan *lefttree);
|
||||
AttrNumber *grpColIdx,
|
||||
Plan *lefttree);
|
||||
static Material *make_material(Plan *lefttree);
|
||||
static WindowAgg *make_windowagg(List *tlist, Index winref,
|
||||
int partNumCols, AttrNumber *partColIdx, Oid *partOperators, Oid *partCollations,
|
||||
int ordNumCols, AttrNumber *ordColIdx, Oid *ordOperators, Oid *ordCollations,
|
||||
int frameOptions, Node *startOffset, Node *endOffset,
|
||||
Oid startInRangeFunc, Oid endInRangeFunc,
|
||||
Oid inRangeColl, bool inRangeAsc, bool inRangeNullsFirst,
|
||||
Plan *lefttree);
|
||||
int partNumCols, AttrNumber *partColIdx, Oid *partOperators, Oid *partCollations,
|
||||
int ordNumCols, AttrNumber *ordColIdx, Oid *ordOperators, Oid *ordCollations,
|
||||
int frameOptions, Node *startOffset, Node *endOffset,
|
||||
Oid startInRangeFunc, Oid endInRangeFunc,
|
||||
Oid inRangeColl, bool inRangeAsc, bool inRangeNullsFirst,
|
||||
Plan *lefttree);
|
||||
static Group *make_group(List *tlist, List *qual, int numGroupCols,
|
||||
AttrNumber *grpColIdx, Oid *grpOperators, Oid *grpCollations,
|
||||
Plan *lefttree);
|
||||
AttrNumber *grpColIdx, Oid *grpOperators, Oid *grpCollations,
|
||||
Plan *lefttree);
|
||||
static Unique *make_unique_from_sortclauses(Plan *lefttree, List *distinctList);
|
||||
static Unique *make_unique_from_pathkeys(Plan *lefttree,
|
||||
List *pathkeys, int numCols);
|
||||
List *pathkeys, int numCols);
|
||||
static Gather *make_gather(List *qptlist, List *qpqual,
|
||||
int nworkers, int rescan_param, bool single_copy, Plan *subplan);
|
||||
int nworkers, int rescan_param, bool single_copy, Plan *subplan);
|
||||
static SetOp *make_setop(SetOpCmd cmd, SetOpStrategy strategy, Plan *lefttree,
|
||||
List *distinctList, AttrNumber flagColIdx, int firstFlag,
|
||||
long numGroups);
|
||||
List *distinctList, AttrNumber flagColIdx, int firstFlag,
|
||||
long numGroups);
|
||||
static LockRows *make_lockrows(Plan *lefttree, List *rowMarks, int epqParam);
|
||||
static Result *make_result(List *tlist, Node *resconstantqual, Plan *subplan);
|
||||
static ProjectSet *make_project_set(List *tlist, Plan *subplan);
|
||||
static ModifyTable *make_modifytable(PlannerInfo *root,
|
||||
CmdType operation, bool canSetTag,
|
||||
Index nominalRelation, Index rootRelation,
|
||||
bool partColsUpdated,
|
||||
List *resultRelations, List *subplans, List *subroots,
|
||||
List *withCheckOptionLists, List *returningLists,
|
||||
List *rowMarks, OnConflictExpr *onconflict, int epqParam);
|
||||
CmdType operation, bool canSetTag,
|
||||
Index nominalRelation, Index rootRelation,
|
||||
bool partColsUpdated,
|
||||
List *resultRelations, List *subplans, List *subroots,
|
||||
List *withCheckOptionLists, List *returningLists,
|
||||
List *rowMarks, OnConflictExpr *onconflict, int epqParam);
|
||||
static GatherMerge *create_gather_merge_plan(PlannerInfo *root,
|
||||
GatherMergePath *best_path);
|
||||
GatherMergePath *best_path);
|
||||
|
||||
|
||||
/*
|
||||
|
||||
@@ -49,33 +49,33 @@ typedef struct PostponedQual
|
||||
|
||||
|
||||
static void extract_lateral_references(PlannerInfo *root, RelOptInfo *brel,
|
||||
Index rtindex);
|
||||
Index rtindex);
|
||||
static List *deconstruct_recurse(PlannerInfo *root, Node *jtnode,
|
||||
bool below_outer_join,
|
||||
Relids *qualscope, Relids *inner_join_rels,
|
||||
List **postponed_qual_list);
|
||||
bool below_outer_join,
|
||||
Relids *qualscope, Relids *inner_join_rels,
|
||||
List **postponed_qual_list);
|
||||
static void process_security_barrier_quals(PlannerInfo *root,
|
||||
int rti, Relids qualscope,
|
||||
bool below_outer_join);
|
||||
int rti, Relids qualscope,
|
||||
bool below_outer_join);
|
||||
static SpecialJoinInfo *make_outerjoininfo(PlannerInfo *root,
|
||||
Relids left_rels, Relids right_rels,
|
||||
Relids inner_join_rels,
|
||||
JoinType jointype, List *clause);
|
||||
Relids left_rels, Relids right_rels,
|
||||
Relids inner_join_rels,
|
||||
JoinType jointype, List *clause);
|
||||
static void compute_semijoin_info(SpecialJoinInfo *sjinfo, List *clause);
|
||||
static void distribute_qual_to_rels(PlannerInfo *root, Node *clause,
|
||||
bool is_deduced,
|
||||
bool below_outer_join,
|
||||
JoinType jointype,
|
||||
Index security_level,
|
||||
Relids qualscope,
|
||||
Relids ojscope,
|
||||
Relids outerjoin_nonnullable,
|
||||
Relids deduced_nullable_relids,
|
||||
List **postponed_qual_list);
|
||||
bool is_deduced,
|
||||
bool below_outer_join,
|
||||
JoinType jointype,
|
||||
Index security_level,
|
||||
Relids qualscope,
|
||||
Relids ojscope,
|
||||
Relids outerjoin_nonnullable,
|
||||
Relids deduced_nullable_relids,
|
||||
List **postponed_qual_list);
|
||||
static bool check_outerjoin_delay(PlannerInfo *root, Relids *relids_p,
|
||||
Relids *nullable_relids_p, bool is_pushed_down);
|
||||
Relids *nullable_relids_p, bool is_pushed_down);
|
||||
static bool check_equivalence_delay(PlannerInfo *root,
|
||||
RestrictInfo *restrictinfo);
|
||||
RestrictInfo *restrictinfo);
|
||||
static bool check_redundant_nullability_qual(PlannerInfo *root, Node *clause);
|
||||
static void check_mergejoinable(RestrictInfo *restrictinfo);
|
||||
static void check_hashjoinable(RestrictInfo *restrictinfo);
|
||||
|
||||
@@ -50,7 +50,7 @@
|
||||
|
||||
static bool find_minmax_aggs_walker(Node *node, List **context);
|
||||
static bool build_minmax_path(PlannerInfo *root, MinMaxAggInfo *mminfo,
|
||||
Oid eqop, Oid sortop, bool nulls_first);
|
||||
Oid eqop, Oid sortop, bool nulls_first);
|
||||
static void minmax_qp_callback(PlannerInfo *root, void *extra);
|
||||
static Oid fetch_agg_sort_op(Oid aggfnoid);
|
||||
|
||||
|
||||
@@ -132,122 +132,122 @@ static Node *preprocess_expression(PlannerInfo *root, Node *expr, int kind);
|
||||
static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode);
|
||||
static void inheritance_planner(PlannerInfo *root);
|
||||
static void grouping_planner(PlannerInfo *root, bool inheritance_update,
|
||||
double tuple_fraction);
|
||||
double tuple_fraction);
|
||||
static grouping_sets_data *preprocess_grouping_sets(PlannerInfo *root);
|
||||
static List *remap_to_groupclause_idx(List *groupClause, List *gsets,
|
||||
int *tleref_to_colnum_map);
|
||||
int *tleref_to_colnum_map);
|
||||
static void preprocess_rowmarks(PlannerInfo *root);
|
||||
static double preprocess_limit(PlannerInfo *root,
|
||||
double tuple_fraction,
|
||||
int64 *offset_est, int64 *count_est);
|
||||
double tuple_fraction,
|
||||
int64 *offset_est, int64 *count_est);
|
||||
static void remove_useless_groupby_columns(PlannerInfo *root);
|
||||
static List *preprocess_groupclause(PlannerInfo *root, List *force);
|
||||
static List *extract_rollup_sets(List *groupingSets);
|
||||
static List *reorder_grouping_sets(List *groupingSets, List *sortclause);
|
||||
static void standard_qp_callback(PlannerInfo *root, void *extra);
|
||||
static double get_number_of_groups(PlannerInfo *root,
|
||||
double path_rows,
|
||||
grouping_sets_data *gd,
|
||||
List *target_list);
|
||||
double path_rows,
|
||||
grouping_sets_data *gd,
|
||||
List *target_list);
|
||||
static RelOptInfo *create_grouping_paths(PlannerInfo *root,
|
||||
RelOptInfo *input_rel,
|
||||
PathTarget *target,
|
||||
bool target_parallel_safe,
|
||||
const AggClauseCosts *agg_costs,
|
||||
grouping_sets_data *gd);
|
||||
RelOptInfo *input_rel,
|
||||
PathTarget *target,
|
||||
bool target_parallel_safe,
|
||||
const AggClauseCosts *agg_costs,
|
||||
grouping_sets_data *gd);
|
||||
static bool is_degenerate_grouping(PlannerInfo *root);
|
||||
static void create_degenerate_grouping_paths(PlannerInfo *root,
|
||||
RelOptInfo *input_rel,
|
||||
RelOptInfo *grouped_rel);
|
||||
RelOptInfo *input_rel,
|
||||
RelOptInfo *grouped_rel);
|
||||
static RelOptInfo *make_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel,
|
||||
PathTarget *target, bool target_parallel_safe,
|
||||
Node *havingQual);
|
||||
PathTarget *target, bool target_parallel_safe,
|
||||
Node *havingQual);
|
||||
static void create_ordinary_grouping_paths(PlannerInfo *root,
|
||||
RelOptInfo *input_rel,
|
||||
RelOptInfo *grouped_rel,
|
||||
const AggClauseCosts *agg_costs,
|
||||
grouping_sets_data *gd,
|
||||
GroupPathExtraData *extra,
|
||||
RelOptInfo **partially_grouped_rel_p);
|
||||
RelOptInfo *input_rel,
|
||||
RelOptInfo *grouped_rel,
|
||||
const AggClauseCosts *agg_costs,
|
||||
grouping_sets_data *gd,
|
||||
GroupPathExtraData *extra,
|
||||
RelOptInfo **partially_grouped_rel_p);
|
||||
static void consider_groupingsets_paths(PlannerInfo *root,
|
||||
RelOptInfo *grouped_rel,
|
||||
Path *path,
|
||||
bool is_sorted,
|
||||
bool can_hash,
|
||||
grouping_sets_data *gd,
|
||||
const AggClauseCosts *agg_costs,
|
||||
double dNumGroups);
|
||||
RelOptInfo *grouped_rel,
|
||||
Path *path,
|
||||
bool is_sorted,
|
||||
bool can_hash,
|
||||
grouping_sets_data *gd,
|
||||
const AggClauseCosts *agg_costs,
|
||||
double dNumGroups);
|
||||
static RelOptInfo *create_window_paths(PlannerInfo *root,
|
||||
RelOptInfo *input_rel,
|
||||
PathTarget *input_target,
|
||||
PathTarget *output_target,
|
||||
bool output_target_parallel_safe,
|
||||
WindowFuncLists *wflists,
|
||||
List *activeWindows);
|
||||
RelOptInfo *input_rel,
|
||||
PathTarget *input_target,
|
||||
PathTarget *output_target,
|
||||
bool output_target_parallel_safe,
|
||||
WindowFuncLists *wflists,
|
||||
List *activeWindows);
|
||||
static void create_one_window_path(PlannerInfo *root,
|
||||
RelOptInfo *window_rel,
|
||||
Path *path,
|
||||
PathTarget *input_target,
|
||||
PathTarget *output_target,
|
||||
WindowFuncLists *wflists,
|
||||
List *activeWindows);
|
||||
RelOptInfo *window_rel,
|
||||
Path *path,
|
||||
PathTarget *input_target,
|
||||
PathTarget *output_target,
|
||||
WindowFuncLists *wflists,
|
||||
List *activeWindows);
|
||||
static RelOptInfo *create_distinct_paths(PlannerInfo *root,
|
||||
RelOptInfo *input_rel);
|
||||
RelOptInfo *input_rel);
|
||||
static RelOptInfo *create_ordered_paths(PlannerInfo *root,
|
||||
RelOptInfo *input_rel,
|
||||
PathTarget *target,
|
||||
bool target_parallel_safe,
|
||||
double limit_tuples);
|
||||
RelOptInfo *input_rel,
|
||||
PathTarget *target,
|
||||
bool target_parallel_safe,
|
||||
double limit_tuples);
|
||||
static PathTarget *make_group_input_target(PlannerInfo *root,
|
||||
PathTarget *final_target);
|
||||
PathTarget *final_target);
|
||||
static PathTarget *make_partial_grouping_target(PlannerInfo *root,
|
||||
PathTarget *grouping_target,
|
||||
Node *havingQual);
|
||||
PathTarget *grouping_target,
|
||||
Node *havingQual);
|
||||
static List *postprocess_setop_tlist(List *new_tlist, List *orig_tlist);
|
||||
static List *select_active_windows(PlannerInfo *root, WindowFuncLists *wflists);
|
||||
static PathTarget *make_window_input_target(PlannerInfo *root,
|
||||
PathTarget *final_target,
|
||||
List *activeWindows);
|
||||
PathTarget *final_target,
|
||||
List *activeWindows);
|
||||
static List *make_pathkeys_for_window(PlannerInfo *root, WindowClause *wc,
|
||||
List *tlist);
|
||||
List *tlist);
|
||||
static PathTarget *make_sort_input_target(PlannerInfo *root,
|
||||
PathTarget *final_target,
|
||||
bool *have_postponed_srfs);
|
||||
PathTarget *final_target,
|
||||
bool *have_postponed_srfs);
|
||||
static void adjust_paths_for_srfs(PlannerInfo *root, RelOptInfo *rel,
|
||||
List *targets, List *targets_contain_srfs);
|
||||
List *targets, List *targets_contain_srfs);
|
||||
static void add_paths_to_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel,
|
||||
RelOptInfo *grouped_rel,
|
||||
RelOptInfo *partially_grouped_rel,
|
||||
const AggClauseCosts *agg_costs,
|
||||
grouping_sets_data *gd,
|
||||
double dNumGroups,
|
||||
GroupPathExtraData *extra);
|
||||
RelOptInfo *grouped_rel,
|
||||
RelOptInfo *partially_grouped_rel,
|
||||
const AggClauseCosts *agg_costs,
|
||||
grouping_sets_data *gd,
|
||||
double dNumGroups,
|
||||
GroupPathExtraData *extra);
|
||||
static RelOptInfo *create_partial_grouping_paths(PlannerInfo *root,
|
||||
RelOptInfo *grouped_rel,
|
||||
RelOptInfo *input_rel,
|
||||
grouping_sets_data *gd,
|
||||
GroupPathExtraData *extra,
|
||||
bool force_rel_creation);
|
||||
RelOptInfo *grouped_rel,
|
||||
RelOptInfo *input_rel,
|
||||
grouping_sets_data *gd,
|
||||
GroupPathExtraData *extra,
|
||||
bool force_rel_creation);
|
||||
static void gather_grouping_paths(PlannerInfo *root, RelOptInfo *rel);
|
||||
static bool can_partial_agg(PlannerInfo *root,
|
||||
const AggClauseCosts *agg_costs);
|
||||
const AggClauseCosts *agg_costs);
|
||||
static void apply_scanjoin_target_to_paths(PlannerInfo *root,
|
||||
RelOptInfo *rel,
|
||||
List *scanjoin_targets,
|
||||
List *scanjoin_targets_contain_srfs,
|
||||
bool scanjoin_target_parallel_safe,
|
||||
bool tlist_same_exprs);
|
||||
RelOptInfo *rel,
|
||||
List *scanjoin_targets,
|
||||
List *scanjoin_targets_contain_srfs,
|
||||
bool scanjoin_target_parallel_safe,
|
||||
bool tlist_same_exprs);
|
||||
static void create_partitionwise_grouping_paths(PlannerInfo *root,
|
||||
RelOptInfo *input_rel,
|
||||
RelOptInfo *grouped_rel,
|
||||
RelOptInfo *partially_grouped_rel,
|
||||
const AggClauseCosts *agg_costs,
|
||||
grouping_sets_data *gd,
|
||||
PartitionwiseAggregateType patype,
|
||||
GroupPathExtraData *extra);
|
||||
RelOptInfo *input_rel,
|
||||
RelOptInfo *grouped_rel,
|
||||
RelOptInfo *partially_grouped_rel,
|
||||
const AggClauseCosts *agg_costs,
|
||||
grouping_sets_data *gd,
|
||||
PartitionwiseAggregateType patype,
|
||||
GroupPathExtraData *extra);
|
||||
static bool group_by_has_partkey(RelOptInfo *input_rel,
|
||||
List *targetList,
|
||||
List *groupClause);
|
||||
List *targetList,
|
||||
List *groupClause);
|
||||
static int common_prefix_cmp(const void *a, const void *b);
|
||||
|
||||
|
||||
|
||||
@@ -88,25 +88,25 @@ static bool flatten_rtes_walker(Node *node, PlannerGlobal *glob);
|
||||
static void add_rte_to_flat_rtable(PlannerGlobal *glob, RangeTblEntry *rte);
|
||||
static Plan *set_plan_refs(PlannerInfo *root, Plan *plan, int rtoffset);
|
||||
static Plan *set_indexonlyscan_references(PlannerInfo *root,
|
||||
IndexOnlyScan *plan,
|
||||
int rtoffset);
|
||||
IndexOnlyScan *plan,
|
||||
int rtoffset);
|
||||
static Plan *set_subqueryscan_references(PlannerInfo *root,
|
||||
SubqueryScan *plan,
|
||||
int rtoffset);
|
||||
SubqueryScan *plan,
|
||||
int rtoffset);
|
||||
static bool trivial_subqueryscan(SubqueryScan *plan);
|
||||
static Plan *clean_up_removed_plan_level(Plan *parent, Plan *child);
|
||||
static void set_foreignscan_references(PlannerInfo *root,
|
||||
ForeignScan *fscan,
|
||||
int rtoffset);
|
||||
ForeignScan *fscan,
|
||||
int rtoffset);
|
||||
static void set_customscan_references(PlannerInfo *root,
|
||||
CustomScan *cscan,
|
||||
int rtoffset);
|
||||
CustomScan *cscan,
|
||||
int rtoffset);
|
||||
static Plan *set_append_references(PlannerInfo *root,
|
||||
Append *aplan,
|
||||
int rtoffset);
|
||||
Append *aplan,
|
||||
int rtoffset);
|
||||
static Plan *set_mergeappend_references(PlannerInfo *root,
|
||||
MergeAppend *mplan,
|
||||
int rtoffset);
|
||||
MergeAppend *mplan,
|
||||
int rtoffset);
|
||||
static Node *fix_scan_expr(PlannerInfo *root, Node *node, int rtoffset);
|
||||
static Node *fix_scan_expr_mutator(Node *node, fix_scan_expr_context *context);
|
||||
static bool fix_scan_expr_walker(Node *node, fix_scan_expr_context *context);
|
||||
@@ -117,35 +117,35 @@ static Node *convert_combining_aggrefs(Node *node, void *context);
|
||||
static void set_dummy_tlist_references(Plan *plan, int rtoffset);
|
||||
static indexed_tlist *build_tlist_index(List *tlist);
|
||||
static Var *search_indexed_tlist_for_var(Var *var,
|
||||
indexed_tlist *itlist,
|
||||
Index newvarno,
|
||||
int rtoffset);
|
||||
indexed_tlist *itlist,
|
||||
Index newvarno,
|
||||
int rtoffset);
|
||||
static Var *search_indexed_tlist_for_non_var(Expr *node,
|
||||
indexed_tlist *itlist,
|
||||
Index newvarno);
|
||||
indexed_tlist *itlist,
|
||||
Index newvarno);
|
||||
static Var *search_indexed_tlist_for_sortgroupref(Expr *node,
|
||||
Index sortgroupref,
|
||||
indexed_tlist *itlist,
|
||||
Index newvarno);
|
||||
Index sortgroupref,
|
||||
indexed_tlist *itlist,
|
||||
Index newvarno);
|
||||
static List *fix_join_expr(PlannerInfo *root,
|
||||
List *clauses,
|
||||
indexed_tlist *outer_itlist,
|
||||
indexed_tlist *inner_itlist,
|
||||
Index acceptable_rel, int rtoffset);
|
||||
List *clauses,
|
||||
indexed_tlist *outer_itlist,
|
||||
indexed_tlist *inner_itlist,
|
||||
Index acceptable_rel, int rtoffset);
|
||||
static Node *fix_join_expr_mutator(Node *node,
|
||||
fix_join_expr_context *context);
|
||||
fix_join_expr_context *context);
|
||||
static Node *fix_upper_expr(PlannerInfo *root,
|
||||
Node *node,
|
||||
indexed_tlist *subplan_itlist,
|
||||
Index newvarno,
|
||||
int rtoffset);
|
||||
Node *node,
|
||||
indexed_tlist *subplan_itlist,
|
||||
Index newvarno,
|
||||
int rtoffset);
|
||||
static Node *fix_upper_expr_mutator(Node *node,
|
||||
fix_upper_expr_context *context);
|
||||
fix_upper_expr_context *context);
|
||||
static List *set_returning_clause_references(PlannerInfo *root,
|
||||
List *rlist,
|
||||
Plan *topplan,
|
||||
Index resultRelation,
|
||||
int rtoffset);
|
||||
List *rlist,
|
||||
Plan *topplan,
|
||||
Index resultRelation,
|
||||
int rtoffset);
|
||||
|
||||
|
||||
/*****************************************************************************
|
||||
|
||||
@@ -67,19 +67,19 @@ typedef struct inline_cte_walker_context
|
||||
|
||||
|
||||
static Node *build_subplan(PlannerInfo *root, Plan *plan, PlannerInfo *subroot,
|
||||
List *plan_params,
|
||||
SubLinkType subLinkType, int subLinkId,
|
||||
Node *testexpr, bool adjust_testexpr,
|
||||
bool unknownEqFalse);
|
||||
List *plan_params,
|
||||
SubLinkType subLinkType, int subLinkId,
|
||||
Node *testexpr, bool adjust_testexpr,
|
||||
bool unknownEqFalse);
|
||||
static List *generate_subquery_params(PlannerInfo *root, List *tlist,
|
||||
List **paramIds);
|
||||
List **paramIds);
|
||||
static List *generate_subquery_vars(PlannerInfo *root, List *tlist,
|
||||
Index varno);
|
||||
Index varno);
|
||||
static Node *convert_testexpr(PlannerInfo *root,
|
||||
Node *testexpr,
|
||||
List *subst_nodes);
|
||||
Node *testexpr,
|
||||
List *subst_nodes);
|
||||
static Node *convert_testexpr_mutator(Node *node,
|
||||
convert_testexpr_context *context);
|
||||
convert_testexpr_context *context);
|
||||
static bool subplan_is_hashable(Plan *plan);
|
||||
static bool testexpr_is_hashable(Node *testexpr);
|
||||
static bool hash_ok_operator(OpExpr *expr);
|
||||
@@ -91,15 +91,15 @@ static void inline_cte(PlannerInfo *root, CommonTableExpr *cte);
|
||||
static bool inline_cte_walker(Node *node, inline_cte_walker_context *context);
|
||||
static bool simplify_EXISTS_query(PlannerInfo *root, Query *query);
|
||||
static Query *convert_EXISTS_to_ANY(PlannerInfo *root, Query *subselect,
|
||||
Node **testexpr, List **paramIds);
|
||||
Node **testexpr, List **paramIds);
|
||||
static Node *replace_correlation_vars_mutator(Node *node, PlannerInfo *root);
|
||||
static Node *process_sublinks_mutator(Node *node,
|
||||
process_sublinks_context *context);
|
||||
process_sublinks_context *context);
|
||||
static Bitmapset *finalize_plan(PlannerInfo *root,
|
||||
Plan *plan,
|
||||
int gather_param,
|
||||
Bitmapset *valid_params,
|
||||
Bitmapset *scan_params);
|
||||
Plan *plan,
|
||||
int gather_param,
|
||||
Bitmapset *valid_params,
|
||||
Bitmapset *scan_params);
|
||||
static bool finalize_primnode(Node *node, finalize_primnode_context *context);
|
||||
static bool finalize_agg_primnode(Node *node, finalize_primnode_context *context);
|
||||
|
||||
|
||||
@@ -61,61 +61,61 @@ typedef struct reduce_outer_joins_state
|
||||
} reduce_outer_joins_state;
|
||||
|
||||
static Node *pull_up_sublinks_jointree_recurse(PlannerInfo *root, Node *jtnode,
|
||||
Relids *relids);
|
||||
Relids *relids);
|
||||
static Node *pull_up_sublinks_qual_recurse(PlannerInfo *root, Node *node,
|
||||
Node **jtlink1, Relids available_rels1,
|
||||
Node **jtlink2, Relids available_rels2);
|
||||
Node **jtlink1, Relids available_rels1,
|
||||
Node **jtlink2, Relids available_rels2);
|
||||
static Node *pull_up_subqueries_recurse(PlannerInfo *root, Node *jtnode,
|
||||
JoinExpr *lowest_outer_join,
|
||||
JoinExpr *lowest_nulling_outer_join,
|
||||
AppendRelInfo *containing_appendrel);
|
||||
JoinExpr *lowest_outer_join,
|
||||
JoinExpr *lowest_nulling_outer_join,
|
||||
AppendRelInfo *containing_appendrel);
|
||||
static Node *pull_up_simple_subquery(PlannerInfo *root, Node *jtnode,
|
||||
RangeTblEntry *rte,
|
||||
JoinExpr *lowest_outer_join,
|
||||
JoinExpr *lowest_nulling_outer_join,
|
||||
AppendRelInfo *containing_appendrel);
|
||||
RangeTblEntry *rte,
|
||||
JoinExpr *lowest_outer_join,
|
||||
JoinExpr *lowest_nulling_outer_join,
|
||||
AppendRelInfo *containing_appendrel);
|
||||
static Node *pull_up_simple_union_all(PlannerInfo *root, Node *jtnode,
|
||||
RangeTblEntry *rte);
|
||||
RangeTblEntry *rte);
|
||||
static void pull_up_union_leaf_queries(Node *setOp, PlannerInfo *root,
|
||||
int parentRTindex, Query *setOpQuery,
|
||||
int childRToffset);
|
||||
int parentRTindex, Query *setOpQuery,
|
||||
int childRToffset);
|
||||
static void make_setop_translation_list(Query *query, Index newvarno,
|
||||
List **translated_vars);
|
||||
List **translated_vars);
|
||||
static bool is_simple_subquery(Query *subquery, RangeTblEntry *rte,
|
||||
JoinExpr *lowest_outer_join);
|
||||
JoinExpr *lowest_outer_join);
|
||||
static Node *pull_up_simple_values(PlannerInfo *root, Node *jtnode,
|
||||
RangeTblEntry *rte);
|
||||
RangeTblEntry *rte);
|
||||
static bool is_simple_values(PlannerInfo *root, RangeTblEntry *rte);
|
||||
static bool is_simple_union_all(Query *subquery);
|
||||
static bool is_simple_union_all_recurse(Node *setOp, Query *setOpQuery,
|
||||
List *colTypes);
|
||||
List *colTypes);
|
||||
static bool is_safe_append_member(Query *subquery);
|
||||
static bool jointree_contains_lateral_outer_refs(Node *jtnode, bool restricted,
|
||||
Relids safe_upper_varnos);
|
||||
Relids safe_upper_varnos);
|
||||
static void replace_vars_in_jointree(Node *jtnode,
|
||||
pullup_replace_vars_context *context,
|
||||
JoinExpr *lowest_nulling_outer_join);
|
||||
pullup_replace_vars_context *context,
|
||||
JoinExpr *lowest_nulling_outer_join);
|
||||
static Node *pullup_replace_vars(Node *expr,
|
||||
pullup_replace_vars_context *context);
|
||||
pullup_replace_vars_context *context);
|
||||
static Node *pullup_replace_vars_callback(Var *var,
|
||||
replace_rte_variables_context *context);
|
||||
replace_rte_variables_context *context);
|
||||
static Query *pullup_replace_vars_subquery(Query *query,
|
||||
pullup_replace_vars_context *context);
|
||||
pullup_replace_vars_context *context);
|
||||
static reduce_outer_joins_state *reduce_outer_joins_pass1(Node *jtnode);
|
||||
static void reduce_outer_joins_pass2(Node *jtnode,
|
||||
reduce_outer_joins_state *state,
|
||||
PlannerInfo *root,
|
||||
Relids nonnullable_rels,
|
||||
List *nonnullable_vars,
|
||||
List *forced_null_vars);
|
||||
reduce_outer_joins_state *state,
|
||||
PlannerInfo *root,
|
||||
Relids nonnullable_rels,
|
||||
List *nonnullable_vars,
|
||||
List *forced_null_vars);
|
||||
static Node *remove_useless_results_recurse(PlannerInfo *root, Node *jtnode);
|
||||
static int get_result_relid(PlannerInfo *root, Node *jtnode);
|
||||
static void remove_result_refs(PlannerInfo *root, int varno, Node *newjtloc);
|
||||
static bool find_dependent_phvs(Node *node, int varno);
|
||||
static void substitute_phv_relids(Node *node,
|
||||
int varno, Relids subrelids);
|
||||
int varno, Relids subrelids);
|
||||
static void fix_append_rel_relids(List *append_rel_list, int varno,
|
||||
Relids subrelids);
|
||||
Relids subrelids);
|
||||
static Node *find_jointree_node_for_rel(Node *jtnode, int relid);
|
||||
|
||||
|
||||
|
||||
@@ -54,7 +54,7 @@
|
||||
|
||||
|
||||
static List *expand_targetlist(List *tlist, int command_type,
|
||||
Index result_relation, Relation rel);
|
||||
Index result_relation, Relation rel);
|
||||
|
||||
|
||||
/*
|
||||
|
||||
@@ -47,42 +47,42 @@
|
||||
|
||||
|
||||
static RelOptInfo *recurse_set_operations(Node *setOp, PlannerInfo *root,
|
||||
List *colTypes, List *colCollations,
|
||||
bool junkOK,
|
||||
int flag, List *refnames_tlist,
|
||||
List **pTargetList,
|
||||
double *pNumGroups);
|
||||
List *colTypes, List *colCollations,
|
||||
bool junkOK,
|
||||
int flag, List *refnames_tlist,
|
||||
List **pTargetList,
|
||||
double *pNumGroups);
|
||||
static RelOptInfo *generate_recursion_path(SetOperationStmt *setOp,
|
||||
PlannerInfo *root,
|
||||
List *refnames_tlist,
|
||||
List **pTargetList);
|
||||
PlannerInfo *root,
|
||||
List *refnames_tlist,
|
||||
List **pTargetList);
|
||||
static RelOptInfo *generate_union_paths(SetOperationStmt *op, PlannerInfo *root,
|
||||
List *refnames_tlist,
|
||||
List **pTargetList);
|
||||
List *refnames_tlist,
|
||||
List **pTargetList);
|
||||
static RelOptInfo *generate_nonunion_paths(SetOperationStmt *op, PlannerInfo *root,
|
||||
List *refnames_tlist,
|
||||
List **pTargetList);
|
||||
List *refnames_tlist,
|
||||
List **pTargetList);
|
||||
static List *plan_union_children(PlannerInfo *root,
|
||||
SetOperationStmt *top_union,
|
||||
List *refnames_tlist,
|
||||
List **tlist_list);
|
||||
SetOperationStmt *top_union,
|
||||
List *refnames_tlist,
|
||||
List **tlist_list);
|
||||
static Path *make_union_unique(SetOperationStmt *op, Path *path, List *tlist,
|
||||
PlannerInfo *root);
|
||||
PlannerInfo *root);
|
||||
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);
|
||||
Path *input_path,
|
||||
double dNumGroups, double dNumOutputRows,
|
||||
const char *construct);
|
||||
static List *generate_setop_tlist(List *colTypes, List *colCollations,
|
||||
int flag,
|
||||
Index varno,
|
||||
bool hack_constants,
|
||||
List *input_tlist,
|
||||
List *refnames_tlist);
|
||||
int flag,
|
||||
Index varno,
|
||||
bool hack_constants,
|
||||
List *input_tlist,
|
||||
List *refnames_tlist);
|
||||
static List *generate_append_tlist(List *colTypes, List *colCollations,
|
||||
bool flag,
|
||||
List *input_tlists,
|
||||
List *refnames_tlist);
|
||||
bool flag,
|
||||
List *input_tlists,
|
||||
List *refnames_tlist);
|
||||
static List *generate_setop_grouplist(SetOperationStmt *op, List *targetlist);
|
||||
|
||||
|
||||
|
||||
@@ -32,13 +32,13 @@ typedef struct
|
||||
} adjust_appendrel_attrs_context;
|
||||
|
||||
static void make_inh_translation_list(Relation oldrelation,
|
||||
Relation newrelation,
|
||||
Index newvarno,
|
||||
List **translated_vars);
|
||||
Relation newrelation,
|
||||
Index newvarno,
|
||||
List **translated_vars);
|
||||
static Node *adjust_appendrel_attrs_mutator(Node *node,
|
||||
adjust_appendrel_attrs_context *context);
|
||||
adjust_appendrel_attrs_context *context);
|
||||
static List *adjust_inherited_tlist(List *tlist,
|
||||
AppendRelInfo *context);
|
||||
AppendRelInfo *context);
|
||||
|
||||
|
||||
/*
|
||||
|
||||
@@ -99,14 +99,14 @@ typedef struct
|
||||
|
||||
static bool contain_agg_clause_walker(Node *node, void *context);
|
||||
static bool get_agg_clause_costs_walker(Node *node,
|
||||
get_agg_clause_costs_context *context);
|
||||
get_agg_clause_costs_context *context);
|
||||
static bool find_window_functions_walker(Node *node, WindowFuncLists *lists);
|
||||
static bool contain_subplans_walker(Node *node, void *context);
|
||||
static bool contain_mutable_functions_walker(Node *node, void *context);
|
||||
static bool contain_volatile_functions_walker(Node *node, void *context);
|
||||
static bool contain_volatile_functions_not_nextval_walker(Node *node, void *context);
|
||||
static bool max_parallel_hazard_walker(Node *node,
|
||||
max_parallel_hazard_context *context);
|
||||
max_parallel_hazard_context *context);
|
||||
static bool contain_nonstrict_functions_walker(Node *node, void *context);
|
||||
static bool contain_context_dependent_node(Node *clause);
|
||||
static bool contain_context_dependent_node_walker(Node *node, int *flags);
|
||||
@@ -115,46 +115,46 @@ static Relids find_nonnullable_rels_walker(Node *node, bool top_level);
|
||||
static List *find_nonnullable_vars_walker(Node *node, bool top_level);
|
||||
static bool is_strict_saop(ScalarArrayOpExpr *expr, bool falseOK);
|
||||
static Node *eval_const_expressions_mutator(Node *node,
|
||||
eval_const_expressions_context *context);
|
||||
eval_const_expressions_context *context);
|
||||
static bool contain_non_const_walker(Node *node, void *context);
|
||||
static bool ece_function_is_safe(Oid funcid,
|
||||
eval_const_expressions_context *context);
|
||||
eval_const_expressions_context *context);
|
||||
static List *simplify_or_arguments(List *args,
|
||||
eval_const_expressions_context *context,
|
||||
bool *haveNull, bool *forceTrue);
|
||||
eval_const_expressions_context *context,
|
||||
bool *haveNull, bool *forceTrue);
|
||||
static List *simplify_and_arguments(List *args,
|
||||
eval_const_expressions_context *context,
|
||||
bool *haveNull, bool *forceFalse);
|
||||
eval_const_expressions_context *context,
|
||||
bool *haveNull, bool *forceFalse);
|
||||
static Node *simplify_boolean_equality(Oid opno, List *args);
|
||||
static Expr *simplify_function(Oid funcid,
|
||||
Oid result_type, int32 result_typmod,
|
||||
Oid result_collid, Oid input_collid, List **args_p,
|
||||
bool funcvariadic, bool process_args, bool allow_non_const,
|
||||
eval_const_expressions_context *context);
|
||||
Oid result_type, int32 result_typmod,
|
||||
Oid result_collid, Oid input_collid, List **args_p,
|
||||
bool funcvariadic, bool process_args, bool allow_non_const,
|
||||
eval_const_expressions_context *context);
|
||||
static List *reorder_function_arguments(List *args, HeapTuple func_tuple);
|
||||
static List *add_function_defaults(List *args, HeapTuple func_tuple);
|
||||
static List *fetch_function_defaults(HeapTuple func_tuple);
|
||||
static void recheck_cast_function_args(List *args, Oid result_type,
|
||||
HeapTuple func_tuple);
|
||||
HeapTuple func_tuple);
|
||||
static Expr *evaluate_function(Oid funcid, Oid result_type, int32 result_typmod,
|
||||
Oid result_collid, Oid input_collid, List *args,
|
||||
bool funcvariadic,
|
||||
HeapTuple func_tuple,
|
||||
eval_const_expressions_context *context);
|
||||
Oid result_collid, Oid input_collid, List *args,
|
||||
bool funcvariadic,
|
||||
HeapTuple func_tuple,
|
||||
eval_const_expressions_context *context);
|
||||
static Expr *inline_function(Oid funcid, Oid result_type, Oid result_collid,
|
||||
Oid input_collid, List *args,
|
||||
bool funcvariadic,
|
||||
HeapTuple func_tuple,
|
||||
eval_const_expressions_context *context);
|
||||
Oid input_collid, List *args,
|
||||
bool funcvariadic,
|
||||
HeapTuple func_tuple,
|
||||
eval_const_expressions_context *context);
|
||||
static Node *substitute_actual_parameters(Node *expr, int nargs, List *args,
|
||||
int *usecounts);
|
||||
int *usecounts);
|
||||
static Node *substitute_actual_parameters_mutator(Node *node,
|
||||
substitute_actual_parameters_context *context);
|
||||
substitute_actual_parameters_context *context);
|
||||
static void sql_inline_error_callback(void *arg);
|
||||
static Query *substitute_actual_srf_parameters(Query *expr,
|
||||
int nargs, List *args);
|
||||
int nargs, List *args);
|
||||
static Node *substitute_actual_srf_parameters_mutator(Node *node,
|
||||
substitute_actual_srf_parameters_context *context);
|
||||
substitute_actual_srf_parameters_context *context);
|
||||
static bool tlist_matches_coltypelist(List *tlist, List *coltypelist);
|
||||
|
||||
|
||||
|
||||
@@ -36,19 +36,19 @@
|
||||
|
||||
|
||||
static void expand_partitioned_rtentry(PlannerInfo *root, RelOptInfo *relinfo,
|
||||
RangeTblEntry *parentrte,
|
||||
Index parentRTindex, Relation parentrel,
|
||||
PlanRowMark *top_parentrc, LOCKMODE lockmode);
|
||||
RangeTblEntry *parentrte,
|
||||
Index parentRTindex, Relation parentrel,
|
||||
PlanRowMark *top_parentrc, LOCKMODE lockmode);
|
||||
static void expand_single_inheritance_child(PlannerInfo *root,
|
||||
RangeTblEntry *parentrte,
|
||||
Index parentRTindex, Relation parentrel,
|
||||
PlanRowMark *top_parentrc, Relation childrel,
|
||||
RangeTblEntry **childrte_p,
|
||||
Index *childRTindex_p);
|
||||
RangeTblEntry *parentrte,
|
||||
Index parentRTindex, Relation parentrel,
|
||||
PlanRowMark *top_parentrc, Relation childrel,
|
||||
RangeTblEntry **childrte_p,
|
||||
Index *childRTindex_p);
|
||||
static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
|
||||
List *translated_vars);
|
||||
List *translated_vars);
|
||||
static void expand_appendrel_subquery(PlannerInfo *root, RelOptInfo *rel,
|
||||
RangeTblEntry *rte, Index rti);
|
||||
RangeTblEntry *rte, Index rti);
|
||||
|
||||
|
||||
/*
|
||||
|
||||
@@ -27,7 +27,7 @@
|
||||
static bool is_safe_restriction_clause_for(RestrictInfo *rinfo, RelOptInfo *rel);
|
||||
static Expr *extract_or_clause(RestrictInfo *or_rinfo, RelOptInfo *rel);
|
||||
static void consider_new_or_clause(PlannerInfo *root, RelOptInfo *rel,
|
||||
Expr *orclause, RestrictInfo *join_or_rinfo);
|
||||
Expr *orclause, RestrictInfo *join_or_rinfo);
|
||||
|
||||
|
||||
/*
|
||||
|
||||
@@ -55,8 +55,8 @@ static List *translate_sub_tlist(List *tlist, int relid);
|
||||
static int append_total_cost_compare(const void *a, const void *b);
|
||||
static int append_startup_cost_compare(const void *a, const void *b);
|
||||
static List *reparameterize_pathlist_by_child(PlannerInfo *root,
|
||||
List *pathlist,
|
||||
RelOptInfo *child_rel);
|
||||
List *pathlist,
|
||||
RelOptInfo *child_rel);
|
||||
|
||||
|
||||
/*****************************************************************************
|
||||
|
||||
@@ -62,22 +62,22 @@ get_relation_info_hook_type get_relation_info_hook = NULL;
|
||||
|
||||
|
||||
static void get_relation_foreign_keys(PlannerInfo *root, RelOptInfo *rel,
|
||||
Relation relation, bool inhparent);
|
||||
Relation relation, bool inhparent);
|
||||
static bool infer_collation_opclass_match(InferenceElem *elem, Relation idxRel,
|
||||
List *idxExprs);
|
||||
List *idxExprs);
|
||||
static List *get_relation_constraints(PlannerInfo *root,
|
||||
Oid relationObjectId, RelOptInfo *rel,
|
||||
bool include_noinherit,
|
||||
bool include_notnull,
|
||||
bool include_partition);
|
||||
Oid relationObjectId, RelOptInfo *rel,
|
||||
bool include_noinherit,
|
||||
bool include_notnull,
|
||||
bool include_partition);
|
||||
static List *build_index_tlist(PlannerInfo *root, IndexOptInfo *index,
|
||||
Relation heapRelation);
|
||||
Relation heapRelation);
|
||||
static List *get_relation_statistics(RelOptInfo *rel, Relation relation);
|
||||
static void set_relation_partition_info(PlannerInfo *root, RelOptInfo *rel,
|
||||
Relation relation);
|
||||
Relation relation);
|
||||
static PartitionScheme find_partition_scheme(PlannerInfo *root, Relation rel);
|
||||
static void set_baserel_partition_key_exprs(Relation relation,
|
||||
RelOptInfo *rel);
|
||||
RelOptInfo *rel);
|
||||
|
||||
/*
|
||||
* get_relation_info -
|
||||
|
||||
@@ -79,9 +79,9 @@ typedef struct PredIterInfoData
|
||||
|
||||
|
||||
static bool predicate_implied_by_recurse(Node *clause, Node *predicate,
|
||||
bool weak);
|
||||
bool weak);
|
||||
static bool predicate_refuted_by_recurse(Node *clause, Node *predicate,
|
||||
bool weak);
|
||||
bool weak);
|
||||
static PredClass predicate_classify(Node *clause, PredIterInfo info);
|
||||
static void list_startup_fn(Node *clause, PredIterInfo info);
|
||||
static Node *list_next_fn(PredIterInfo info);
|
||||
@@ -94,18 +94,18 @@ static void arrayexpr_startup_fn(Node *clause, PredIterInfo info);
|
||||
static Node *arrayexpr_next_fn(PredIterInfo info);
|
||||
static void arrayexpr_cleanup_fn(PredIterInfo info);
|
||||
static bool predicate_implied_by_simple_clause(Expr *predicate, Node *clause,
|
||||
bool weak);
|
||||
bool weak);
|
||||
static bool predicate_refuted_by_simple_clause(Expr *predicate, Node *clause,
|
||||
bool weak);
|
||||
bool weak);
|
||||
static Node *extract_not_arg(Node *clause);
|
||||
static Node *extract_strong_not_arg(Node *clause);
|
||||
static bool clause_is_strict_for(Node *clause, Node *subexpr, bool allow_false);
|
||||
static bool operator_predicate_proof(Expr *predicate, Node *clause,
|
||||
bool refute_it, bool weak);
|
||||
bool refute_it, bool weak);
|
||||
static bool operator_same_subexprs_proof(Oid pred_op, Oid clause_op,
|
||||
bool refute_it);
|
||||
bool refute_it);
|
||||
static bool operator_same_subexprs_lookup(Oid pred_op, Oid clause_op,
|
||||
bool refute_it);
|
||||
bool refute_it);
|
||||
static Oid get_btree_test_op(Oid pred_op, Oid clause_op, bool refute_it);
|
||||
static void InvalidateOprProofCacheCallBack(Datum arg, int cacheid, uint32 hashvalue);
|
||||
|
||||
|
||||
@@ -38,31 +38,31 @@ typedef struct JoinHashEntry
|
||||
} JoinHashEntry;
|
||||
|
||||
static void build_joinrel_tlist(PlannerInfo *root, RelOptInfo *joinrel,
|
||||
RelOptInfo *input_rel);
|
||||
RelOptInfo *input_rel);
|
||||
static List *build_joinrel_restrictlist(PlannerInfo *root,
|
||||
RelOptInfo *joinrel,
|
||||
RelOptInfo *outer_rel,
|
||||
RelOptInfo *inner_rel);
|
||||
RelOptInfo *joinrel,
|
||||
RelOptInfo *outer_rel,
|
||||
RelOptInfo *inner_rel);
|
||||
static void build_joinrel_joinlist(RelOptInfo *joinrel,
|
||||
RelOptInfo *outer_rel,
|
||||
RelOptInfo *inner_rel);
|
||||
RelOptInfo *outer_rel,
|
||||
RelOptInfo *inner_rel);
|
||||
static List *subbuild_joinrel_restrictlist(RelOptInfo *joinrel,
|
||||
List *joininfo_list,
|
||||
List *new_restrictlist);
|
||||
List *joininfo_list,
|
||||
List *new_restrictlist);
|
||||
static List *subbuild_joinrel_joinlist(RelOptInfo *joinrel,
|
||||
List *joininfo_list,
|
||||
List *new_joininfo);
|
||||
List *joininfo_list,
|
||||
List *new_joininfo);
|
||||
static void set_foreign_rel_properties(RelOptInfo *joinrel,
|
||||
RelOptInfo *outer_rel, RelOptInfo *inner_rel);
|
||||
RelOptInfo *outer_rel, RelOptInfo *inner_rel);
|
||||
static void add_join_rel(PlannerInfo *root, RelOptInfo *joinrel);
|
||||
static void build_joinrel_partition_info(RelOptInfo *joinrel,
|
||||
RelOptInfo *outer_rel, RelOptInfo *inner_rel,
|
||||
List *restrictlist, JoinType jointype);
|
||||
RelOptInfo *outer_rel, RelOptInfo *inner_rel,
|
||||
List *restrictlist, JoinType jointype);
|
||||
static void build_child_join_reltarget(PlannerInfo *root,
|
||||
RelOptInfo *parentrel,
|
||||
RelOptInfo *childrel,
|
||||
int nappinfos,
|
||||
AppendRelInfo **appinfos);
|
||||
RelOptInfo *parentrel,
|
||||
RelOptInfo *childrel,
|
||||
int nappinfos,
|
||||
AppendRelInfo **appinfos);
|
||||
|
||||
|
||||
/*
|
||||
|
||||
@@ -22,22 +22,22 @@
|
||||
|
||||
|
||||
static RestrictInfo *make_restrictinfo_internal(Expr *clause,
|
||||
Expr *orclause,
|
||||
bool is_pushed_down,
|
||||
bool outerjoin_delayed,
|
||||
bool pseudoconstant,
|
||||
Index security_level,
|
||||
Relids required_relids,
|
||||
Relids outer_relids,
|
||||
Relids nullable_relids);
|
||||
Expr *orclause,
|
||||
bool is_pushed_down,
|
||||
bool outerjoin_delayed,
|
||||
bool pseudoconstant,
|
||||
Index security_level,
|
||||
Relids required_relids,
|
||||
Relids outer_relids,
|
||||
Relids nullable_relids);
|
||||
static Expr *make_sub_restrictinfos(Expr *clause,
|
||||
bool is_pushed_down,
|
||||
bool outerjoin_delayed,
|
||||
bool pseudoconstant,
|
||||
Index security_level,
|
||||
Relids required_relids,
|
||||
Relids outer_relids,
|
||||
Relids nullable_relids);
|
||||
bool is_pushed_down,
|
||||
bool outerjoin_delayed,
|
||||
bool pseudoconstant,
|
||||
Index security_level,
|
||||
Relids required_relids,
|
||||
Relids outer_relids,
|
||||
Relids nullable_relids);
|
||||
|
||||
|
||||
/*
|
||||
|
||||
@@ -54,9 +54,9 @@ typedef struct
|
||||
} split_pathtarget_context;
|
||||
|
||||
static bool split_pathtarget_walker(Node *node,
|
||||
split_pathtarget_context *context);
|
||||
split_pathtarget_context *context);
|
||||
static void add_sp_item_to_pathtarget(PathTarget *target,
|
||||
split_pathtarget_item *item);
|
||||
split_pathtarget_item *item);
|
||||
static void add_sp_items_to_pathtarget(PathTarget *target, List *items);
|
||||
|
||||
|
||||
|
||||
@@ -67,17 +67,17 @@ typedef struct
|
||||
} flatten_join_alias_vars_context;
|
||||
|
||||
static bool pull_varnos_walker(Node *node,
|
||||
pull_varnos_context *context);
|
||||
pull_varnos_context *context);
|
||||
static bool pull_varattnos_walker(Node *node, pull_varattnos_context *context);
|
||||
static bool pull_vars_walker(Node *node, pull_vars_context *context);
|
||||
static bool contain_var_clause_walker(Node *node, void *context);
|
||||
static bool contain_vars_of_level_walker(Node *node, int *sublevels_up);
|
||||
static bool locate_var_of_level_walker(Node *node,
|
||||
locate_var_of_level_context *context);
|
||||
locate_var_of_level_context *context);
|
||||
static bool pull_var_clause_walker(Node *node,
|
||||
pull_var_clause_context *context);
|
||||
pull_var_clause_context *context);
|
||||
static Node *flatten_join_alias_vars_mutator(Node *node,
|
||||
flatten_join_alias_vars_context *context);
|
||||
flatten_join_alias_vars_context *context);
|
||||
static Relids alias_relid_set(Query *query, Relids relids);
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user