SaOpControl saop_control, ScanTypeControl scantype);
static List *build_paths_for_OR(PlannerInfo *root, RelOptInfo *rel,
List *clauses, List *other_clauses);
-static List *drop_indexable_join_clauses(RelOptInfo *rel, List *clauses);
+static List *generate_bitmap_or_paths(PlannerInfo *root, RelOptInfo *rel,
+ List *clauses, List *other_clauses);
static Path *choose_bitmap_and(PlannerInfo *root, RelOptInfo *rel,
List *paths);
static int path_usage_comparator(const void *a, const void *b);
* restriction list. Add these to bitindexpaths.
*/
indexpaths = generate_bitmap_or_paths(root, rel,
- rel->baserestrictinfo, NIL,
- false);
+ rel->baserestrictinfo, NIL);
bitindexpaths = list_concat(bitindexpaths, indexpaths);
/*
* the joinclause list. Add these to bitjoinpaths.
*/
indexpaths = generate_bitmap_or_paths(root, rel,
- joinorclauses, rel->baserestrictinfo,
- false);
+ joinorclauses, rel->baserestrictinfo);
bitjoinpaths = list_concat(bitjoinpaths, indexpaths);
/*
* other_clauses is a list of additional clauses that can be assumed true
* for the purpose of generating indexquals, but are not to be searched for
* ORs. (See build_paths_for_OR() for motivation.)
- *
- * If restriction_only is true, ignore OR elements that are join clauses.
- * When using this feature it is caller's responsibility that neither clauses
- * nor other_clauses contain any join clauses that are not ORs, as we do not
- * re-filter those lists.
*/
-List *
+static List *
generate_bitmap_or_paths(PlannerInfo *root, RelOptInfo *rel,
- List *clauses, List *other_clauses,
- bool restriction_only)
+ List *clauses, List *other_clauses)
{
List *result = NIL;
List *all_clauses;
{
List *andargs = ((BoolExpr *) orarg)->args;
- if (restriction_only)
- andargs = drop_indexable_join_clauses(rel, andargs);
-
indlist = build_paths_for_OR(root, rel,
andargs,
all_clauses);
indlist = list_concat(indlist,
generate_bitmap_or_paths(root, rel,
andargs,
- all_clauses,
- restriction_only));
+ all_clauses));
}
else
{
Assert(!restriction_is_or_clause((RestrictInfo *) orarg));
orargs = list_make1(orarg);
- if (restriction_only)
- orargs = drop_indexable_join_clauses(rel, orargs);
-
indlist = build_paths_for_OR(root, rel,
orargs,
all_clauses);
return result;
}
-/*
- * drop_indexable_join_clauses
- * Remove any indexable join clauses from the list.
- *
- * This is a helper for generate_bitmap_or_paths(). We leave OR clauses
- * in the list whether they are joins or not, since we might be able to
- * extract a restriction item from an OR list. It's safe to leave such
- * clauses in the list because match_clauses_to_index() will ignore them,
- * so there's no harm in passing such clauses to build_paths_for_OR().
- */
-static List *
-drop_indexable_join_clauses(RelOptInfo *rel, List *clauses)
-{
- List *result = NIL;
- ListCell *lc;
-
- foreach(lc, clauses)
- {
- RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-
- Assert(IsA(rinfo, RestrictInfo));
- if (restriction_is_or_clause(rinfo) ||
- bms_is_subset(rinfo->clause_relids, rel->relids))
- result = lappend(result, rinfo);
- }
- return result;
-}
-
/*
* choose_bitmap_and
* These are appended to the initial contents of *quals and *preds (hence
* caller should initialize those to NIL).
*
- * This is sort of a simplified version of make_restrictinfo_from_bitmapqual;
- * here, we are not trying to produce an accurate representation of the AND/OR
+ * Note we are not trying to produce an accurate representation of the AND/OR
* semantics of the Path, but just find out all the base conditions used.
*
* The result lists contain pointers to the expressions used in the Path,
#include "postgres.h"
#include "optimizer/clauses.h"
-#include "optimizer/predtest.h"
#include "optimizer/restrictinfo.h"
#include "optimizer/var.h"
nullable_relids);
}
-/*
- * make_restrictinfo_from_bitmapqual
- *
- * Given the bitmapqual Path structure for a bitmap indexscan, generate
- * RestrictInfo node(s) equivalent to the condition represented by the
- * indexclauses of the Path structure.
- *
- * The result is a List (effectively, implicit-AND representation) of
- * RestrictInfos.
- *
- * The caller must pass is_pushed_down, but we assume outerjoin_delayed
- * and pseudoconstant are false while outer_relids and nullable_relids
- * are NULL (no other kind of qual should ever get into a bitmapqual).
- *
- * If include_predicates is true, we add any partial index predicates to
- * the explicit index quals. When this is not true, we return a condition
- * that might be weaker than the actual scan represents.
- *
- * To do this through the normal make_restrictinfo() API, callers would have
- * to strip off the RestrictInfo nodes present in the indexclauses lists, and
- * then make_restrictinfo() would have to build new ones. It's better to have
- * a specialized routine to allow sharing of RestrictInfos.
- *
- * The qual manipulations here are much the same as in create_bitmap_subplan;
- * keep the two routines in sync!
- */
-List *
-make_restrictinfo_from_bitmapqual(Path *bitmapqual,
- bool is_pushed_down,
- bool include_predicates)
-{
- List *result;
- ListCell *l;
-
- if (IsA(bitmapqual, BitmapAndPath))
- {
- BitmapAndPath *apath = (BitmapAndPath *) bitmapqual;
-
- /*
- * There may well be redundant quals among the subplans, since a
- * top-level WHERE qual might have gotten used to form several
- * different index quals. We don't try exceedingly hard to eliminate
- * redundancies, but we do eliminate obvious duplicates by using
- * list_concat_unique.
- */
- result = NIL;
- foreach(l, apath->bitmapquals)
- {
- List *sublist;
-
- sublist = make_restrictinfo_from_bitmapqual((Path *) lfirst(l),
- is_pushed_down,
- include_predicates);
- result = list_concat_unique(result, sublist);
- }
- }
- else if (IsA(bitmapqual, BitmapOrPath))
- {
- BitmapOrPath *opath = (BitmapOrPath *) bitmapqual;
- List *withris = NIL;
- List *withoutris = NIL;
-
- /*
- * Here, we only detect qual-free subplans. A qual-free subplan would
- * cause us to generate "... OR true ..." which we may as well reduce
- * to just "true". We do not try to eliminate redundant subclauses
- * because (a) it's not as likely as in the AND case, and (b) we might
- * well be working with hundreds or even thousands of OR conditions,
- * perhaps from a long IN list. The performance of list_append_unique
- * would be unacceptable.
- */
- foreach(l, opath->bitmapquals)
- {
- List *sublist;
-
- sublist = make_restrictinfo_from_bitmapqual((Path *) lfirst(l),
- is_pushed_down,
- include_predicates);
- if (sublist == NIL)
- {
- /*
- * If we find a qual-less subscan, it represents a constant
- * TRUE, and hence the OR result is also constant TRUE, so we
- * can stop here.
- */
- return NIL;
- }
-
- /*
- * If the sublist contains multiple RestrictInfos, we create an
- * AND subclause. If there's just one, we have to check if it's
- * an OR clause, and if so flatten it to preserve AND/OR flatness
- * of our output.
- *
- * We construct lists with and without sub-RestrictInfos, so as
- * not to have to regenerate duplicate RestrictInfos below.
- */
- if (list_length(sublist) > 1)
- {
- withris = lappend(withris, make_andclause(sublist));
- sublist = get_actual_clauses(sublist);
- withoutris = lappend(withoutris, make_andclause(sublist));
- }
- else
- {
- RestrictInfo *subri = (RestrictInfo *) linitial(sublist);
-
- Assert(IsA(subri, RestrictInfo));
- if (restriction_is_or_clause(subri))
- {
- BoolExpr *subor = (BoolExpr *) subri->orclause;
-
- Assert(or_clause((Node *) subor));
- withris = list_concat(withris,
- list_copy(subor->args));
- subor = (BoolExpr *) subri->clause;
- Assert(or_clause((Node *) subor));
- withoutris = list_concat(withoutris,
- list_copy(subor->args));
- }
- else
- {
- withris = lappend(withris, subri);
- withoutris = lappend(withoutris, subri->clause);
- }
- }
- }
-
- /*
- * Avoid generating one-element ORs, which could happen due to
- * redundancy elimination or ScalarArrayOpExpr quals.
- */
- if (list_length(withris) <= 1)
- result = withris;
- else
- {
- /* Here's the magic part not available to outside callers */
- result =
- list_make1(make_restrictinfo_internal(make_orclause(withoutris),
- make_orclause(withris),
- is_pushed_down,
- false,
- false,
- NULL,
- NULL,
- NULL));
- }
- }
- else if (IsA(bitmapqual, IndexPath))
- {
- IndexPath *ipath = (IndexPath *) bitmapqual;
-
- result = list_copy(ipath->indexclauses);
- if (include_predicates && ipath->indexinfo->indpred != NIL)
- {
- foreach(l, ipath->indexinfo->indpred)
- {
- Expr *pred = (Expr *) lfirst(l);
-
- /*
- * We know that the index predicate must have been implied by
- * the query condition as a whole, but it may or may not be
- * implied by the conditions that got pushed into the
- * bitmapqual. Avoid generating redundant conditions.
- */
- if (!predicate_implied_by(list_make1(pred), result))
- result = lappend(result,
- make_restrictinfo(pred,
- is_pushed_down,
- false,
- false,
- NULL,
- NULL,
- NULL));
- }
- }
- }
- else
- {
- elog(ERROR, "unrecognized node type: %d", nodeTag(bitmapqual));
- result = NIL; /* keep compiler quiet */
- }
-
- return result;
-}
-
/*
* make_restrictinfos_from_actual_clauses
*
projects / postgresql.git / commitdiff