yb_ddl_parser 0.1.0

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/optimizer/pathnode.h

@@ -0,0 +1,359 @@
+/*-------------------------------------------------------------------------
+ *
+ * pathnode.h
+ *	  prototypes for pathnode.c, relnode.c.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/pathnode.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PATHNODE_H
+#define PATHNODE_H
+
+#include "nodes/bitmapset.h"
+#include "nodes/pathnodes.h"
+
+
+/*
+ * prototypes for pathnode.c
+ */
+extern int	compare_path_costs(Path *path1, Path *path2,
+							   CostSelector criterion);
+extern int	compare_fractional_path_costs(Path *path1, Path *path2,
+										  double fraction);
+extern void set_cheapest(RelOptInfo *parent_rel);
+extern void add_path(RelOptInfo *parent_rel, Path *new_path);
+extern bool add_path_precheck(RelOptInfo *parent_rel,
+							  Cost startup_cost, Cost total_cost,
+							  List *pathkeys, Relids required_outer);
+extern void add_partial_path(RelOptInfo *parent_rel, Path *new_path);
+extern bool add_partial_path_precheck(RelOptInfo *parent_rel,
+									  Cost total_cost, List *pathkeys);
+
+extern Path *create_seqscan_path(PlannerInfo *root, RelOptInfo *rel,
+								 Relids required_outer, int parallel_workers);
+extern Path *create_samplescan_path(PlannerInfo *root, RelOptInfo *rel,
+									Relids required_outer);
+extern IndexPath *create_index_path(PlannerInfo *root,
+									IndexOptInfo *index,
+									List *indexclauses,
+									List *yb_bitmap_idx_pushdowns,
+									List *indexorderbys,
+									List *indexorderbycols,
+									List *pathkeys,
+									ScanDirection indexscandir,
+									bool indexonly,
+									Relids required_outer,
+									double loop_count,
+									bool partial_path,
+									List *yb_merge_scan_saop_cols);
+extern BitmapHeapPath *create_bitmap_heap_path(PlannerInfo *root,
+											   RelOptInfo *rel,
+											   Path *bitmapqual,
+											   Relids required_outer,
+											   double loop_count,
+											   int parallel_degree);
+extern YbBitmapTablePath *create_yb_bitmap_table_path(PlannerInfo *root,
+													  RelOptInfo *rel,
+													  Path *bitmapqual,
+													  Relids required_outer,
+													  double loop_count,
+													  int parallel_degree);
+extern BitmapAndPath *create_bitmap_and_path(PlannerInfo *root,
+											 RelOptInfo *rel,
+											 List *bitmapquals);
+extern BitmapOrPath *create_bitmap_or_path(PlannerInfo *root,
+										   RelOptInfo *rel,
+										   List *bitmapquals);
+extern TidPath *create_tidscan_path(PlannerInfo *root, RelOptInfo *rel,
+									List *tidquals, Relids required_outer);
+extern TidRangePath *create_tidrangescan_path(PlannerInfo *root,
+											  RelOptInfo *rel,
+											  List *tidrangequals,
+											  Relids required_outer);
+extern 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);
+extern MergeAppendPath *create_merge_append_path(PlannerInfo *root,
+												 RelOptInfo *rel,
+												 List *subpaths,
+												 List *pathkeys,
+												 Relids required_outer);
+extern GroupResultPath *create_group_result_path(PlannerInfo *root,
+												 RelOptInfo *rel,
+												 PathTarget *target,
+												 List *havingqual);
+extern MaterialPath *create_material_path(RelOptInfo *rel, Path *subpath);
+extern MemoizePath *create_memoize_path(PlannerInfo *root,
+										RelOptInfo *rel,
+										Path *subpath,
+										List *param_exprs,
+										List *hash_operators,
+										bool singlerow,
+										bool binary_mode,
+										double calls);
+extern UniquePath *create_unique_path(PlannerInfo *root, RelOptInfo *rel,
+									  Path *subpath, SpecialJoinInfo *sjinfo);
+extern GatherPath *create_gather_path(PlannerInfo *root,
+									  RelOptInfo *rel, Path *subpath, PathTarget *target,
+									  Relids required_outer, double *rows);
+extern GatherMergePath *create_gather_merge_path(PlannerInfo *root,
+												 RelOptInfo *rel,
+												 Path *subpath,
+												 PathTarget *target,
+												 List *pathkeys,
+												 Relids required_outer,
+												 double *rows);
+extern SubqueryScanPath *create_subqueryscan_path(PlannerInfo *root,
+												  RelOptInfo *rel, Path *subpath,
+												  List *pathkeys, Relids required_outer);
+extern Path *create_functionscan_path(PlannerInfo *root, RelOptInfo *rel,
+									  List *pathkeys, Relids required_outer);
+extern Path *create_valuesscan_path(PlannerInfo *root, RelOptInfo *rel,
+									Relids required_outer);
+extern Path *create_tablefuncscan_path(PlannerInfo *root, RelOptInfo *rel,
+									   Relids required_outer);
+extern Path *create_ctescan_path(PlannerInfo *root, RelOptInfo *rel,
+								 Relids required_outer);
+extern Path *create_namedtuplestorescan_path(PlannerInfo *root, RelOptInfo *rel,
+											 Relids required_outer);
+extern Path *create_resultscan_path(PlannerInfo *root, RelOptInfo *rel,
+									Relids required_outer);
+extern Path *create_worktablescan_path(PlannerInfo *root, RelOptInfo *rel,
+									   Relids required_outer);
+extern ForeignPath *create_foreignscan_path(PlannerInfo *root, RelOptInfo *rel,
+											PathTarget *target,
+											double rows, Cost startup_cost, Cost total_cost,
+											List *pathkeys,
+											Relids required_outer,
+											Path *fdw_outerpath,
+											List *fdw_private);
+extern ForeignPath *create_foreign_join_path(PlannerInfo *root, RelOptInfo *rel,
+											 PathTarget *target,
+											 double rows, Cost startup_cost, Cost total_cost,
+											 List *pathkeys,
+											 Relids required_outer,
+											 Path *fdw_outerpath,
+											 List *fdw_private);
+extern ForeignPath *create_foreign_upper_path(PlannerInfo *root, RelOptInfo *rel,
+											  PathTarget *target,
+											  double rows, Cost startup_cost, Cost total_cost,
+											  List *pathkeys,
+											  Path *fdw_outerpath,
+											  List *fdw_private);
+
+extern Relids calc_nestloop_required_outer(Relids outerrelids,
+										   Relids outer_paramrels,
+										   Relids innerrelids,
+										   Relids inner_paramrels);
+extern Relids calc_non_nestloop_required_outer(Path *outer_path, Path *inner_path);
+
+extern NestPath *create_nestloop_path(PlannerInfo *root,
+									  RelOptInfo *joinrel,
+									  JoinType jointype,
+									  JoinCostWorkspace *workspace,
+									  JoinPathExtraData *extra,
+									  Path *outer_path,
+									  Path *inner_path,
+									  List *restrict_clauses,
+									  List *pathkeys,
+									  Relids required_outer);
+
+extern MergePath *create_mergejoin_path(PlannerInfo *root,
+										RelOptInfo *joinrel,
+										JoinType jointype,
+										JoinCostWorkspace *workspace,
+										JoinPathExtraData *extra,
+										Path *outer_path,
+										Path *inner_path,
+										List *restrict_clauses,
+										List *pathkeys,
+										Relids required_outer,
+										List *mergeclauses,
+										List *outersortkeys,
+										List *innersortkeys);
+
+extern HashPath *create_hashjoin_path(PlannerInfo *root,
+									  RelOptInfo *joinrel,
+									  JoinType jointype,
+									  JoinCostWorkspace *workspace,
+									  JoinPathExtraData *extra,
+									  Path *outer_path,
+									  Path *inner_path,
+									  bool parallel_hash,
+									  List *restrict_clauses,
+									  Relids required_outer,
+									  List *hashclauses);
+
+extern ProjectionPath *create_projection_path(PlannerInfo *root,
+											  RelOptInfo *rel,
+											  Path *subpath,
+											  PathTarget *target);
+extern Path *apply_projection_to_path(PlannerInfo *root,
+									  RelOptInfo *rel,
+									  Path *path,
+									  PathTarget *target);
+extern ProjectSetPath *create_set_projection_path(PlannerInfo *root,
+												  RelOptInfo *rel,
+												  Path *subpath,
+												  PathTarget *target);
+extern SortPath *create_sort_path(PlannerInfo *root,
+								  RelOptInfo *rel,
+								  Path *subpath,
+								  List *pathkeys,
+								  double limit_tuples);
+extern IncrementalSortPath *create_incremental_sort_path(PlannerInfo *root,
+														 RelOptInfo *rel,
+														 Path *subpath,
+														 List *pathkeys,
+														 int presorted_keys,
+														 double limit_tuples);
+extern GroupPath *create_group_path(PlannerInfo *root,
+									RelOptInfo *rel,
+									Path *subpath,
+									List *groupClause,
+									List *qual,
+									double numGroups);
+extern UpperUniquePath *create_upper_unique_path(PlannerInfo *root,
+												 RelOptInfo *rel,
+												 Path *subpath,
+												 int numCols,
+												 double numGroups);
+extern 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);
+extern GroupingSetsPath *create_groupingsets_path(PlannerInfo *root,
+												  RelOptInfo *rel,
+												  Path *subpath,
+												  List *having_qual,
+												  AggStrategy aggstrategy,
+												  List *rollups,
+												  const AggClauseCosts *agg_costs,
+												  double numGroups);
+extern MinMaxAggPath *create_minmaxagg_path(PlannerInfo *root,
+											RelOptInfo *rel,
+											PathTarget *target,
+											List *mmaggregates,
+											List *quals);
+extern WindowAggPath *create_windowagg_path(PlannerInfo *root,
+											RelOptInfo *rel,
+											Path *subpath,
+											PathTarget *target,
+											List *windowFuncs,
+											WindowClause *winclause,
+											List *qual,
+											bool topwindow);
+extern SetOpPath *create_setop_path(PlannerInfo *root,
+									RelOptInfo *rel,
+									Path *subpath,
+									SetOpCmd cmd,
+									SetOpStrategy strategy,
+									List *distinctList,
+									AttrNumber flagColIdx,
+									int firstFlag,
+									double numGroups,
+									double outputRows);
+extern RecursiveUnionPath *create_recursiveunion_path(PlannerInfo *root,
+													  RelOptInfo *rel,
+													  Path *leftpath,
+													  Path *rightpath,
+													  PathTarget *target,
+													  List *distinctList,
+													  int wtParam,
+													  double numGroups);
+extern LockRowsPath *create_lockrows_path(PlannerInfo *root, RelOptInfo *rel,
+										  Path *subpath, List *rowMarks, int epqParam);
+extern ModifyTablePath *create_modifytable_path(PlannerInfo *root,
+												RelOptInfo *rel,
+												Path *subpath,
+												CmdType operation, bool canSetTag,
+												Index nominalRelation, Index rootRelation,
+												bool partColsUpdated,
+												List *resultRelations,
+												List *updateColnosLists,
+												List *withCheckOptionLists, List *returningLists,
+												List *rowMarks, OnConflictExpr *onconflict,
+												List *mergeActionLists, int epqParam);
+extern LimitPath *create_limit_path(PlannerInfo *root, RelOptInfo *rel,
+									Path *subpath,
+									Node *limitOffset, Node *limitCount,
+									LimitOption limitOption,
+									int64 offset_est, int64 count_est);
+extern void adjust_limit_rows_costs(double *rows,
+									Cost *startup_cost, Cost *total_cost,
+									int64 offset_est, int64 count_est);
+
+extern Path *reparameterize_path(PlannerInfo *root, Path *path,
+								 Relids required_outer,
+								 double loop_count);
+extern Path *reparameterize_path_by_child(PlannerInfo *root, Path *path,
+										  RelOptInfo *child_rel);
+
+/*
+ * prototypes for relnode.c
+ */
+extern void setup_simple_rel_arrays(PlannerInfo *root);
+extern void expand_planner_arrays(PlannerInfo *root, int add_size);
+extern RelOptInfo *build_simple_rel(PlannerInfo *root, int relid,
+									RelOptInfo *parent);
+extern RelOptInfo *find_base_rel(PlannerInfo *root, int relid);
+extern RelOptInfo *find_join_rel(PlannerInfo *root, Relids relids);
+extern RelOptInfo *build_join_rel(PlannerInfo *root,
+								  Relids joinrelids,
+								  RelOptInfo *outer_rel,
+								  RelOptInfo *inner_rel,
+								  SpecialJoinInfo *sjinfo,
+								  List **restrictlist_ptr);
+extern Relids min_join_parameterization(PlannerInfo *root,
+										Relids joinrelids,
+										RelOptInfo *outer_rel,
+										RelOptInfo *inner_rel);
+extern RelOptInfo *fetch_upper_rel(PlannerInfo *root, UpperRelationKind kind,
+								   Relids relids);
+extern Relids find_childrel_parents(PlannerInfo *root, RelOptInfo *rel);
+extern ParamPathInfo *get_baserel_parampathinfo(PlannerInfo *root,
+												RelOptInfo *baserel,
+												Relids required_outer);
+extern ParamPathInfo *get_joinrel_parampathinfo(PlannerInfo *root,
+												RelOptInfo *joinrel,
+												Path *outer_path,
+												Path *inner_path,
+												SpecialJoinInfo *sjinfo,
+												Relids required_outer,
+												List **restrict_clauses);
+extern ParamPathInfo *get_appendrel_parampathinfo(RelOptInfo *appendrel,
+												  Relids required_outer);
+extern ParamPathInfo *find_param_path_info(RelOptInfo *rel,
+										   Relids required_outer);
+extern RelOptInfo *build_child_join_rel(PlannerInfo *root,
+										RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+										RelOptInfo *parent_joinrel, List *restrictlist,
+										SpecialJoinInfo *sjinfo, JoinType jointype);
+
+/* YB */
+extern bool yb_has_same_batching_reqs(List *paths);
+extern ParamPathInfo *yb_find_batched_param_path_info(RelOptInfo *rel,
+													  Relids required_outer,
+													  Relids yb_required_batched_outer);
+extern Path *yb_create_distinct_index_path(PlannerInfo *root,
+										   IndexOptInfo *index,
+										   IndexPath *basepath,
+										   int yb_distinct_prefixlen,
+										   int yb_distinct_nkeys);
+extern bool ybfindHintAlias(List *ybfindHintAlias, char *hintAlias);
+extern void yb_assign_unique_path_node_id(PlannerInfo *root, Path *path);
+
+#endif							/* PATHNODE_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/optimizer/paths.h

