43#define IndexCollMatchesExprColl(idxcollation, exprcollation) \
44 ((idxcollation) == InvalidOid || (idxcollation) == (exprcollation))
85 List **bitindexpaths);
92 List *indexjoinclauses,
93 int considered_clauses,
94 List **considered_relids);
100 List **bitindexpaths,
102 List **considered_relids);
104 List *indexjoinclauses);
107 List **bitindexpaths);
110 bool useful_predicate,
112 bool *skip_nonnative_saop);
114 List *clauses,
List *other_clauses);
116 List *clauses,
List *other_clauses);
141 List **joinorclauses);
194 List **orderby_clauses_p,
195 List **clause_columns_p);
197 int indexcol,
Expr *clause,
Oid pk_opfamily);
257 bitindexpaths = bitjoinpaths = joinorclauses =
NIL;
278 MemSet(&rclauseset, 0,
sizeof(rclauseset));
295 MemSet(&jclauseset, 0,
sizeof(jclauseset));
297 &jclauseset, &joinorclauses);
303 MemSet(&eclauseset, 0,
sizeof(eclauseset));
325 bitindexpaths =
list_concat(bitindexpaths, indexpaths);
333 bitjoinpaths =
list_concat(bitjoinpaths, indexpaths);
342 if (bitindexpaths !=
NIL)
367 if (bitjoinpaths !=
NIL)
369 List *all_path_outers;
372 all_path_outers =
NIL;
373 foreach(lc, bitjoinpaths)
383 foreach(lc, all_path_outers)
395 foreach(lcp, bitjoinpaths)
400 this_path_set =
lappend(this_path_set, path);
407 this_path_set =
list_concat(this_path_set, bitindexpaths);
416 required_outer, loop_count, 0);
443 List **bitindexpaths)
445 int considered_clauses = 0;
470 for (indexcol = 0; indexcol <
index->nkeycolumns; indexcol++)
475 rclauseset, jclauseset, eclauseset,
483 rclauseset, jclauseset, eclauseset,
509 List **bitindexpaths,
510 List *indexjoinclauses,
511 int considered_clauses,
512 List **considered_relids)
517 foreach(lc, indexjoinclauses)
520 Relids clause_relids = iclause->
rinfo->clause_relids;
522 int num_considered_relids;
525 if (
list_member(*considered_relids, clause_relids))
541 num_considered_relids =
list_length(*considered_relids);
542 for (
int pos = 0; pos < num_considered_relids; pos++)
573 if (
list_length(*considered_relids) >= 10 * considered_clauses)
578 rclauseset, jclauseset, eclauseset,
586 rclauseset, jclauseset, eclauseset,
612 List **bitindexpaths,
614 List **considered_relids)
624 MemSet(&clauseset, 0,
sizeof(clauseset));
626 for (indexcol = 0; indexcol <
index->nkeycolumns; indexcol++)
676 *considered_relids =
lappend(*considered_relids, relids);
686 List *indexjoinclauses)
690 foreach(lc, indexjoinclauses)
695 if (rinfo->parent_ec == parent_ec &&
719 List **bitindexpaths)
722 bool skip_nonnative_saop =
false;
733 &skip_nonnative_saop);
747 foreach(lc, indexpaths)
751 if (
index->amhasgettuple)
754 if (
index->amhasgetbitmap &&
757 *bitindexpaths =
lappend(*bitindexpaths, ipath);
765 if (skip_nonnative_saop)
772 *bitindexpaths =
list_concat(*bitindexpaths, indexpaths);
813 bool useful_predicate,
815 bool *skip_nonnative_saop)
822 List *orderbyclauses;
823 List *orderbyclausecols;
824 List *index_pathkeys;
825 List *useful_pathkeys;
826 bool pathkeys_possibly_useful;
827 bool index_is_ordered;
828 bool index_only_scan;
839 if (!
index->amhasgettuple)
843 if (!
index->amhasgetbitmap)
865 for (indexcol = 0; indexcol <
index->nkeycolumns; indexcol++)
874 if (skip_nonnative_saop && !
index->amsearcharray &&
884 *skip_nonnative_saop =
true;
889 index_clauses =
lappend(index_clauses, iclause);
891 rinfo->clause_relids);
902 if (index_clauses ==
NIL && !
index->amoptionalkey)
919 index_is_ordered = (
index->sortopfamily != NULL);
920 if (index_is_ordered && pathkeys_possibly_useful)
926 orderbyclauses =
NIL;
927 orderbyclausecols =
NIL;
929 else if (
index->amcanorderbyop && pathkeys_possibly_useful)
941 useful_pathkeys =
root->query_pathkeys;
948 useful_pathkeys =
NIL;
949 orderbyclauses =
NIL;
950 orderbyclausecols =
NIL;
967 if (index_clauses !=
NIL || useful_pathkeys !=
NIL || useful_predicate ||
980 result =
lappend(result, ipath);
986 if (
index->amcanparallel &&
1015 if (index_is_ordered && pathkeys_possibly_useful)
1021 if (useful_pathkeys !=
NIL)
1033 result =
lappend(result, ipath);
1036 if (
index->amcanparallel &&
1094 List *clauses,
List *other_clauses)
1105 bool useful_predicate;
1108 if (!
index->amhasgetbitmap)
1123 useful_predicate =
false;
1133 if (all_clauses ==
NIL)
1140 useful_predicate =
true;
1147 MemSet(&clauseset, 0,
sizeof(clauseset));
1154 if (!clauseset.
nonempty && !useful_predicate)
1216 else if (match_a->
opno > match_b->
opno)
1253 bool matched =
false;
1261 orargs = ((
BoolExpr *) rinfo->orclause)->args;
1300 opno = clause->
opno;
1338 nonConstExpr = rightop;
1344 nonConstExpr = leftop;
1367 if (!
index->amhasgetbitmap || !
index->amsearcharray)
1370 for (colnum = 0; colnum <
index->nkeycolumns; colnum++)
1376 matches[
i].
opno = opno;
1387 if (matches[
i].indexnum >= 0)
1411 for (
i = 1;
i <= n;
i++)
1414 if (group_start >= 0 &&
1416 matches[
i].indexnum != matches[group_start].indexnum ||
1417 matches[
i].colnum != matches[group_start].colnum ||
1418 matches[
i].opno != matches[group_start].opno ||
1419 matches[
i].inputcollid != matches[group_start].inputcollid ||
1420 matches[
i].indexnum == -1))
1425 if (
i - group_start == 1)
1429 matches[group_start].argindex));
1444 for (
j = group_start;
j <
i;
j++)
1462 rinfo->pseudoconstant,
1467 result =
lappend(result, subrinfo);
1500 Cost jointcost = 0.0,
1525 if (jointlist !=
NIL && other_clauses ==
NIL)
1547 splitlist =
lappend(splitlist, bitmapqual);
1553 if (splitlist ==
NIL)
1555 else if (jointlist ==
NIL)
1558 return (jointcost < splitcost) ? jointlist : splitlist;
1574 List *clauses,
List *other_clauses)
1586 foreach(lc, clauses)
1593 List *inner_other_clauses =
NIL;
1612 if (groupedArgs != ((
BoolExpr *) rinfo->orclause)->args)
1626 foreach(
j, groupedArgs)
1656 inner_other_clauses);
1696 pathlist =
lappend(pathlist, bitmapqual);
1699 if (inner_other_clauses !=
NIL)
1706 if (pathlist !=
NIL)
1709 result =
lappend(result, bitmapqual);
1813 pathinfoarray[npaths++] = pathinfo;
1817 for (
i = 0;
i < npaths;
i++)
1819 if (!pathinfoarray[
i]->unclassifiable &&
1834 pathinfoarray[
i] = pathinfo;
1839 pathinfoarray[npaths++] = pathinfo;
1845 return pathinfoarray[0]->
path;
1860 for (
i = 0;
i < npaths;
i++)
1866 pathinfo = pathinfoarray[
i];
1872 for (
j =
i + 1;
j < npaths;
j++)
1876 pathinfo = pathinfoarray[
j];
1880 if (pathinfo->
preds)
1882 bool redundant =
false;
1885 foreach(l, pathinfo->
preds)
1901 if (newcost < costsofar)
1904 costsofar = newcost;
1918 if (
i == 0 || costsofar < bestcost)
1921 bestcost = costsofar;
1955 if (aselec < bselec)
1957 if (aselec > bselec)
1973 bpath.
path.type = T_BitmapHeapPath;
1975 bpath.
path.parent = rel;
1977 bpath.
path.param_info = ipath->param_info;
1989 bpath.
path.param_info,
2038 result->
path = path;
2062 foreach(lc, result->
quals)
2069 foreach(lc, result->
preds)
2152 foreach(lc, *nodelist)
2156 if (
equal(node, oldnode))
2161 *nodelist =
lappend(*nodelist, node);
2176 Bitmapset *index_canreturn_attrs = NULL;
2207 foreach(lc,
index->indrestrictinfo)
2218 for (
i = 0;
i <
index->ncolumns;
i++)
2220 int attno =
index->indexkeys[
i];
2230 index_canreturn_attrs =
2277 if (outer_relids == NULL)
2282 while ((outer_relid =
bms_next_member(outer_relids, outer_relid)) >= 0)
2288 if (outer_relid >=
root->simple_rel_array_size)
2290 outer_rel =
root->simple_rel_array[outer_relid];
2291 if (outer_rel == NULL)
2309 if (result == 0.0 || result > rowcount)
2313 return (result > 0.0) ? result : 1.0;
2331 foreach(lc,
root->join_info_list)
2349 if (rowcount > nunique)
2370 double rowcount = 1.0;
2379 if (relid >=
root->simple_rel_array_size)
2381 rel =
root->simple_rel_array[relid];
2394 rowcount *= rel->
rows;
2429 List **joinorclauses)
2466 if (!
index->rel->has_eclass_joins)
2469 for (indexcol = 0; indexcol <
index->nkeycolumns; indexcol++)
2476 arg.indexcol = indexcol;
2481 index->rel->lateral_referencers);
2505 foreach(lc, clauses)
2544 if (rinfo->pseudoconstant)
2555 for (indexcol = 0; indexcol <
index->nkeycolumns; indexcol++)
2565 if (iclause->
rinfo == rinfo)
2664 Assert(indexcol < index->nkeycolumns);
2674 opfamily =
index->opfamily[indexcol];
2711 if (!nt->argisrow &&
2715 iclause->
rinfo = rinfo;
2717 iclause->
lossy =
false;
2739 return IsBuiltinBooleanOpfamily(opfamily);
2831 iclause->
rinfo = rinfo;
2833 iclause->
lossy =
false;
2873 expr_op = clause->
opno;
2874 expr_coll = clause->inputcollid;
2876 index_relid =
index->rel->relid;
2877 opfamily =
index->opfamily[indexcol];
2878 idxcollation =
index->indexcollations[indexcol];
2897 iclause->
rinfo = rinfo;
2899 iclause->
lossy =
false;
2936 iclause->
rinfo = rinfo;
2938 iclause->
lossy =
false;
2987 foreach(lc, clause->
args)
3027 req.
type = T_SupportRequestIndexCondition;
3053 foreach(lc, sresult)
3057 indexquals =
lappend(indexquals,
3061 iclause->
rinfo = rinfo;
3100 expr_op = saop->
opno;
3101 expr_coll = saop->inputcollid;
3103 index_relid =
index->rel->relid;
3104 opfamily =
index->opfamily[indexcol];
3105 idxcollation =
index->indexcollations[indexcol];
3119 iclause->
rinfo = rinfo;
3121 iclause->
lossy =
false;
3163 if (
index->relam != BTREE_AM_OID)
3166 index_relid =
index->rel->relid;
3167 opfamily =
index->opfamily[indexcol];
3168 idxcollation =
index->indexcollations[indexcol];
3207 var_on_left =
false;
3248 Node *indexExpr = NULL;
3250 Node *arrayNode = NULL;
3257 bool firstTime =
true;
3258 bool haveNonConst =
false;
3265 if (!
index->amsearcharray)
3275 foreach(lc, orclause->
args)
3294 opno = subClause->
opno;
3334 constExpr = rightop;
3346 indexExpr = rightop;
3380 inputcollid = subClause->inputcollid;
3395 if (opno != matchOpno ||
3396 inputcollid != subClause->inputcollid ||
3406 haveNonConst =
true;
3407 consts =
lappend(consts, constExpr);
3431 arrayExpr->element_typeid = consttype;
3432 arrayExpr->array_typeid = arraytype;
3433 arrayExpr->multidims =
false;
3437 arrayNode = (
Node *) arrayExpr;
3455 elems[
i++] =
value->constvalue;
3470 saopexpr->opno = matchOpno;
3474 saopexpr->useOr =
true;
3475 saopexpr->inputcollid = inputcollid;
3476 saopexpr->args =
list_make2(indexExpr, arrayNode);
3477 saopexpr->location = -1;
3487 iclause->rinfo = rinfo;
3490 iclause->lossy =
false;
3491 iclause->indexcol = indexcol;
3492 iclause->indexcols =
NIL;
3541 iclause->
rinfo = rinfo;
3546 var_args = clause->
largs;
3547 non_var_args = clause->
rargs;
3551 var_args = clause->
rargs;
3552 non_var_args = clause->
largs;
3599 for (
i = 0;
i <
index->nkeycolumns;
i++)
3603 index->opfamily[
i]) == op_strategy &&
3609 if (
i >=
index->nkeycolumns)
3623 righttypes =
lappend_oid(righttypes, op_righttype);
3636 if (var_on_left && !iclause->
lossy)
3645 if (!iclause->
lossy)
3667 elog(
ERROR,
"unexpected strategy number %d", op_strategy);
3669 forthree(opfamilies_cell, opfamilies,
3670 lefttypes_cell, lefttypes,
3671 righttypes_cell, righttypes)
3680 elog(
ERROR,
"missing operator %d(%u,%u) in opfamily %u",
3681 op_strategy, lefttype, righttype, opfam);
3687 if (matching_cols > 1)
3692 rc->opnos = new_ops;
3743 List **orderby_clauses_p,
3744 List **clause_columns_p)
3748 *orderby_clauses_p =
NIL;
3749 *clause_columns_p =
NIL;
3752 if (!
index->amcanorderbyop)
3755 foreach(lc1, pathkeys)
3768 if (pathkey->pk_eclass->ec_has_volatile)
3779 foreach(lc2, pathkey->pk_eclass->ec_members)
3796 for (indexcol = 0; indexcol <
index->nkeycolumns; indexcol++)
3806 *orderby_clauses_p =
lappend(*orderby_clauses_p, expr);
3807 *clause_columns_p =
lappend_int(*clause_columns_p, indexcol);
3866 Assert(indexcol < index->nkeycolumns);
3868 opfamily =
index->opfamily[indexcol];
3869 idxcollation =
index->indexcollations[indexcol];
3878 if (!leftop || !rightop)
3880 expr_op = ((
OpExpr *) clause)->opno;
3881 expr_coll = ((
OpExpr *) clause)->inputcollid;
3917 if (sortfamily != pk_opfamily)
3926 memcpy(newclause, clause,
sizeof(
OpExpr));
3929 newclause->
opno = expr_op;
3933 clause = (
Expr *) newclause;
3982 have_partial =
false;
3989 have_partial =
true;
4012 clauselist =
lappend(clauselist, rinfo);
4087 index->indpred,
false))
4113 Assert(indexcol < index->nkeycolumns);
4115 curFamily =
index->opfamily[indexcol];
4116 curCollation =
index->indexcollations[indexcol];
4128 if (
index->relam == BTREE_AM_OID &&
4187 if (restrictinfo->mergeopfamilies ==
NIL)
4197 restrictinfo->outer_is_left =
true;
4202 restrictinfo->outer_is_left =
false;
4208 restrictlist =
lappend(restrictlist, restrictinfo);
4212 if (restrictlist ==
NIL && exprlist ==
NIL)
4229 if (!
ind->unique || !
ind->immediate ||
ind->indpred !=
NIL)
4236 for (
c = 0;
c <
ind->nkeycolumns;
c++)
4238 bool matched =
false;
4242 foreach(lc, restrictlist)
4263 if (rinfo->outer_is_left)
4278 forboth(lc, exprlist, lc2, oprlist)
4312 if (
c ==
ind->nkeycolumns)
4347 foreach(lc,
index->rel->baserestrictinfo)
4356 if (rinfo->pseudoconstant)
4402 indkey =
index->indexkeys[indexcol];
4408 if (operand &&
IsA(operand,
Var) &&
4409 index->rel->relid == ((
Var *) operand)->varno &&
4410 indkey == ((
Var *) operand)->varattno &&
4411 ((
Var *) operand)->varnullingrels == NULL)
4426 for (
i = 0;
i < indexcol;
i++)
4428 if (
index->indexkeys[
i] == 0)
4430 if (indexpr_item == NULL)
4431 elog(
ERROR,
"wrong number of index expressions");
4432 indexpr_item =
lnext(
index->indexprs, indexpr_item);
4435 if (indexpr_item == NULL)
4436 elog(
ERROR,
"wrong number of index expressions");
4445 if (
equal(indexkey, operand))
void create_partial_bitmap_paths(PlannerInfo *root, RelOptInfo *rel, Path *bitmapqual)
ArrayType * construct_array(Datum *elems, int nelems, Oid elmtype, int elmlen, bool elmbyval, char elmalign)
Bitmapset * bms_difference(const Bitmapset *a, const Bitmapset *b)
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)
Bitmapset * bms_del_members(Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_del_member(Bitmapset *a, int x)
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_add_members(Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_union(const Bitmapset *a, const Bitmapset *b)
bool bms_overlap(const Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_copy(const Bitmapset *a)
#define Assert(condition)
#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, SpecialJoinInfo *sjinfo)
#define OidFunctionCall1(functionId, arg1)
static bool IsBooleanOpfamily(Oid opfamily)
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 int or_arg_index_match_cmp(const void *a, const void *b)
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 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 List * build_index_paths(PlannerInfo *root, RelOptInfo *rel, IndexOptInfo *index, IndexClauseSet *clauses, bool useful_predicate, ScanTypeControl scantype, bool *skip_nonnative_saop)
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_orclause_to_indexcol(PlannerInfo *root, RestrictInfo *rinfo, int indexcol, IndexOptInfo *index)
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 List * group_similar_or_args(PlannerInfo *root, RelOptInfo *rel, RestrictInfo *rinfo)
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)
static List * make_bitmap_paths_for_or_group(PlannerInfo *root, RelOptInfo *rel, RestrictInfo *ri, List *other_clauses)
if(TABLE==NULL||TABLE_index==NULL)
List * lappend(List *list, void *datum)
List * list_delete(List *list, void *datum)
List * list_append_unique(List *list, void *datum)
List * list_concat(List *list1, const List *list2)
List * list_concat_copy(const List *list1, const List *list2)
List * list_copy(const List *oldlist)
List * lappend_int(List *list, int datum)
List * lappend_oid(List *list, Oid datum)
void list_free(List *list)
bool list_member_oid(const List *list, Oid datum)
List * list_truncate(List *list, int new_size)
bool list_member(const List *list, const void *datum)
List * list_copy_head(const List *oldlist, int len)
List * list_append_unique_ptr(List *list, void *datum)
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)
bool type_is_rowtype(Oid typid)
RegProcedure get_func_support(Oid funcid)
void get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval, char *typalign)
RegProcedure get_opcode(Oid opno)
Oid get_op_rettype(Oid opno)
int get_op_opfamily_strategy(Oid opno, Oid opfamily)
Oid get_opfamily_member(Oid opfamily, Oid lefttype, Oid righttype, int16 strategy)
Oid get_array_type(Oid typid)
bool op_in_opfamily(Oid opno, Oid opfamily)
Oid get_commutator(Oid opno)
Expr * make_orclause(List *orclauses)
Node * makeBoolConst(bool value, bool isnull)
Expr * make_opclause(Oid opno, Oid opresulttype, bool opretset, Expr *leftop, Expr *rightop, Oid opcollid, Oid inputcollid)
Const * makeConst(Oid consttype, int32 consttypmod, Oid constcollid, int constlen, Datum constvalue, bool constisnull, bool constbyval)
void pfree(void *pointer)
Oid exprType(const Node *expr)
void set_opfuncid(OpExpr *opexpr)
static bool is_andclause(const void *clause)
static Node * get_rightop(const void *clause)
static bool is_opclause(const void *clause)
static bool is_notclause(const void *clause)
static Expr * get_notclausearg(const void *notclause)
static Node * get_leftop(const void *clause)
#define IsA(nodeptr, _type_)
#define castNode(_type_, nodeptr)
List * truncate_useless_pathkeys(PlannerInfo *root, RelOptInfo *rel, List *pathkeys)
bool has_useful_pathkeys(PlannerInfo *root, RelOptInfo *rel)
List * build_index_pathkeys(PlannerInfo *root, IndexOptInfo *index, ScanDirection scandir)
BitmapAndPath * create_bitmap_and_path(PlannerInfo *root, RelOptInfo *rel, List *bitmapquals)
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)
BitmapHeapPath * create_bitmap_heap_path(PlannerInfo *root, RelOptInfo *rel, Path *bitmapqual, Relids required_outer, double loop_count, int parallel_degree)
void add_path(RelOptInfo *parent_rel, Path *new_path)
#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 void * list_nth(const List *list, int n)
#define foreach_node(type, var, lst)
static ListCell * list_head(const List *l)
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)
static Datum PointerGetDatum(const void *X)
static Pointer DatumGetPointer(Datum 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)
bool restriction_is_securely_promotable(RestrictInfo *restrictinfo, RelOptInfo *rel)
RestrictInfo * make_plain_restrictinfo(PlannerInfo *root, Expr *clause, Expr *orclause, bool is_pushed_down, bool has_clone, bool is_clone, bool pseudoconstant, Index security_level, Relids required_relids, Relids incompatible_relids, Relids outer_relids)
bool join_clause_is_movable_to(RestrictInfo *rinfo, RelOptInfo *baserel)
RestrictInfo * commute_restrictinfo(RestrictInfo *rinfo, Oid comm_op)
#define make_simple_restrictinfo(root, clause)
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
struct PathTarget * reltarget
Relids incompatible_relids
struct IndexOptInfo * index
struct PlannerInfo * root
#define FirstLowInvalidHeapAttributeNumber
#define FirstNormalObjectId
bool contain_var_clause(Node *node)
Relids pull_varnos(PlannerInfo *root, Node *node)
void pull_varattnos(Node *node, Index varno, Bitmapset **varattnos)