diff --git a/src/backend/optimizer/path/indxpath.c b/src/backend/optimizer/path/indxpath.c index 0065c8992bd..8ef3438d78c 100644 --- a/src/backend/optimizer/path/indxpath.c +++ b/src/backend/optimizer/path/indxpath.c @@ -193,6 +193,273 @@ static bool ec_member_matches_indexcol(PlannerInfo *root, RelOptInfo *rel, EquivalenceClass *ec, EquivalenceMember *em, void *arg); +typedef struct OrClauseGroupEntry +{ + Node *node; + List *consts; + Oid collation; + Oid opno; + RestrictInfo *rinfo; +} OrClauseGroupEntry; + +/* + * Pass through baserestrictinfo clauses and try to convert OR clauses into IN + * Return a modified clause list or just the same baserestrictinfo, if no + * changes have made. + * XXX: do not change source list of clauses at all. + */ +static List * +transform_ors(PlannerInfo *root, List *baserestrictinfo) +{ + ListCell *lc; + ListCell *lc_cp; + List *modified_rinfo = NIL; + bool something_changed = false; + List *baserestrictinfo_origin = list_copy(baserestrictinfo); + + /* + * Complexity of a clause could be arbitrarily sophisticated. Here, we will + * look up only on the top level of clause list. + * XXX: It is substantiated? Could we change something here? + */ + forboth (lc, baserestrictinfo, lc_cp, baserestrictinfo_origin) + { + RestrictInfo *rinfo = lfirst_node(RestrictInfo, lc); + RestrictInfo *rinfo_base = lfirst_node(RestrictInfo, lc_cp); + List *or_list = NIL; + ListCell *lc_eargs, + *lc_rargs, + *lc_args; + List *groups_list = NIL; + bool change_apply = false; + + if (!restriction_is_or_clause(rinfo)) + { + /* Add a clause without changes */ + modified_rinfo = lappend(modified_rinfo, rinfo); + continue; + } + + /* + * NOTE: + * It is an OR-clause. So, rinfo->orclause is a BoolExpr node, contains + * a list of sub-restrictinfo args, and rinfo->clause - which is the + * same expression, made from bare clauses. To not break selectivity + * caches and other optimizations, use both: + * - use rinfos from orclause if no transformation needed + * - use bare quals from rinfo->clause in the case of transformation, + * to create new RestrictInfo: in this case we have no options to avoid + * selectivity estimation procedure. + */ + forboth(lc_eargs, ((BoolExpr *) rinfo->clause)->args, + lc_rargs, ((BoolExpr *) rinfo->orclause)->args) + { + Expr *bare_orarg = (Expr *) lfirst(lc_eargs); + RestrictInfo *sub_rinfo; + Node *const_expr; + Node *non_const_expr; + ListCell *lc_groups; + OrClauseGroupEntry *gentry; + Oid opno; + + /* It may be one more boolean expression, skip it for now */ + if (!IsA(lfirst(lc_rargs), RestrictInfo)) + { + or_list = lappend(or_list, (void *) bare_orarg); + continue; + } + + sub_rinfo = lfirst_node(RestrictInfo, lc_rargs); + + /* Check: it is an expr of the form 'F(x) oper ConstExpr' */ + if (!IsA(bare_orarg, OpExpr) || + !(bms_is_empty(sub_rinfo->left_relids) ^ + bms_is_empty(sub_rinfo->right_relids)) || + contain_volatile_functions((Node *) bare_orarg)) + { + /* Again, it's not the expr we can transform */ + or_list = lappend(or_list, (void *) bare_orarg); + continue; + } + + /* Get pointers to constant and expression sides of the clause */ + const_expr =bms_is_empty(sub_rinfo->left_relids) ? + get_leftop(sub_rinfo->clause) : + get_rightop(sub_rinfo->clause); + non_const_expr = bms_is_empty(sub_rinfo->left_relids) ? + get_rightop(sub_rinfo->clause) : + get_leftop(sub_rinfo->clause); + + opno = ((OpExpr *) sub_rinfo->clause)->opno; + if (!op_mergejoinable(opno, exprType(non_const_expr))) + { + /* And again, filter out non-equality operators */ + or_list = lappend(or_list, (void *) bare_orarg); + continue; + } + + /* + * At this point we definitely have a transformable clause. + * Classify it and add into specific group of clauses, or create new + * group. + * TODO: to manage complexity in the case of many different clauses + * (X1=C1) OR (X2=C2 OR) ... (XN = CN) we could invent something + * like a hash table (htab key ???). + */ + foreach(lc_groups, groups_list) + { + OrClauseGroupEntry *v = (OrClauseGroupEntry *) lfirst(lc_groups); + + Assert(v->node != NULL); + + if (equal(v->node, non_const_expr)) + { + v->consts = lappend(v->consts, const_expr); + non_const_expr = NULL; + break; + } + } + + if (non_const_expr == NULL) + /* + * The clause classified successfully and added into existed + * clause group. + */ + continue; + + /* New clause group needed */ + gentry = palloc(sizeof(OrClauseGroupEntry)); + gentry->node = non_const_expr; + gentry->consts = list_make1(const_expr); + gentry->collation = exprInputCollation((Node *)sub_rinfo->clause); + gentry->opno = opno; + gentry->rinfo = sub_rinfo; + groups_list = lappend(groups_list, (void *) gentry); + } + + if (groups_list == NIL) + { + /* + * No any transformations possible with this rinfo, just add itself + * to the list and go further. + */ + modified_rinfo = lappend(modified_rinfo, rinfo); + continue; + } + + /* Let's convert each group of clauses to an IN operation. */ + + /* + * Go through the list of groups and convert each, where number of + * consts more than 1. trivial groups move to OR-list again + */ + + foreach(lc_args, groups_list) + { + OrClauseGroupEntry *gentry = (OrClauseGroupEntry *) lfirst(lc_args); + ScalarArrayOpExpr *saopexpr; + ArrayExpr *newa; + + Assert(list_length(gentry->consts) > 0); + + if (list_length(gentry->consts) == 1) + { + /* + * Only one element in the class. Return rinfo into the BoolExpr + * args list unchanged. + */ + list_free(gentry->consts); + or_list = lappend(or_list, (void *) gentry->rinfo->clause); + continue; + } + + /* + * Do the transformation. It's been a long way ;) + * + * As a source of insides, use make_scalar_array_op() + */ + + newa = makeNode(ArrayExpr); + newa->element_typeid = exprType(gentry->node); + newa->array_typeid = newa->element_typeid; /* don't used in the case of one dimension, but exprType returns this value */ + newa->multidims = false; + newa->elements = gentry->consts; + newa->location = -1; /* Position of the new clause is undefined */ + + saopexpr = makeNode(ScalarArrayOpExpr); + saopexpr->opno = gentry->opno; + saopexpr->opfuncid = get_opcode(gentry->opno); + saopexpr->useOr = true; + saopexpr->inputcollid = gentry->collation; + saopexpr->args = list_make2(gentry->node, newa); + saopexpr->location = -1; + + /* TODO: study on these parameters. */ + saopexpr->hashfuncid = InvalidOid; + saopexpr->negfuncid = InvalidOid; + + /* + * TODO: here we can try to coerce the array to a Const and find + * hash func instead of linear search (see 50e17ad281b). + * convert_saop_to_hashed_saop((Node *) saopexpr); + */ + + or_list = lappend(or_list, (void *) saopexpr); + change_apply = true; + } + + if (!change_apply) + { + /* + * Each group contains only one element - use rinfo as is. + */ + modified_rinfo = lappend(modified_rinfo, rinfo); + list_free(or_list); + list_free_deep(groups_list); + continue; + } + + /* + * Make a new version of the restriction. Remember source restriction + * can be used in another path (SeqScan, for example). + */ + + /* One more trick: assemble correct clause */ + rinfo = make_restrictinfo(root, + list_length(or_list) > 1 ? make_orclause(or_list) : + (Expr *) linitial(or_list), + rinfo->is_pushed_down, + rinfo->has_clone, + rinfo->is_clone, + rinfo->pseudoconstant, + rinfo->security_level, + rinfo->required_relids, + rinfo->incompatible_relids, + rinfo->outer_relids); + rinfo->eval_cost=rinfo_base->eval_cost; + rinfo->norm_selec=rinfo_base->norm_selec; + rinfo->outer_selec=rinfo_base->outer_selec; + rinfo->left_bucketsize=rinfo_base->left_bucketsize; + rinfo->right_bucketsize=rinfo_base->right_bucketsize; + rinfo->left_mcvfreq=rinfo_base->left_mcvfreq; + rinfo->right_mcvfreq=rinfo_base->right_mcvfreq; + modified_rinfo = lappend(modified_rinfo, rinfo); + list_free_deep(groups_list); + something_changed = true; + } + + /* + * Check if transformation has made. If nothing changed - return + * baserestrictinfo as is. + */ + if (something_changed) + { + return modified_rinfo; + } + + list_free(modified_rinfo); + return baserestrictinfo; +} /* * create_index_paths() @@ -3309,11 +3576,16 @@ check_index_predicates(PlannerInfo *root, RelOptInfo *rel) * not, this is all we need to do. */ have_partial = false; + + if (rel->reloptkind == RELOPT_BASEREL) + rel->baserestrictinfo = transform_ors(root, rel->baserestrictinfo); + foreach(lc, rel->indexlist) { IndexOptInfo *index = (IndexOptInfo *) lfirst(lc); index->indrestrictinfo = rel->baserestrictinfo; + if (index->indpred) have_partial = true; }