@@ -0,0 +1,292 @@
+/*-------------------------------------------------------------------------
+ *
+ * paths.h
+ *	  prototypes for various files in optimizer/path
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/paths.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PATHS_H
+#define PATHS_H
+
+#include "nodes/pathnodes.h"
+
+/* YB includes */
+#include "pg_yb_utils.h"
+
+
+/*
+ * allpaths.c
+ */
+extern PGDLLIMPORT bool enable_geqo;
+extern PGDLLIMPORT int geqo_threshold;
+extern PGDLLIMPORT int min_parallel_table_scan_size;
+extern PGDLLIMPORT int min_parallel_index_scan_size;
+
+/* Hook for plugins to get control in set_rel_pathlist() */
+typedef void (*set_rel_pathlist_hook_type) (PlannerInfo *root,
+											RelOptInfo *rel,
+											Index rti,
+											RangeTblEntry *rte);
+extern PGDLLIMPORT set_rel_pathlist_hook_type set_rel_pathlist_hook;
+
+/* Hook for plugins to get control in add_paths_to_joinrel() */
+typedef void (*set_join_pathlist_hook_type) (PlannerInfo *root,
+											 RelOptInfo *joinrel,
+											 RelOptInfo *outerrel,
+											 RelOptInfo *innerrel,
+											 JoinType jointype,
+											 JoinPathExtraData *extra);
+extern PGDLLIMPORT set_join_pathlist_hook_type set_join_pathlist_hook;
+
+/* Hook for plugins to replace standard_join_search() */
+typedef RelOptInfo *(*join_search_hook_type) (PlannerInfo *root,
+											  int levels_needed,
+											  List *initial_rels);
+extern PGDLLIMPORT join_search_hook_type join_search_hook;
+
+/* YB */
+extern PGDLLIMPORT bool yb_enable_optimizer_statistics;
+
+
+extern RelOptInfo *make_one_rel(PlannerInfo *root, List *joinlist);
+extern RelOptInfo *standard_join_search(PlannerInfo *root, int levels_needed,
+										List *initial_rels);
+
+extern void generate_gather_paths(PlannerInfo *root, RelOptInfo *rel,
+								  bool override_rows);
+extern void generate_useful_gather_paths(PlannerInfo *root, RelOptInfo *rel,
+										 bool override_rows);
+extern int	compute_parallel_worker(RelOptInfo *rel, double heap_pages,
+									double index_pages, int max_workers);
+extern void create_partial_bitmap_paths(PlannerInfo *root, RelOptInfo *rel,
+										Path *bitmapqual);
+extern void generate_partitionwise_join_paths(PlannerInfo *root,
+											  RelOptInfo *rel);
+
+#ifdef OPTIMIZER_DEBUG
+extern void debug_print_rel(PlannerInfo *root, RelOptInfo *rel);
+#endif
+
+/*
+ * indxpath.c
+ *	  routines to generate index paths
+ */
+extern void create_index_paths(PlannerInfo *root, RelOptInfo *rel);
+extern bool relation_has_unique_index_for(PlannerInfo *root, RelOptInfo *rel,
+										  List *restrictlist,
+										  List *exprlist, List *oprlist);
+extern bool indexcol_is_bool_constant_for_query(PlannerInfo *root,
+												IndexOptInfo *index,
+												int indexcol);
+extern bool match_index_to_operand(Node *operand, int indexcol,
+								   IndexOptInfo *index);
+extern void check_index_predicates(PlannerInfo *root, RelOptInfo *rel);
+
+/*
+ * tidpath.h
+ *	  routines to generate tid paths
+ */
+extern void create_tidscan_paths(PlannerInfo *root, RelOptInfo *rel);
+
+/*
+ * joinpath.c
+ *	   routines to create join paths
+ */
+extern void add_paths_to_joinrel(PlannerInfo *root, RelOptInfo *joinrel,
+								 RelOptInfo *outerrel, RelOptInfo *innerrel,
+								 JoinType jointype, SpecialJoinInfo *sjinfo,
+								 List *restrictlist);
+
+/*
+ * joinrels.c
+ *	  routines to determine which relations to join
+ */
+extern void join_search_one_level(PlannerInfo *root, int level);
+extern RelOptInfo *make_join_rel(PlannerInfo *root,
+								 RelOptInfo *rel1, RelOptInfo *rel2);
+extern bool have_join_order_restriction(PlannerInfo *root,
+										RelOptInfo *rel1, RelOptInfo *rel2);
+extern bool have_dangerous_phv(PlannerInfo *root,
+							   Relids outer_relids, Relids inner_params);
+extern void mark_dummy_rel(RelOptInfo *rel);
+
+/*
+ * equivclass.c
+ *	  routines for managing EquivalenceClasses
+ */
+typedef bool (*ec_matches_callback_type) (PlannerInfo *root,
+										  RelOptInfo *rel,
+										  EquivalenceClass *ec,
+										  EquivalenceMember *em,
+										  void *arg);
+
+extern bool process_equivalence(PlannerInfo *root,
+								RestrictInfo **p_restrictinfo,
+								bool below_outer_join);
+extern Expr *canonicalize_ec_expression(Expr *expr,
+										Oid req_type, Oid req_collation);
+extern void reconsider_outer_join_clauses(PlannerInfo *root);
+extern EquivalenceClass *get_eclass_for_sort_expr(PlannerInfo *root,
+												  Expr *expr,
+												  Relids nullable_relids,
+												  List *opfamilies,
+												  Oid opcintype,
+												  Oid collation,
+												  Index sortref,
+												  Relids rel,
+												  bool create_it);
+extern EquivalenceMember *find_ec_member_matching_expr(EquivalenceClass *ec,
+													   Expr *expr,
+													   Relids relids);
+extern EquivalenceMember *find_computable_ec_member(PlannerInfo *root,
+													EquivalenceClass *ec,
+													List *exprs,
+													Relids relids,
+													bool require_parallel_safe);
+extern bool relation_can_be_sorted_early(PlannerInfo *root, RelOptInfo *rel,
+										 EquivalenceClass *ec,
+										 bool require_parallel_safe);
+extern void generate_base_implied_equalities(PlannerInfo *root);
+extern List *generate_join_implied_equalities(PlannerInfo *root,
+											  Relids join_relids,
+											  Relids outer_relids,
+											  RelOptInfo *inner_rel);
+extern List *generate_join_implied_equalities_for_ecs(PlannerInfo *root,
+													  List *eclasses,
+													  Relids join_relids,
+													  Relids outer_relids,
+													  RelOptInfo *inner_rel);
+extern bool exprs_known_equal(PlannerInfo *root, Node *item1, Node *item2);
+extern EquivalenceClass *match_eclasses_to_foreign_key_col(PlannerInfo *root,
+														   ForeignKeyOptInfo *fkinfo,
+														   int colno);
+extern RestrictInfo *find_derived_clause_for_ec_member(EquivalenceClass *ec,
+													   EquivalenceMember *em);
+extern void add_child_rel_equivalences(PlannerInfo *root,
+									   AppendRelInfo *appinfo,
+									   RelOptInfo *parent_rel,
+									   RelOptInfo *child_rel);
+extern void add_child_join_rel_equivalences(PlannerInfo *root,
+											int nappinfos,
+											AppendRelInfo **appinfos,
+											RelOptInfo *parent_rel,
+											RelOptInfo *child_rel);
+extern List *generate_implied_equalities_for_column(PlannerInfo *root,
+													RelOptInfo *rel,
+													ec_matches_callback_type callback,
+													void *callback_arg,
+													Relids prohibited_rels);
+extern bool have_relevant_eclass_joinclause(PlannerInfo *root,
+											RelOptInfo *rel1, RelOptInfo *rel2);
+extern bool has_relevant_eclass_joinclause(PlannerInfo *root,
+										   RelOptInfo *rel1);
+extern bool eclass_useful_for_merging(PlannerInfo *root,
+									  EquivalenceClass *eclass,
+									  RelOptInfo *rel);
+extern bool is_redundant_derived_clause(RestrictInfo *rinfo, List *clauselist);
+extern bool is_redundant_with_indexclauses(RestrictInfo *rinfo,
+										   List *indexclauses);
+extern EquivalenceMember *yb_find_ec_member_for_var(PlannerInfo *root, Var *var, Index relid, Index target_relid);
+
+/*
+ * pathkeys.c
+ *	  utilities for matching and building path keys
+ */
+typedef enum
+{
+	PATHKEYS_EQUAL,				/* pathkeys are identical */
+	PATHKEYS_BETTER1,			/* pathkey 1 is a superset of pathkey 2 */
+	PATHKEYS_BETTER2,			/* vice versa */
+	PATHKEYS_DIFFERENT			/* neither pathkey includes the other */
+} PathKeysComparison;
+
+extern PathKeysComparison compare_pathkeys(List *keys1, List *keys2);
+extern bool pathkeys_contained_in(List *keys1, List *keys2);
+extern bool pathkeys_count_contained_in(List *keys1, List *keys2, int *n_common);
+extern Path *get_cheapest_path_for_pathkeys(List *paths, List *pathkeys,
+											Relids required_outer,
+											CostSelector cost_criterion,
+											bool require_parallel_safe);
+extern Path *get_cheapest_fractional_path_for_pathkeys(List *paths,
+													   List *pathkeys,
+													   Relids required_outer,
+													   double fraction);
+extern Path *get_cheapest_parallel_safe_total_inner(List *paths);
+extern List *build_index_pathkeys(PlannerInfo *root, IndexOptInfo *index,
+								  ScanDirection scandir, int *yb_distinct_nkeys,
+								  List **yb_merge_scan_saop_cols);
+extern List *build_partition_pathkeys(PlannerInfo *root, RelOptInfo *partrel,
+									  ScanDirection scandir, bool *partialkeys);
+extern List *build_expression_pathkey(PlannerInfo *root, Expr *expr,
+									  Relids nullable_relids, Oid opno,
+									  Relids rel, bool create_it);
+extern List *convert_subquery_pathkeys(PlannerInfo *root, RelOptInfo *rel,
+									   List *subquery_pathkeys,
+									   List *subquery_tlist);
+extern List *build_join_pathkeys(PlannerInfo *root,
+								 RelOptInfo *joinrel,
+								 JoinType jointype,
+								 List *outer_pathkeys);
+extern List *make_pathkeys_for_sortclauses(PlannerInfo *root,
+										   List *sortclauses,
+										   List *tlist);
+extern void initialize_mergeclause_eclasses(PlannerInfo *root,
+											RestrictInfo *restrictinfo);
+extern void update_mergeclause_eclasses(PlannerInfo *root,
+										RestrictInfo *restrictinfo);
+extern List *find_mergeclauses_for_outer_pathkeys(PlannerInfo *root,
+												  List *pathkeys,
+												  List *restrictinfos);
+extern List *select_outer_pathkeys_for_merge(PlannerInfo *root,
+											 List *mergeclauses,
+											 RelOptInfo *joinrel);
+extern List *make_inner_pathkeys_for_merge(PlannerInfo *root,
+										   List *mergeclauses,
+										   List *outer_pathkeys);
+extern List *trim_mergeclauses_for_inner_pathkeys(PlannerInfo *root,
+												  List *mergeclauses,
+												  List *pathkeys);
+extern List *truncate_useless_pathkeys(PlannerInfo *root,
+									   RelOptInfo *rel,
+									   List *pathkeys,
+									   int yb_distinct_nkeys);
+extern bool has_useful_pathkeys(PlannerInfo *root, RelOptInfo *rel);
+extern PathKey *make_canonical_pathkey(PlannerInfo *root,
+									   EquivalenceClass *eclass, Oid opfamily,
+									   int strategy, bool nulls_first);
+extern void add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel,
+									List *live_childrels);
+
+/* YB */
+extern int	yb_compute_parallel_worker(RelOptInfo *rel,
+									   YbTableDistribution yb_dist, int max_workers);
+extern void ybTraceRelOptInfo(PlannerInfo *root, RelOptInfo *relOptInfo, char *msg);
+extern void ybTraceRelOptInfoList(PlannerInfo *root, List *relOptInfoList, char *msg);
+extern void ybTraceRelds(PlannerInfo *root, Relids relids, char *msg);
+extern void ybTracePath(PlannerInfo *root, Path *path, char *msg);
+extern void ybTracePathList(PlannerInfo *root, List *pathList, char *msg);
+extern bool ybFindHintedJoin(PlannerInfo *root, Relids relIds1, Relids relIds2, bool trySwapped);
+extern bool ybFindProhibitedJoin(PlannerInfo *root, NodeTag joinTag, Relids joinRelids);
+extern void ybBuildRelOptInfoString(PlannerInfo *root, RelOptInfo *relOptInfo, StringInfoData *buf);
+extern void ybBuildRelidsString(PlannerInfo *root, Relids relids, StringInfoData *buf);
+extern void ybTraceCheapestPaths(RelOptInfo *rel, char *msg);
+extern Relids yb_get_batched_relids(NestPath *nest);
+extern Relids yb_get_unbatched_relids(NestPath *nest);
+extern bool yb_is_outer_inner_batched(Path *outer, Path *inner);
+extern bool yb_is_nestloop_batched(NestPath *nest);
+extern bool yb_reject_distinct_pushdown(Node *expr);
+extern List *yb_get_uniqkeys(IndexOptInfo *index, int prefixlen);
+extern int	yb_calculate_distinct_prefixlen(PlannerInfo *root,
+											IndexOptInfo *index,
+											List *index_clauses);
+extern bool yb_has_sufficient_uniqkeys(PlannerInfo *root, Path *pathnode);
+extern List *yb_get_ecs_for_query_uniqkeys(PlannerInfo *root);
+extern Path *get_singleton_append_subpath(Path *path);
+
+#endif							/* PATHS_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/optimizer/placeholder.h

@@ -0,0 +1,32 @@
+/*-------------------------------------------------------------------------
+ *
+ * placeholder.h
+ *	  prototypes for optimizer/util/placeholder.c.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/placeholder.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PLACEHOLDER_H
+#define PLACEHOLDER_H
+
+#include "nodes/pathnodes.h"
+
+
+extern PlaceHolderVar *make_placeholder_expr(PlannerInfo *root, Expr *expr,
+											 Relids phrels);
+extern PlaceHolderInfo *find_placeholder_info(PlannerInfo *root,
+											  PlaceHolderVar *phv, bool create_new_ph);
+extern void find_placeholders_in_jointree(PlannerInfo *root);
+extern void update_placeholder_eval_levels(PlannerInfo *root,
+										   SpecialJoinInfo *new_sjinfo);
+extern void fix_placeholder_input_needed_levels(PlannerInfo *root);
+extern void add_placeholders_to_base_rels(PlannerInfo *root);
+extern void add_placeholders_to_joinrel(PlannerInfo *root, RelOptInfo *joinrel,
+										RelOptInfo *outer_rel, RelOptInfo *inner_rel);
+
+#endif							/* PLACEHOLDER_H */