40 #define IndexCollMatchesExprColl(idxcollation, exprcollation) \
41 ((idxcollation) == InvalidOid || (idxcollation) == (exprcollation))
82 List **bitindexpaths);
89 List *indexjoinclauses,
90 int considered_clauses,
91 List **considered_relids);
99 List **considered_relids);
101 List *indexjoinclauses);
105 List **bitindexpaths);
108 bool useful_predicate,
110 bool *skip_nonnative_saop,
111 bool *skip_lower_saop);
113 List *clauses,
List *other_clauses);
115 List *clauses,
List *other_clauses);
140 List **joinorclauses);
188 List **orderby_clauses_p,
189 List **clause_columns_p);
191 int indexcol,
Expr *clause,
Oid pk_opfamily);
251 bitindexpaths = bitjoinpaths = joinorclauses =
NIL;
272 MemSet(&rclauseset, 0,
sizeof(rclauseset));
289 MemSet(&jclauseset, 0,
sizeof(jclauseset));
291 &jclauseset, &joinorclauses);
297 MemSet(&eclauseset, 0,
sizeof(eclauseset));
319 bitindexpaths =
list_concat(bitindexpaths, indexpaths);
327 bitjoinpaths =
list_concat(bitjoinpaths, indexpaths);
336 if (bitindexpaths !=
NIL)
361 if (bitjoinpaths !=
NIL)
363 List *all_path_outers;
367 all_path_outers =
NIL;
368 foreach(lc, bitjoinpaths)
374 all_path_outers =
lappend(all_path_outers, required_outer);
378 foreach(lc, all_path_outers)
390 foreach(lcp, bitjoinpaths)
395 this_path_set =
lappend(this_path_set, path);
402 this_path_set =
list_concat(this_path_set, bitindexpaths);
411 required_outer, loop_count, 0);
438 List **bitindexpaths)
440 int considered_clauses = 0;
465 for (indexcol = 0; indexcol <
index->nkeycolumns; indexcol++)
470 rclauseset, jclauseset, eclauseset,
478 rclauseset, jclauseset, eclauseset,
504 List **bitindexpaths,
505 List *indexjoinclauses,
506 int considered_clauses,
507 List **considered_relids)
512 foreach(lc, indexjoinclauses)
517 int num_considered_relids;
536 num_considered_relids =
list_length(*considered_relids);
537 for (
int pos = 0; pos < num_considered_relids; pos++)
568 if (
list_length(*considered_relids) >= 10 * considered_clauses)
573 rclauseset, jclauseset, eclauseset,
581 rclauseset, jclauseset, eclauseset,
607 List **bitindexpaths,
609 List **considered_relids)
619 MemSet(&clauseset, 0,
sizeof(clauseset));
621 for (indexcol = 0; indexcol <
index->nkeycolumns; indexcol++)
671 *considered_relids =
lappend(*considered_relids, relids);
681 List *indexjoinclauses)
685 foreach(lc, indexjoinclauses)
708 foreach(lc, relids_list)
735 List **bitindexpaths)
738 bool skip_nonnative_saop =
false;
739 bool skip_lower_saop =
false;
752 &skip_nonnative_saop,
767 &skip_nonnative_saop,
783 foreach(lc, indexpaths)
787 if (
index->amhasgettuple)
790 if (
index->amhasgetbitmap &&
793 *bitindexpaths =
lappend(*bitindexpaths, ipath);
801 if (skip_nonnative_saop)
809 *bitindexpaths =
list_concat(*bitindexpaths, indexpaths);
857 bool useful_predicate,
859 bool *skip_nonnative_saop,
860 bool *skip_lower_saop)
867 List *orderbyclauses;
868 List *orderbyclausecols;
869 List *index_pathkeys;
870 List *useful_pathkeys;
871 bool found_lower_saop_clause;
872 bool pathkeys_possibly_useful;
873 bool index_is_ordered;
874 bool index_only_scan;
883 if (!
index->amhasgettuple)
887 if (!
index->amhasgetbitmap)
915 found_lower_saop_clause =
false;
917 for (indexcol = 0; indexcol <
index->nkeycolumns; indexcol++)
929 if (!
index->amsearcharray)
931 if (skip_nonnative_saop)
934 *skip_nonnative_saop =
true;
945 *skip_lower_saop =
true;
948 found_lower_saop_clause =
true;
953 index_clauses =
lappend(index_clauses, iclause);
966 if (index_clauses ==
NIL && !
index->amoptionalkey)
986 !found_lower_saop_clause &&
988 index_is_ordered = (
index->sortopfamily != NULL);
989 if (index_is_ordered && pathkeys_possibly_useful)
995 orderbyclauses =
NIL;
996 orderbyclausecols =
NIL;
998 else if (
index->amcanorderbyop && pathkeys_possibly_useful)
1003 &orderbyclausecols);
1007 useful_pathkeys =
NIL;
1011 useful_pathkeys =
NIL;
1012 orderbyclauses =
NIL;
1013 orderbyclausecols =
NIL;
1030 if (index_clauses !=
NIL || useful_pathkeys !=
NIL || useful_predicate ||
1045 result =
lappend(result, ipath);
1051 if (
index->amcanparallel &&
1082 if (index_is_ordered && pathkeys_possibly_useful)
1088 if (useful_pathkeys !=
NIL)
1100 result =
lappend(result, ipath);
1103 if (
index->amcanparallel &&
1161 List *clauses,
List *other_clauses)
1172 bool useful_predicate;
1175 if (!
index->amhasgetbitmap)
1190 useful_predicate =
false;
1200 if (all_clauses ==
NIL)
1207 useful_predicate =
true;
1214 MemSet(&clauseset, 0,
sizeof(clauseset));
1221 if (!clauseset.
nonempty && !useful_predicate)
1256 List *clauses,
List *other_clauses)
1268 foreach(lc, clauses)
1332 pathlist =
lappend(pathlist, bitmapqual);
1339 if (pathlist !=
NIL)
1342 result =
lappend(result, bitmapqual);
1446 pathinfoarray[npaths++] = pathinfo;
1450 for (
i = 0;
i < npaths;
i++)
1452 if (!pathinfoarray[
i]->unclassifiable &&
1467 pathinfoarray[
i] = pathinfo;
1472 pathinfoarray[npaths++] = pathinfo;
1478 return pathinfoarray[0]->
path;
1493 for (
i = 0;
i < npaths;
i++)
1499 pathinfo = pathinfoarray[
i];
1505 for (
j =
i + 1;
j < npaths;
j++)
1509 pathinfo = pathinfoarray[
j];
1513 if (pathinfo->
preds)
1515 bool redundant =
false;
1518 foreach(l, pathinfo->
preds)
1534 if (newcost < costsofar)
1537 costsofar = newcost;
1551 if (
i == 0 || costsofar < bestcost)
1554 bestcost = costsofar;
1588 if (aselec < bselec)
1590 if (aselec > bselec)
1671 result->
path = path;
1695 foreach(lc, result->
quals)
1702 foreach(lc, result->
preds)
1785 foreach(lc, *nodelist)
1789 if (
equal(node, oldnode))
1794 *nodelist =
lappend(*nodelist, node);
1809 Bitmapset *index_canreturn_attrs = NULL;
1840 foreach(lc,
index->indrestrictinfo)
1851 for (
i = 0;
i <
index->ncolumns;
i++)
1853 int attno =
index->indexkeys[
i];
1863 index_canreturn_attrs =
1910 if (outer_relids == NULL)
1915 while ((outer_relid =
bms_next_member(outer_relids, outer_relid)) >= 0)
1924 if (outer_rel == NULL)
1942 if (result == 0.0 || result > rowcount)
1946 return (result > 0.0) ? result : 1.0;
1982 if (rowcount > nunique)
2003 double rowcount = 1.0;
2027 rowcount *= rel->
rows;
2061 List **joinorclauses)
2076 *joinorclauses =
lappend(*joinorclauses, rinfo);
2094 if (!
index->rel->has_eclass_joins)
2097 for (indexcol = 0; indexcol <
index->nkeycolumns; indexcol++)
2104 arg.indexcol = indexcol;
2109 index->rel->lateral_referencers);
2133 foreach(lc, clauses)
2183 for (indexcol = 0; indexcol <
index->nkeycolumns; indexcol++)
2193 if (iclause->
rinfo == rinfo)
2287 Assert(indexcol < index->nkeycolumns);
2297 opfamily =
index->opfamily[indexcol];
2298 if (IsBooleanOpfamily(opfamily))
2334 iclause->
rinfo = rinfo;
2336 iclause->
lossy =
false;
2433 iclause->
rinfo = rinfo;
2435 iclause->
lossy =
false;
2475 expr_op = clause->
opno;
2478 index_relid =
index->rel->relid;
2479 opfamily =
index->opfamily[indexcol];
2480 idxcollation =
index->indexcollations[indexcol];
2499 iclause->
rinfo = rinfo;
2501 iclause->
lossy =
false;
2538 iclause->
rinfo = rinfo;
2540 iclause->
lossy =
false;
2589 foreach(lc, clause->
args)
2655 foreach(lc, sresult)
2659 indexquals =
lappend(indexquals,
2663 iclause->
rinfo = rinfo;
2702 expr_op = saop->
opno;
2705 index_relid =
index->rel->relid;
2706 opfamily =
index->opfamily[indexcol];
2707 idxcollation =
index->indexcollations[indexcol];
2721 iclause->
rinfo = rinfo;
2723 iclause->
lossy =
false;
2765 if (
index->relam != BTREE_AM_OID)
2768 index_relid =
index->rel->relid;
2769 opfamily =
index->opfamily[indexcol];
2770 idxcollation =
index->indexcollations[indexcol];
2809 var_on_left =
false;
2877 iclause->
rinfo = rinfo;
2882 var_args = clause->
largs;
2883 non_var_args = clause->
rargs;
2887 var_args = clause->
rargs;
2888 non_var_args = clause->
largs;
2935 for (
i = 0;
i <
index->nkeycolumns;
i++)
2939 index->opfamily[
i]) == op_strategy &&
2945 if (
i >=
index->nkeycolumns)
2959 righttypes =
lappend_oid(righttypes, op_righttype);
2972 if (var_on_left && !iclause->
lossy)
2981 if (!iclause->
lossy)
3003 elog(
ERROR,
"unexpected strategy number %d", op_strategy);
3005 forthree(opfamilies_cell, opfamilies,
3006 lefttypes_cell, lefttypes,
3007 righttypes_cell, righttypes)
3016 elog(
ERROR,
"missing operator %d(%u,%u) in opfamily %u",
3017 op_strategy, lefttype, righttype, opfam);
3023 if (matching_cols > 1)
3028 rc->
opnos = new_ops;
3079 List **orderby_clauses_p,
3080 List **clause_columns_p)
3086 *orderby_clauses_p =
NIL;
3087 *clause_columns_p =
NIL;
3090 if (!
index->amcanorderbyop)
3093 foreach(lc1, pathkeys)
3138 for (indexcol = 0; indexcol <
index->nkeycolumns; indexcol++)
3148 orderby_clauses =
lappend(orderby_clauses, expr);
3149 clause_columns =
lappend_int(clause_columns, indexcol);
3163 *orderby_clauses_p = orderby_clauses;
3164 *clause_columns_p = clause_columns;
3207 Assert(indexcol < index->nkeycolumns);
3209 opfamily =
index->opfamily[indexcol];
3210 idxcollation =
index->indexcollations[indexcol];
3219 if (!leftop || !rightop)
3221 expr_op = ((
OpExpr *) clause)->opno;
3222 expr_coll = ((
OpExpr *) clause)->inputcollid;
3258 if (sortfamily != pk_opfamily)
3267 memcpy(newclause, clause,
sizeof(
OpExpr));
3270 newclause->
opno = expr_op;
3274 clause = (
Expr *) newclause;
3323 have_partial =
false;
3330 have_partial =
true;
3353 clauselist =
lappend(clauselist, rinfo);
3423 index->indpred,
false))
3449 Assert(indexcol < index->nkeycolumns);
3451 curFamily =
index->opfamily[indexcol];
3452 curCollation =
index->indexcollations[indexcol];
3464 if (
index->relam == BTREE_AM_OID &&
3544 restrictlist =
lappend(restrictlist, restrictinfo);
3548 if (restrictlist ==
NIL && exprlist ==
NIL)
3561 if (!
ind->unique || !
ind->immediate ||
3569 for (
c = 0;
c <
ind->nkeycolumns;
c++)
3571 bool matched =
false;
3575 foreach(lc, restrictlist)
3611 forboth(lc, exprlist, lc2, oprlist)
3645 if (
c ==
ind->nkeycolumns)
3676 if (!IsBooleanOpfamily(
index->opfamily[indexcol]))
3680 foreach(lc,
index->rel->baserestrictinfo)
3735 indkey =
index->indexkeys[indexcol];
3741 if (operand &&
IsA(operand,
Var) &&
3742 index->rel->relid == ((
Var *) operand)->varno &&
3743 indkey == ((
Var *) operand)->varattno)
3758 for (
i = 0;
i < indexcol;
i++)
3760 if (
index->indexkeys[
i] == 0)
3762 if (indexpr_item == NULL)
3763 elog(
ERROR,
"wrong number of index expressions");
3764 indexpr_item =
lnext(
index->indexprs, indexpr_item);
3767 if (indexpr_item == NULL)
3768 elog(
ERROR,
"wrong number of index expressions");
3777 if (
equal(indexkey, operand))
void create_partial_bitmap_paths(PlannerInfo *root, RelOptInfo *rel, Path *bitmapqual)
bool bms_equal(const Bitmapset *a, const Bitmapset *b)
BMS_Comparison bms_subset_compare(const Bitmapset *a, const Bitmapset *b)
int bms_next_member(const Bitmapset *a, int prevbit)
bool bms_is_subset(const Bitmapset *a, const Bitmapset *b)
void bms_free(Bitmapset *a)
bool bms_is_member(int x, const Bitmapset *a)
Bitmapset * bms_add_member(Bitmapset *a, int x)
Bitmapset * bms_union(const Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_difference(const Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_add_members(Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_del_member(Bitmapset *a, int x)
bool bms_is_empty(const Bitmapset *a)
bool bms_overlap(const Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_copy(const Bitmapset *a)
#define MemSet(start, val, len)
#define OidIsValid(objectId)
bool contain_mutable_functions(Node *clause)
bool contain_volatile_functions(Node *clause)
void cost_bitmap_tree_node(Path *path, Cost *cost, Selectivity *selec)
void cost_bitmap_heap_scan(Path *path, PlannerInfo *root, RelOptInfo *baserel, ParamPathInfo *param_info, Path *bitmapqual, double loop_count)
bool enable_indexonlyscan
bool equal(const void *a, const void *b)
List * generate_implied_equalities_for_column(PlannerInfo *root, RelOptInfo *rel, ec_matches_callback_type callback, void *callback_arg, Relids prohibited_rels)
List * generate_join_implied_equalities(PlannerInfo *root, Relids join_relids, Relids outer_relids, RelOptInfo *inner_rel)
#define OidFunctionCall1(functionId, arg1)
static Path * choose_bitmap_and(PlannerInfo *root, RelOptInfo *rel, List *paths)
static Cost bitmap_and_cost_est(PlannerInfo *root, RelOptInfo *rel, List *paths)
static void find_indexpath_quals(Path *bitmapqual, List **quals, List **preds)
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)
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)
static void match_clause_to_index(PlannerInfo *root, RestrictInfo *rinfo, IndexOptInfo *index, IndexClauseSet *clauseset)
bool is_pseudo_constant_for_index(PlannerInfo *root, Node *expr, IndexOptInfo *index)
static bool eclass_already_used(EquivalenceClass *parent_ec, Relids oldrelids, List *indexjoinclauses)
static void match_join_clauses_to_index(PlannerInfo *root, RelOptInfo *rel, IndexOptInfo *index, IndexClauseSet *clauseset, List **joinorclauses)
static IndexClause * match_saopclause_to_indexcol(PlannerInfo *root, RestrictInfo *rinfo, int indexcol, IndexOptInfo *index)
static bool check_index_only(RelOptInfo *rel, IndexOptInfo *index)
static void match_eclass_clauses_to_index(PlannerInfo *root, IndexOptInfo *index, IndexClauseSet *clauseset)
static bool bms_equal_any(Relids relids, List *relids_list)
static PathClauseUsage * classify_index_clause_usage(Path *path, List **clauselist)
static void get_index_paths(PlannerInfo *root, RelOptInfo *rel, IndexOptInfo *index, IndexClauseSet *clauses, List **bitindexpaths)
void check_index_predicates(PlannerInfo *root, RelOptInfo *rel)
static void match_pathkeys_to_index(IndexOptInfo *index, List *pathkeys, List **orderby_clauses_p, List **clause_columns_p)
static int find_list_position(Node *node, List **nodelist)
static void match_clauses_to_index(PlannerInfo *root, List *clauses, IndexOptInfo *index, IndexClauseSet *clauseset)
static double get_loop_count(PlannerInfo *root, Index cur_relid, Relids outer_relids)
bool relation_has_unique_index_for(PlannerInfo *root, RelOptInfo *rel, List *restrictlist, List *exprlist, List *oprlist)
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)
void create_index_paths(PlannerInfo *root, RelOptInfo *rel)
static double adjust_rowcount_for_semijoins(PlannerInfo *root, Index cur_relid, Index outer_relid, double rowcount)
static IndexClause * match_clause_to_indexcol(PlannerInfo *root, RestrictInfo *rinfo, int indexcol, IndexOptInfo *index)
static bool ec_member_matches_indexcol(PlannerInfo *root, RelOptInfo *rel, EquivalenceClass *ec, EquivalenceMember *em, void *arg)
static IndexClause * get_index_clause_from_support(PlannerInfo *root, RestrictInfo *rinfo, Oid funcid, int indexarg, int indexcol, IndexOptInfo *index)
#define IndexCollMatchesExprColl(idxcollation, exprcollation)
static IndexClause * match_opclause_to_indexcol(PlannerInfo *root, RestrictInfo *rinfo, int indexcol, IndexOptInfo *index)
static Cost bitmap_scan_cost_est(PlannerInfo *root, RelOptInfo *rel, Path *ipath)
bool match_index_to_operand(Node *operand, int indexcol, IndexOptInfo *index)
static IndexClause * match_boolean_index_clause(PlannerInfo *root, RestrictInfo *rinfo, int indexcol, IndexOptInfo *index)
static void consider_index_join_clauses(PlannerInfo *root, RelOptInfo *rel, IndexOptInfo *index, IndexClauseSet *rclauseset, IndexClauseSet *jclauseset, IndexClauseSet *eclauseset, List **bitindexpaths)
static IndexClause * expand_indexqual_rowcompare(PlannerInfo *root, RestrictInfo *rinfo, int indexcol, IndexOptInfo *index, Oid expr_op, bool var_on_left)
static void match_restriction_clauses_to_index(PlannerInfo *root, IndexOptInfo *index, IndexClauseSet *clauseset)
static IndexClause * match_rowcompare_to_indexcol(PlannerInfo *root, RestrictInfo *rinfo, int indexcol, IndexOptInfo *index)
static List * build_paths_for_OR(PlannerInfo *root, RelOptInfo *rel, List *clauses, List *other_clauses)
bool indexcol_is_bool_constant_for_query(PlannerInfo *root, IndexOptInfo *index, int indexcol)
static IndexClause * match_funcclause_to_indexcol(PlannerInfo *root, RestrictInfo *rinfo, int indexcol, IndexOptInfo *index)
static int path_usage_comparator(const void *a, const void *b)
static double approximate_joinrel_size(PlannerInfo *root, Relids relids)
static Expr * match_clause_to_ordering_op(IndexOptInfo *index, int indexcol, Expr *clause, Oid pk_opfamily)
static List * generate_bitmap_or_paths(PlannerInfo *root, RelOptInfo *rel, List *clauses, List *other_clauses)
Assert(fmt[strlen(fmt) - 1] !='\n')
List * list_truncate(List *list, int new_size)
List * lappend(List *list, void *datum)
List * lappend_int(List *list, int datum)
List * lappend_oid(List *list, Oid datum)
List * list_copy(const List *oldlist)
void list_free(List *list)
bool list_member_oid(const List *list, Oid datum)
List * list_concat(List *list1, const List *list2)
List * list_concat_copy(const List *list1, const List *list2)
void get_op_opfamily_properties(Oid opno, Oid opfamily, bool ordering_op, int *strategy, Oid *lefttype, Oid *righttype)
Oid get_op_opfamily_sortfamily(Oid opno, Oid opfamily)
RegProcedure get_func_support(Oid funcid)
int get_op_opfamily_strategy(Oid opno, Oid opfamily)
Oid get_opfamily_member(Oid opfamily, Oid lefttype, Oid righttype, int16 strategy)
bool op_in_opfamily(Oid opno, Oid opfamily)
Oid get_commutator(Oid opno)
Expr * make_opclause(Oid opno, Oid opresulttype, bool opretset, Expr *leftop, Expr *rightop, Oid opcollid, Oid inputcollid)
Node * makeBoolConst(bool value, bool isnull)
void pfree(void *pointer)
void set_opfuncid(OpExpr *opexpr)
static bool is_andclause(const void *clause)
static Expr * get_notclausearg(const void *notclause)
static bool is_opclause(const void *clause)
static Node * get_rightop(const void *clause)
static bool is_notclause(const void *clause)
static Node * get_leftop(const void *clause)
#define IsA(nodeptr, _type_)
@ T_SupportRequestIndexCondition
#define castNode(_type_, nodeptr)
bool has_useful_pathkeys(PlannerInfo *root, RelOptInfo *rel)
List * truncate_useless_pathkeys(PlannerInfo *root, RelOptInfo *rel, List *pathkeys)
List * build_index_pathkeys(PlannerInfo *root, IndexOptInfo *index, ScanDirection scandir)
IndexPath * create_index_path(PlannerInfo *root, IndexOptInfo *index, List *indexclauses, List *indexorderbys, List *indexorderbycols, List *pathkeys, ScanDirection indexscandir, bool indexonly, Relids required_outer, double loop_count, bool partial_path)
void add_partial_path(RelOptInfo *parent_rel, Path *new_path)
BitmapOrPath * create_bitmap_or_path(PlannerInfo *root, RelOptInfo *rel, List *bitmapquals)
void add_path(RelOptInfo *parent_rel, Path *new_path)
BitmapAndPath * create_bitmap_and_path(PlannerInfo *root, RelOptInfo *rel, List *bitmapquals)
BitmapHeapPath * create_bitmap_heap_path(PlannerInfo *root, RelOptInfo *rel, Path *bitmapqual, Relids required_outer, double loop_count, int parallel_degree)
#define IS_SIMPLE_REL(rel)
#define PATH_REQ_OUTER(path)
@ RELOPT_OTHER_MEMBER_REL
#define lfirst_node(type, lc)
static int list_length(const List *l)
#define forboth(cell1, list1, cell2, list2)
static Oid list_nth_oid(const List *list, int n)
#define list_make1_oid(x1)
#define forthree(cell1, list1, cell2, list2, cell3, list3)
static ListCell * list_head(const List *l)
static void * list_nth(const List *list, int n)
static ListCell * lnext(const List *l, const ListCell *c)
#define list_make1_int(x1)
#define list_make2(x1, x2)
#define qsort(a, b, c, d)
#define DatumGetPointer(X)
#define PointerGetDatum(X)
bool predicate_implied_by(List *predicate_list, List *clause_list, bool weak)
PlanRowMark * get_plan_rowmark(List *rowmarks, Index rtindex)
Relids find_childrel_parents(PlannerInfo *root, RelOptInfo *rel)
bool restriction_is_or_clause(RestrictInfo *restrictinfo)
RestrictInfo * commute_restrictinfo(RestrictInfo *rinfo, Oid comm_op)
bool restriction_is_securely_promotable(RestrictInfo *restrictinfo, RelOptInfo *rel)
bool join_clause_is_movable_to(RestrictInfo *rinfo, RelOptInfo *baserel)
#define make_simple_restrictinfo(root, clause)
@ NoMovementScanDirection
double estimate_num_groups(PlannerInfo *root, List *groupExprs, double input_rows, List **pgset, EstimationInfo *estinfo)
#define BTGreaterStrategyNumber
#define BTLessStrategyNumber
#define BTLessEqualStrategyNumber
#define BTGreaterEqualStrategyNumber
BoolTestType booltesttype
List * indexclauses[INDEX_MAX_KEYS]
struct RestrictInfo * rinfo
Selectivity indexselectivity
EquivalenceClass * pk_eclass
ParamPathInfo * param_info
int simple_rel_array_size
struct RelOptInfo ** simple_rel_array
struct PathTarget * reltarget
EquivalenceClass * parent_ec
struct IndexOptInfo * index
struct PlannerInfo * root
#define FirstLowInvalidHeapAttributeNumber
bool contain_var_clause(Node *node)
Relids pull_varnos(PlannerInfo *root, Node *node)
void pull_varattnos(Node *node, Index varno, Bitmapset **varattnos)