src/include/optimizer/paths.h

   1 /*-------------------------------------------------------------------------
   2  *
   3  * paths.h
   4  *        prototypes for various files in optimizer/path
   5  *
   6  *
   7  * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
   8  * Portions Copyright (c) 1994, Regents of the University of California
   9  *
  10  * $PostgreSQL$
  11  *
  12  *-------------------------------------------------------------------------
  13  */
  14 #ifndef PATHS_H
  15 #define PATHS_H
  16
  17 #include "nodes/relation.h"
  18
  19
  20 /*
  21  * allpaths.c
  22  */
  23 extern bool enable_geqo;
  24 extern int      geqo_threshold;
  25
  26 /* Hook for plugins to replace standard_join_search() */
  27 typedef RelOptInfo *(*join_search_hook_type) (PlannerInfo *root,
  28                                                                                                                   int levels_needed,
  29                                                                                                                   List *initial_rels);
  30 extern PGDLLIMPORT join_search_hook_type join_search_hook;
  31
  32
  33 extern RelOptInfo *make_one_rel(PlannerInfo *root, List *joinlist);
  34 extern RelOptInfo *standard_join_search(PlannerInfo *root, int levels_needed,
  35                                          List *initial_rels);
  36
  37 #ifdef OPTIMIZER_DEBUG
  38 extern void debug_print_rel(PlannerInfo *root, RelOptInfo *rel);
  39 #endif
  40
  41 /*
  42  * indxpath.c
  43  *        routines to generate index paths
  44  */
  45 typedef enum
  46 {
  47         /* Whether to use ScalarArrayOpExpr to build index qualifications */
  48         SAOP_FORBID,                            /* Do not use ScalarArrayOpExpr */
  49         SAOP_ALLOW,                                     /* OK to use ScalarArrayOpExpr */
  50         SAOP_REQUIRE                            /* Require ScalarArrayOpExpr */
  51 } SaOpControl;
  52
  53 extern void create_index_paths(PlannerInfo *root, RelOptInfo *rel);
  54 extern List *generate_bitmap_or_paths(PlannerInfo *root, RelOptInfo *rel,
  55                                                  List *clauses, List *outer_clauses,
  56                                                  RelOptInfo *outer_rel);
  57 extern void best_inner_indexscan(PlannerInfo *root, RelOptInfo *rel,
  58                                          RelOptInfo *outer_rel, JoinType jointype,
  59                                          Path **cheapest_startup, Path **cheapest_total);
  60 extern List *group_clauses_by_indexkey(IndexOptInfo *index,
  61                                                   List *clauses, List *outer_clauses,
  62                                                   Relids outer_relids,
  63                                                   SaOpControl saop_control,
  64                                                   bool *found_clause);
  65 extern bool eclass_matches_any_index(EquivalenceClass *ec,
  66                                                  EquivalenceMember *em,
  67                                                  RelOptInfo *rel);
  68 extern bool match_index_to_operand(Node *operand, int indexcol,
  69                                            IndexOptInfo *index);
  70 extern List *expand_indexqual_conditions(IndexOptInfo *index,
  71                                                         List *clausegroups);
  72 extern void check_partial_indexes(PlannerInfo *root, RelOptInfo *rel);
  73 extern List *flatten_clausegroups_list(List *clausegroups);
  74
  75 /*
  76  * orindxpath.c
  77  *        additional routines for indexable OR clauses
  78  */
  79 extern bool create_or_index_quals(PlannerInfo *root, RelOptInfo *rel);
  80
  81 /*
  82  * tidpath.h
  83  *        routines to generate tid paths
  84  */
  85 extern void create_tidscan_paths(PlannerInfo *root, RelOptInfo *rel);
  86
  87 /*
  88  * joinpath.c
  89  *         routines to create join paths
  90  */
  91 extern void add_paths_to_joinrel(PlannerInfo *root, RelOptInfo *joinrel,
  92                                          RelOptInfo *outerrel, RelOptInfo *innerrel,
  93                                          JoinType jointype, SpecialJoinInfo *sjinfo,
  94                                          List *restrictlist);
  95
  96 /*
  97  * joinrels.c
  98  *        routines to determine which relations to join
  99  */
 100 extern List *join_search_one_level(PlannerInfo *root, int level,
 101                                           List **joinrels);
 102 extern RelOptInfo *make_join_rel(PlannerInfo *root,
 103                           RelOptInfo *rel1, RelOptInfo *rel2);
 104 extern bool have_join_order_restriction(PlannerInfo *root,
 105                                                         RelOptInfo *rel1, RelOptInfo *rel2);
 106
 107 /*
 108  * equivclass.c
 109  *        routines for managing EquivalenceClasses
 110  */
 111 extern bool process_equivalence(PlannerInfo *root, RestrictInfo *restrictinfo,
 112                                         bool below_outer_join);
 113 extern void reconsider_outer_join_clauses(PlannerInfo *root);
 114 extern EquivalenceClass *get_eclass_for_sort_expr(PlannerInfo *root,
 115                                                  Expr *expr,
 116                                                  Oid expr_datatype,
 117                                                  List *opfamilies,
 118                                                  Index sortref);
 119 extern void generate_base_implied_equalities(PlannerInfo *root);
 120 extern List *generate_join_implied_equalities(PlannerInfo *root,
 121                                                                  RelOptInfo *joinrel,
 122                                                                  RelOptInfo *outer_rel,
 123                                                                  RelOptInfo *inner_rel);
 124 extern bool exprs_known_equal(PlannerInfo *root, Node *item1, Node *item2);
 125 extern void add_child_rel_equivalences(PlannerInfo *root,
 126                                                    AppendRelInfo *appinfo,
 127                                                    RelOptInfo *parent_rel,
 128                                                    RelOptInfo *child_rel);
 129 extern void mutate_eclass_expressions(PlannerInfo *root,
 130                                                   Node *(*mutator) (),
 131                                                   void *context);
 132 extern List *find_eclass_clauses_for_index_join(PlannerInfo *root,
 133                                                                    RelOptInfo *rel,
 134                                                                    Relids outer_relids);
 135 extern bool have_relevant_eclass_joinclause(PlannerInfo *root,
 136                                                                 RelOptInfo *rel1, RelOptInfo *rel2);
 137 extern bool has_relevant_eclass_joinclause(PlannerInfo *root,
 138                                                            RelOptInfo *rel1);
 139 extern bool eclass_useful_for_merging(EquivalenceClass *eclass,
 140                                                   RelOptInfo *rel);
 141
 142 /*
 143  * pathkeys.c
 144  *        utilities for matching and building path keys
 145  */
 146 typedef enum
 147 {
 148         PATHKEYS_EQUAL,                         /* pathkeys are identical */
 149         PATHKEYS_BETTER1,                       /* pathkey 1 is a superset of pathkey 2 */
 150         PATHKEYS_BETTER2,                       /* vice versa */
 151         PATHKEYS_DIFFERENT                      /* neither pathkey includes the other */
 152 } PathKeysComparison;
 153
 154 extern List *canonicalize_pathkeys(PlannerInfo *root, List *pathkeys);
 155 extern PathKeysComparison compare_pathkeys(List *keys1, List *keys2);
 156 extern bool pathkeys_contained_in(List *keys1, List *keys2);
 157 extern Path *get_cheapest_path_for_pathkeys(List *paths, List *pathkeys,
 158                                                            CostSelector cost_criterion);
 159 extern Path *get_cheapest_fractional_path_for_pathkeys(List *paths,
 160                                                                                   List *pathkeys,
 161                                                                                   double fraction);
 162 extern List *build_index_pathkeys(PlannerInfo *root, IndexOptInfo *index,
 163                                          ScanDirection scandir);
 164 extern List *convert_subquery_pathkeys(PlannerInfo *root, RelOptInfo *rel,
 165                                                   List *subquery_pathkeys);
 166 extern List *build_join_pathkeys(PlannerInfo *root,
 167                                         RelOptInfo *joinrel,
 168                                         JoinType jointype,
 169                                         List *outer_pathkeys);
 170 extern List *make_pathkeys_for_sortclauses(PlannerInfo *root,
 171                                                           List *sortclauses,
 172                                                           List *tlist,
 173                                                           bool canonicalize);
 174 extern void cache_mergeclause_eclasses(PlannerInfo *root,
 175                                                    RestrictInfo *restrictinfo);
 176 extern List *find_mergeclauses_for_pathkeys(PlannerInfo *root,
 177                                                            List *pathkeys,
 178                                                            bool outer_keys,
 179                                                            List *restrictinfos);
 180 extern List *select_outer_pathkeys_for_merge(PlannerInfo *root,
 181                                                                 List *mergeclauses,
 182                                                                 RelOptInfo *joinrel);
 183 extern List *make_inner_pathkeys_for_merge(PlannerInfo *root,
 184                                                           List *mergeclauses,
 185                                                           List *outer_pathkeys);
 186 extern int pathkeys_useful_for_merging(PlannerInfo *root,
 187                                                         RelOptInfo *rel,
 188                                                         List *pathkeys);
 189 extern int      pathkeys_useful_for_ordering(PlannerInfo *root, List *pathkeys);
 190 extern List *truncate_useless_pathkeys(PlannerInfo *root,
 191                                                   RelOptInfo *rel,
 192                                                   List *pathkeys);
 193 extern bool has_useful_pathkeys(PlannerInfo *root, RelOptInfo *rel);
 194
 195 #endif   /* PATHS_H */