1996-07-09 08:22:35 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
1999-02-14 00:22:53 +01:00
|
|
|
* restrictinfo.c
|
1999-02-03 21:15:53 +01:00
|
|
|
* RestrictInfo node manipulation routines.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2006-03-05 16:59:11 +01:00
|
|
|
* Portions Copyright (c) 1996-2006, PostgreSQL Global Development Group
|
2000-01-26 06:58:53 +01:00
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
2006-04-07 19:05:39 +02:00
|
|
|
* $PostgreSQL: pgsql/src/backend/optimizer/util/restrictinfo.c,v 1.47 2006/04/07 17:05:39 tgl Exp $
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
#include "postgres.h"
|
|
|
|
|
|
|
|
#include "optimizer/clauses.h"
|
2004-02-27 22:48:04 +01:00
|
|
|
#include "optimizer/cost.h"
|
2002-11-24 22:52:15 +01:00
|
|
|
#include "optimizer/paths.h"
|
2005-07-28 22:26:22 +02:00
|
|
|
#include "optimizer/predtest.h"
|
1999-02-03 21:15:53 +01:00
|
|
|
#include "optimizer/restrictinfo.h"
|
2003-01-24 04:58:44 +01:00
|
|
|
#include "optimizer/var.h"
|
1996-07-09 08:22:35 +02:00
|
|
|
|
2002-11-24 22:52:15 +01:00
|
|
|
|
2004-01-06 00:39:54 +01:00
|
|
|
static RestrictInfo *make_restrictinfo_internal(Expr *clause,
|
2004-08-29 07:07:03 +02:00
|
|
|
Expr *orclause,
|
|
|
|
bool is_pushed_down,
|
2005-11-15 00:54:23 +01:00
|
|
|
bool outerjoin_delayed,
|
2005-06-09 06:19:00 +02:00
|
|
|
Relids required_relids);
|
2004-01-06 00:39:54 +01:00
|
|
|
static Expr *make_sub_restrictinfos(Expr *clause,
|
2005-11-15 00:54:23 +01:00
|
|
|
bool is_pushed_down,
|
2005-11-16 18:08:03 +01:00
|
|
|
bool outerjoin_delayed,
|
|
|
|
Relids required_relids);
|
2005-06-06 00:32:58 +02:00
|
|
|
static RestrictInfo *join_clause_is_redundant(PlannerInfo *root,
|
2003-08-04 02:43:34 +02:00
|
|
|
RestrictInfo *rinfo,
|
|
|
|
List *reference_list,
|
2005-04-22 23:58:32 +02:00
|
|
|
bool isouterjoin);
|
2003-06-16 00:51:45 +02:00
|
|
|
|
|
|
|
|
2004-01-04 01:07:32 +01:00
|
|
|
/*
|
|
|
|
* make_restrictinfo
|
|
|
|
*
|
|
|
|
* Build a RestrictInfo node containing the given subexpression.
|
|
|
|
*
|
2005-11-15 00:54:23 +01:00
|
|
|
* The is_pushed_down and outerjoin_delayed flags must be supplied by the
|
2005-11-22 19:17:34 +01:00
|
|
|
* caller. required_relids can be NULL, in which case it defaults to the
|
2005-06-09 06:19:00 +02:00
|
|
|
* actual clause contents (i.e., clause_relids).
|
2004-01-05 06:07:36 +01:00
|
|
|
*
|
|
|
|
* We initialize fields that depend only on the given subexpression, leaving
|
|
|
|
* others that depend on context (or may never be needed at all) to be filled
|
|
|
|
* later.
|
2004-01-04 01:07:32 +01:00
|
|
|
*/
|
|
|
|
RestrictInfo *
|
2005-11-15 00:54:23 +01:00
|
|
|
make_restrictinfo(Expr *clause,
|
|
|
|
bool is_pushed_down,
|
|
|
|
bool outerjoin_delayed,
|
|
|
|
Relids required_relids)
|
2004-01-06 00:39:54 +01:00
|
|
|
{
|
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* If it's an OR clause, build a modified copy with RestrictInfos inserted
|
|
|
|
* above each subclause of the top-level AND/OR structure.
|
2004-01-06 00:39:54 +01:00
|
|
|
*/
|
|
|
|
if (or_clause((Node *) clause))
|
2005-11-15 00:54:23 +01:00
|
|
|
return (RestrictInfo *) make_sub_restrictinfos(clause,
|
|
|
|
is_pushed_down,
|
2005-11-16 18:08:03 +01:00
|
|
|
outerjoin_delayed,
|
|
|
|
required_relids);
|
2004-01-06 00:39:54 +01:00
|
|
|
|
2005-04-22 23:58:32 +02:00
|
|
|
/* Shouldn't be an AND clause, else AND/OR flattening messed up */
|
|
|
|
Assert(!and_clause((Node *) clause));
|
2004-01-06 00:39:54 +01:00
|
|
|
|
2005-11-15 00:54:23 +01:00
|
|
|
return make_restrictinfo_internal(clause, NULL,
|
|
|
|
is_pushed_down, outerjoin_delayed,
|
2005-06-09 06:19:00 +02:00
|
|
|
required_relids);
|
2004-01-06 00:39:54 +01:00
|
|
|
}
|
|
|
|
|
2005-04-25 04:14:48 +02:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*
|
2005-07-28 22:26:22 +02:00
|
|
|
* The result is a List (effectively, implicit-AND representation) of
|
|
|
|
* RestrictInfos.
|
|
|
|
*
|
2005-11-15 00:54:23 +01:00
|
|
|
* The caller must pass is_pushed_down, but we assume outerjoin_delayed
|
|
|
|
* is false (no such qual should ever get into a bitmapqual).
|
|
|
|
*
|
2005-07-28 22:26:22 +02:00
|
|
|
* 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.
|
2005-04-25 04:14:48 +02:00
|
|
|
*
|
|
|
|
* 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.
|
2005-07-28 22:26:22 +02:00
|
|
|
*
|
|
|
|
* The qual manipulations here are much the same as in create_bitmap_subplan;
|
|
|
|
* keep the two routines in sync!
|
2005-04-25 04:14:48 +02:00
|
|
|
*/
|
|
|
|
List *
|
2005-07-28 22:26:22 +02:00
|
|
|
make_restrictinfo_from_bitmapqual(Path *bitmapqual,
|
|
|
|
bool is_pushed_down,
|
|
|
|
bool include_predicates)
|
2005-04-25 04:14:48 +02:00
|
|
|
{
|
|
|
|
List *result;
|
2005-07-28 22:26:22 +02:00
|
|
|
ListCell *l;
|
2005-04-25 04:14:48 +02:00
|
|
|
|
|
|
|
if (IsA(bitmapqual, BitmapAndPath))
|
|
|
|
{
|
|
|
|
BitmapAndPath *apath = (BitmapAndPath *) bitmapqual;
|
|
|
|
|
2005-07-28 22:26:22 +02:00
|
|
|
/*
|
|
|
|
* There may well be redundant quals among the subplans, since a
|
|
|
|
* top-level WHERE qual might have gotten used to form several
|
2005-10-15 04:49:52 +02:00
|
|
|
* different index quals. We don't try exceedingly hard to eliminate
|
|
|
|
* redundancies, but we do eliminate obvious duplicates by using
|
|
|
|
* list_concat_unique.
|
2005-07-28 22:26:22 +02:00
|
|
|
*/
|
2005-04-25 04:14:48 +02:00
|
|
|
result = NIL;
|
|
|
|
foreach(l, apath->bitmapquals)
|
|
|
|
{
|
|
|
|
List *sublist;
|
|
|
|
|
|
|
|
sublist = make_restrictinfo_from_bitmapqual((Path *) lfirst(l),
|
2005-07-28 22:26:22 +02:00
|
|
|
is_pushed_down,
|
|
|
|
include_predicates);
|
|
|
|
result = list_concat_unique(result, sublist);
|
2005-04-25 04:14:48 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (IsA(bitmapqual, BitmapOrPath))
|
|
|
|
{
|
|
|
|
BitmapOrPath *opath = (BitmapOrPath *) bitmapqual;
|
|
|
|
List *withris = NIL;
|
|
|
|
List *withoutris = NIL;
|
|
|
|
|
2005-07-28 22:26:22 +02:00
|
|
|
/*
|
2005-10-13 02:06:46 +02:00
|
|
|
* Here, we only detect qual-free subplans. A qual-free subplan would
|
|
|
|
* cause us to generate "... OR true ..." which we may as well reduce
|
2005-10-15 04:49:52 +02:00
|
|
|
* to just "true". We do not try to eliminate redundant subclauses
|
2005-10-13 02:06:46 +02:00
|
|
|
* 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.
|
2005-07-28 22:26:22 +02:00
|
|
|
*/
|
2005-04-25 04:14:48 +02:00
|
|
|
foreach(l, opath->bitmapquals)
|
|
|
|
{
|
|
|
|
List *sublist;
|
|
|
|
|
|
|
|
sublist = make_restrictinfo_from_bitmapqual((Path *) lfirst(l),
|
2005-07-28 22:26:22 +02:00
|
|
|
is_pushed_down,
|
|
|
|
include_predicates);
|
2005-04-25 04:14:48 +02:00
|
|
|
if (sublist == NIL)
|
|
|
|
{
|
2005-07-28 22:26:22 +02:00
|
|
|
/*
|
|
|
|
* If we find a qual-less subscan, it represents a constant
|
2005-10-15 04:49:52 +02:00
|
|
|
* TRUE, and hence the OR result is also constant TRUE, so we
|
|
|
|
* can stop here.
|
2005-07-28 22:26:22 +02:00
|
|
|
*/
|
2005-04-25 04:14:48 +02:00
|
|
|
return NIL;
|
|
|
|
}
|
2006-04-07 19:05:39 +02:00
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
}
|
|
|
|
}
|
2005-07-28 22:26:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* Avoid generating one-element ORs, which could happen due to
|
2005-11-25 20:47:50 +01:00
|
|
|
* redundancy elimination or ScalarArrayOpExpr quals.
|
2005-07-28 22:26:22 +02:00
|
|
|
*/
|
|
|
|
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,
|
2005-11-15 00:54:23 +01:00
|
|
|
false,
|
2005-07-28 22:26:22 +02:00
|
|
|
NULL));
|
2005-04-25 04:14:48 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (IsA(bitmapqual, IndexPath))
|
|
|
|
{
|
2005-10-15 04:49:52 +02:00
|
|
|
IndexPath *ipath = (IndexPath *) bitmapqual;
|
2005-04-25 04:14:48 +02:00
|
|
|
|
|
|
|
result = list_copy(ipath->indexclauses);
|
2005-07-28 22:26:22 +02:00
|
|
|
if (include_predicates && ipath->indexinfo->indpred != NIL)
|
|
|
|
{
|
|
|
|
foreach(l, ipath->indexinfo->indpred)
|
|
|
|
{
|
2005-10-15 04:49:52 +02:00
|
|
|
Expr *pred = (Expr *) lfirst(l);
|
2005-07-28 22:26:22 +02:00
|
|
|
|
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* 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.
|
2005-07-28 22:26:22 +02:00
|
|
|
*/
|
|
|
|
if (!predicate_implied_by(list_make1(pred), result))
|
|
|
|
result = lappend(result,
|
|
|
|
make_restrictinfo(pred,
|
|
|
|
is_pushed_down,
|
2005-11-15 00:54:23 +01:00
|
|
|
false,
|
2005-07-28 22:26:22 +02:00
|
|
|
NULL));
|
|
|
|
}
|
|
|
|
}
|
2005-04-25 04:14:48 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
elog(ERROR, "unrecognized node type: %d", nodeTag(bitmapqual));
|
|
|
|
result = NIL; /* keep compiler quiet */
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2004-01-06 00:39:54 +01:00
|
|
|
/*
|
|
|
|
* make_restrictinfo_internal
|
|
|
|
*
|
2005-04-25 04:14:48 +02:00
|
|
|
* Common code for the main entry points and the recursive cases.
|
2004-01-06 00:39:54 +01:00
|
|
|
*/
|
|
|
|
static RestrictInfo *
|
|
|
|
make_restrictinfo_internal(Expr *clause, Expr *orclause,
|
2005-11-15 00:54:23 +01:00
|
|
|
bool is_pushed_down, bool outerjoin_delayed,
|
|
|
|
Relids required_relids)
|
2004-01-04 01:07:32 +01:00
|
|
|
{
|
|
|
|
RestrictInfo *restrictinfo = makeNode(RestrictInfo);
|
|
|
|
|
|
|
|
restrictinfo->clause = clause;
|
2004-01-06 00:39:54 +01:00
|
|
|
restrictinfo->orclause = orclause;
|
2004-01-05 06:07:36 +01:00
|
|
|
restrictinfo->is_pushed_down = is_pushed_down;
|
2005-11-15 00:54:23 +01:00
|
|
|
restrictinfo->outerjoin_delayed = outerjoin_delayed;
|
2004-01-05 06:07:36 +01:00
|
|
|
restrictinfo->can_join = false; /* may get set below */
|
2004-01-04 01:07:32 +01:00
|
|
|
|
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* If it's a binary opclause, set up left/right relids info. In any case
|
|
|
|
* set up the total clause relids info.
|
2004-01-04 01:07:32 +01:00
|
|
|
*/
|
2004-05-31 01:40:41 +02:00
|
|
|
if (is_opclause(clause) && list_length(((OpExpr *) clause)->args) == 2)
|
2004-01-04 01:07:32 +01:00
|
|
|
{
|
|
|
|
restrictinfo->left_relids = pull_varnos(get_leftop(clause));
|
|
|
|
restrictinfo->right_relids = pull_varnos(get_rightop(clause));
|
|
|
|
|
2004-01-04 04:51:52 +01:00
|
|
|
restrictinfo->clause_relids = bms_union(restrictinfo->left_relids,
|
2005-10-15 04:49:52 +02:00
|
|
|
restrictinfo->right_relids);
|
2004-01-04 04:51:52 +01:00
|
|
|
|
2004-01-04 01:07:32 +01:00
|
|
|
/*
|
|
|
|
* Does it look like a normal join clause, i.e., a binary operator
|
2005-10-15 04:49:52 +02:00
|
|
|
* relating expressions that come from distinct relations? If so we
|
|
|
|
* might be able to use it in a join algorithm. Note that this is a
|
|
|
|
* purely syntactic test that is made regardless of context.
|
2004-01-04 01:07:32 +01:00
|
|
|
*/
|
|
|
|
if (!bms_is_empty(restrictinfo->left_relids) &&
|
|
|
|
!bms_is_empty(restrictinfo->right_relids) &&
|
|
|
|
!bms_overlap(restrictinfo->left_relids,
|
|
|
|
restrictinfo->right_relids))
|
2004-01-05 06:07:36 +01:00
|
|
|
restrictinfo->can_join = true;
|
2004-01-04 01:07:32 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2004-01-04 04:51:52 +01:00
|
|
|
/* Not a binary opclause, so mark left/right relid sets as empty */
|
2004-01-04 01:07:32 +01:00
|
|
|
restrictinfo->left_relids = NULL;
|
|
|
|
restrictinfo->right_relids = NULL;
|
2004-01-04 04:51:52 +01:00
|
|
|
/* and get the total relid set the hard way */
|
|
|
|
restrictinfo->clause_relids = pull_varnos((Node *) clause);
|
2004-01-04 01:07:32 +01:00
|
|
|
}
|
|
|
|
|
2005-06-09 06:19:00 +02:00
|
|
|
/* required_relids defaults to clause_relids */
|
|
|
|
if (required_relids != NULL)
|
|
|
|
restrictinfo->required_relids = required_relids;
|
|
|
|
else
|
|
|
|
restrictinfo->required_relids = restrictinfo->clause_relids;
|
|
|
|
|
2004-01-04 01:07:32 +01:00
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* Fill in all the cacheable fields with "not yet set" markers. None of
|
|
|
|
* these will be computed until/unless needed. Note in particular that we
|
|
|
|
* don't mark a binary opclause as mergejoinable or hashjoinable here;
|
|
|
|
* that happens only if it appears in the right context (top level of a
|
|
|
|
* joinclause list).
|
2004-01-04 01:07:32 +01:00
|
|
|
*/
|
|
|
|
restrictinfo->eval_cost.startup = -1;
|
|
|
|
restrictinfo->this_selec = -1;
|
|
|
|
|
|
|
|
restrictinfo->mergejoinoperator = InvalidOid;
|
|
|
|
restrictinfo->left_sortop = InvalidOid;
|
|
|
|
restrictinfo->right_sortop = InvalidOid;
|
|
|
|
|
|
|
|
restrictinfo->left_pathkey = NIL;
|
|
|
|
restrictinfo->right_pathkey = NIL;
|
|
|
|
|
|
|
|
restrictinfo->left_mergescansel = -1;
|
|
|
|
restrictinfo->right_mergescansel = -1;
|
|
|
|
|
|
|
|
restrictinfo->hashjoinoperator = InvalidOid;
|
|
|
|
|
|
|
|
restrictinfo->left_bucketsize = -1;
|
|
|
|
restrictinfo->right_bucketsize = -1;
|
|
|
|
|
|
|
|
return restrictinfo;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Recursively insert sub-RestrictInfo nodes into a boolean expression.
|
2005-04-22 23:58:32 +02:00
|
|
|
*
|
|
|
|
* We put RestrictInfos above simple (non-AND/OR) clauses and above
|
|
|
|
* sub-OR clauses, but not above sub-AND clauses, because there's no need.
|
|
|
|
* This may seem odd but it is closely related to the fact that we use
|
|
|
|
* implicit-AND lists at top level of RestrictInfo lists. Only ORs and
|
|
|
|
* simple clauses are valid RestrictInfos.
|
2005-11-16 18:08:03 +01:00
|
|
|
*
|
|
|
|
* The given required_relids are attached to our top-level output,
|
|
|
|
* but any OR-clause constituents are allowed to default to just the
|
|
|
|
* contained rels.
|
2004-01-04 01:07:32 +01:00
|
|
|
*/
|
|
|
|
static Expr *
|
2005-11-15 00:54:23 +01:00
|
|
|
make_sub_restrictinfos(Expr *clause,
|
2005-11-16 18:08:03 +01:00
|
|
|
bool is_pushed_down, bool outerjoin_delayed,
|
|
|
|
Relids required_relids)
|
2004-01-04 01:07:32 +01:00
|
|
|
{
|
|
|
|
if (or_clause((Node *) clause))
|
|
|
|
{
|
|
|
|
List *orlist = NIL;
|
2004-05-26 06:41:50 +02:00
|
|
|
ListCell *temp;
|
2004-01-04 01:07:32 +01:00
|
|
|
|
|
|
|
foreach(temp, ((BoolExpr *) clause)->args)
|
|
|
|
orlist = lappend(orlist,
|
|
|
|
make_sub_restrictinfos(lfirst(temp),
|
2005-11-15 00:54:23 +01:00
|
|
|
is_pushed_down,
|
2005-11-16 18:08:03 +01:00
|
|
|
outerjoin_delayed,
|
|
|
|
NULL));
|
2005-04-22 23:58:32 +02:00
|
|
|
return (Expr *) make_restrictinfo_internal(clause,
|
|
|
|
make_orclause(orlist),
|
|
|
|
is_pushed_down,
|
2005-11-15 00:54:23 +01:00
|
|
|
outerjoin_delayed,
|
2005-11-16 18:08:03 +01:00
|
|
|
required_relids);
|
2004-01-04 01:07:32 +01:00
|
|
|
}
|
|
|
|
else if (and_clause((Node *) clause))
|
|
|
|
{
|
|
|
|
List *andlist = NIL;
|
2004-05-26 06:41:50 +02:00
|
|
|
ListCell *temp;
|
2004-01-04 01:07:32 +01:00
|
|
|
|
|
|
|
foreach(temp, ((BoolExpr *) clause)->args)
|
|
|
|
andlist = lappend(andlist,
|
|
|
|
make_sub_restrictinfos(lfirst(temp),
|
2005-11-15 00:54:23 +01:00
|
|
|
is_pushed_down,
|
2005-11-16 18:08:03 +01:00
|
|
|
outerjoin_delayed,
|
|
|
|
required_relids));
|
2004-01-04 01:07:32 +01:00
|
|
|
return make_andclause(andlist);
|
|
|
|
}
|
|
|
|
else
|
2004-01-06 00:39:54 +01:00
|
|
|
return (Expr *) make_restrictinfo_internal(clause,
|
|
|
|
NULL,
|
|
|
|
is_pushed_down,
|
2005-11-15 00:54:23 +01:00
|
|
|
outerjoin_delayed,
|
2005-11-16 18:08:03 +01:00
|
|
|
required_relids);
|
2004-01-04 01:07:32 +01:00
|
|
|
}
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
/*
|
1999-07-25 01:21:14 +02:00
|
|
|
* restriction_is_or_clause
|
1997-09-07 07:04:48 +02:00
|
|
|
*
|
1999-07-25 01:21:14 +02:00
|
|
|
* Returns t iff the restrictinfo node contains an 'or' clause.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
bool
|
1999-07-25 01:21:14 +02:00
|
|
|
restriction_is_or_clause(RestrictInfo *restrictinfo)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2004-01-04 01:07:32 +01:00
|
|
|
if (restrictinfo->orclause != NULL)
|
1998-09-01 05:29:17 +02:00
|
|
|
return true;
|
1997-09-07 07:04:48 +02:00
|
|
|
else
|
1998-09-01 05:29:17 +02:00
|
|
|
return false;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
/*
|
1999-02-14 00:22:53 +01:00
|
|
|
* get_actual_clauses
|
1997-09-07 07:04:48 +02:00
|
|
|
*
|
2002-11-24 22:52:15 +01:00
|
|
|
* Returns a list containing the bare clauses from 'restrictinfo_list'.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1998-02-26 05:46:47 +01:00
|
|
|
List *
|
1999-02-03 21:15:53 +01:00
|
|
|
get_actual_clauses(List *restrictinfo_list)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
List *result = NIL;
|
2004-05-26 06:41:50 +02:00
|
|
|
ListCell *temp;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1999-02-03 21:15:53 +01:00
|
|
|
foreach(temp, restrictinfo_list)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
2004-01-06 00:39:54 +01:00
|
|
|
RestrictInfo *rinfo = (RestrictInfo *) lfirst(temp);
|
|
|
|
|
|
|
|
Assert(IsA(rinfo, RestrictInfo));
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2004-01-06 00:39:54 +01:00
|
|
|
result = lappend(result, rinfo->clause);
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
2000-09-12 23:07:18 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* get_actual_join_clauses
|
|
|
|
*
|
|
|
|
* Extract clauses from 'restrictinfo_list', separating those that
|
2000-09-29 20:21:41 +02:00
|
|
|
* syntactically match the join level from those that were pushed down.
|
2000-09-12 23:07:18 +02:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
get_actual_join_clauses(List *restrictinfo_list,
|
|
|
|
List **joinquals, List **otherquals)
|
|
|
|
{
|
2004-05-26 06:41:50 +02:00
|
|
|
ListCell *temp;
|
2000-09-12 23:07:18 +02:00
|
|
|
|
|
|
|
*joinquals = NIL;
|
|
|
|
*otherquals = NIL;
|
|
|
|
|
|
|
|
foreach(temp, restrictinfo_list)
|
|
|
|
{
|
|
|
|
RestrictInfo *clause = (RestrictInfo *) lfirst(temp);
|
|
|
|
|
2004-01-05 06:07:36 +01:00
|
|
|
if (clause->is_pushed_down)
|
2000-09-12 23:07:18 +02:00
|
|
|
*otherquals = lappend(*otherquals, clause->clause);
|
2000-09-29 20:21:41 +02:00
|
|
|
else
|
|
|
|
*joinquals = lappend(*joinquals, clause->clause);
|
2000-09-12 23:07:18 +02:00
|
|
|
}
|
|
|
|
}
|
2002-11-24 22:52:15 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* remove_redundant_join_clauses
|
|
|
|
*
|
|
|
|
* Given a list of RestrictInfo clauses that are to be applied in a join,
|
|
|
|
* remove any duplicate or redundant clauses.
|
|
|
|
*
|
|
|
|
* We must eliminate duplicates when forming the restrictlist for a joinrel,
|
|
|
|
* since we will see many of the same clauses arriving from both input
|
|
|
|
* relations. Also, if a clause is a mergejoinable clause, it's possible that
|
|
|
|
* it is redundant with previous clauses (see optimizer/README for
|
|
|
|
* discussion). We detect that case and omit the redundant clause from the
|
|
|
|
* result list.
|
|
|
|
*
|
2003-06-16 00:51:45 +02:00
|
|
|
* The result is a fresh List, but it points to the same member nodes
|
|
|
|
* as were in the input.
|
|
|
|
*/
|
|
|
|
List *
|
2005-06-06 00:32:58 +02:00
|
|
|
remove_redundant_join_clauses(PlannerInfo *root, List *restrictinfo_list,
|
2005-04-22 23:58:32 +02:00
|
|
|
bool isouterjoin)
|
2003-06-16 00:51:45 +02:00
|
|
|
{
|
|
|
|
List *result = NIL;
|
2004-05-26 06:41:50 +02:00
|
|
|
ListCell *item;
|
2004-02-27 22:48:04 +01:00
|
|
|
QualCost cost;
|
|
|
|
|
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* If there are any redundant clauses, we want to eliminate the ones that
|
|
|
|
* are more expensive in favor of the ones that are less so. Run
|
2004-08-29 07:07:03 +02:00
|
|
|
* cost_qual_eval() to ensure the eval_cost fields are set up.
|
2004-02-27 22:48:04 +01:00
|
|
|
*/
|
|
|
|
cost_qual_eval(&cost, restrictinfo_list);
|
|
|
|
|
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* We don't have enough knowledge yet to be able to estimate the number of
|
|
|
|
* times a clause might be evaluated, so it's hard to weight the startup
|
|
|
|
* and per-tuple costs appropriately. For now just weight 'em the same.
|
2004-02-27 22:48:04 +01:00
|
|
|
*/
|
|
|
|
#define CLAUSECOST(r) ((r)->eval_cost.startup + (r)->eval_cost.per_tuple)
|
2003-06-16 00:51:45 +02:00
|
|
|
|
|
|
|
foreach(item, restrictinfo_list)
|
|
|
|
{
|
|
|
|
RestrictInfo *rinfo = (RestrictInfo *) lfirst(item);
|
2004-02-27 22:48:04 +01:00
|
|
|
RestrictInfo *prevrinfo;
|
2003-06-16 00:51:45 +02:00
|
|
|
|
2004-02-27 22:48:04 +01:00
|
|
|
/* is it redundant with any prior clause? */
|
2005-04-22 23:58:32 +02:00
|
|
|
prevrinfo = join_clause_is_redundant(root, rinfo, result, isouterjoin);
|
2004-02-27 22:48:04 +01:00
|
|
|
if (prevrinfo == NULL)
|
|
|
|
{
|
|
|
|
/* no, so add it to result list */
|
|
|
|
result = lappend(result, rinfo);
|
|
|
|
}
|
|
|
|
else if (CLAUSECOST(rinfo) < CLAUSECOST(prevrinfo))
|
|
|
|
{
|
|
|
|
/* keep this one, drop the previous one */
|
2004-05-31 01:40:41 +02:00
|
|
|
result = list_delete_ptr(result, prevrinfo);
|
2004-02-27 22:48:04 +01:00
|
|
|
result = lappend(result, rinfo);
|
|
|
|
}
|
|
|
|
/* else, drop this one */
|
2003-06-16 00:51:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* select_nonredundant_join_clauses
|
|
|
|
*
|
|
|
|
* Given a list of RestrictInfo clauses that are to be applied in a join,
|
|
|
|
* select the ones that are not redundant with any clause in the
|
|
|
|
* reference_list.
|
|
|
|
*
|
|
|
|
* This is similar to remove_redundant_join_clauses, but we are looking for
|
|
|
|
* redundancies with a separate list of clauses (i.e., clauses that have
|
|
|
|
* already been applied below the join itself).
|
|
|
|
*
|
|
|
|
* Note that we assume the given restrictinfo_list has already been checked
|
|
|
|
* for local redundancies, so we don't check again.
|
|
|
|
*/
|
|
|
|
List *
|
2005-06-06 00:32:58 +02:00
|
|
|
select_nonredundant_join_clauses(PlannerInfo *root,
|
2003-06-16 00:51:45 +02:00
|
|
|
List *restrictinfo_list,
|
|
|
|
List *reference_list,
|
2005-04-22 23:58:32 +02:00
|
|
|
bool isouterjoin)
|
2003-06-16 00:51:45 +02:00
|
|
|
{
|
|
|
|
List *result = NIL;
|
2004-05-26 06:41:50 +02:00
|
|
|
ListCell *item;
|
2003-06-16 00:51:45 +02:00
|
|
|
|
|
|
|
foreach(item, restrictinfo_list)
|
|
|
|
{
|
|
|
|
RestrictInfo *rinfo = (RestrictInfo *) lfirst(item);
|
|
|
|
|
|
|
|
/* drop it if redundant with any reference clause */
|
2005-04-22 23:58:32 +02:00
|
|
|
if (join_clause_is_redundant(root, rinfo, reference_list, isouterjoin) != NULL)
|
2003-06-16 00:51:45 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/* otherwise, add it to result list */
|
|
|
|
result = lappend(result, rinfo);
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* join_clause_is_redundant
|
2004-02-27 22:48:04 +01:00
|
|
|
* If rinfo is redundant with any clause in reference_list,
|
|
|
|
* return one such clause; otherwise return NULL.
|
2003-06-16 00:51:45 +02:00
|
|
|
*
|
|
|
|
* This is the guts of both remove_redundant_join_clauses and
|
|
|
|
* select_nonredundant_join_clauses. See the docs above for motivation.
|
|
|
|
*
|
2002-11-24 22:52:15 +01:00
|
|
|
* We can detect redundant mergejoinable clauses very cheaply by using their
|
|
|
|
* left and right pathkeys, which uniquely identify the sets of equijoined
|
|
|
|
* variables in question. All the members of a pathkey set that are in the
|
|
|
|
* left relation have already been forced to be equal; likewise for those in
|
2003-08-04 02:43:34 +02:00
|
|
|
* the right relation. So, we need to have only one clause that checks
|
2002-11-24 22:52:15 +01:00
|
|
|
* equality between any set member on the left and any member on the right;
|
|
|
|
* by transitivity, all the rest are then equal.
|
|
|
|
*
|
2003-01-24 04:58:44 +01:00
|
|
|
* However, clauses that are of the form "var expr = const expr" cannot be
|
|
|
|
* eliminated as redundant. This is because when there are const expressions
|
|
|
|
* in a pathkey set, generate_implied_equalities() suppresses "var = var"
|
|
|
|
* clauses in favor of "var = const" clauses. We cannot afford to drop any
|
|
|
|
* of the latter, even though they might seem redundant by the pathkey
|
|
|
|
* membership test.
|
|
|
|
*
|
2002-11-24 22:52:15 +01:00
|
|
|
* Weird special case: if we have two clauses that seem redundant
|
|
|
|
* except one is pushed down into an outer join and the other isn't,
|
|
|
|
* then they're not really redundant, because one constrains the
|
|
|
|
* joined rows after addition of null fill rows, and the other doesn't.
|
|
|
|
*/
|
2004-02-27 22:48:04 +01:00
|
|
|
static RestrictInfo *
|
2005-06-06 00:32:58 +02:00
|
|
|
join_clause_is_redundant(PlannerInfo *root,
|
2003-06-16 00:51:45 +02:00
|
|
|
RestrictInfo *rinfo,
|
|
|
|
List *reference_list,
|
2005-04-22 23:58:32 +02:00
|
|
|
bool isouterjoin)
|
2002-11-24 22:52:15 +01:00
|
|
|
{
|
2004-05-26 06:41:50 +02:00
|
|
|
ListCell *refitem;
|
2004-02-27 22:48:04 +01:00
|
|
|
|
2003-06-16 00:51:45 +02:00
|
|
|
/* always consider exact duplicates redundant */
|
2004-02-27 22:48:04 +01:00
|
|
|
foreach(refitem, reference_list)
|
|
|
|
{
|
|
|
|
RestrictInfo *refrinfo = (RestrictInfo *) lfirst(refitem);
|
|
|
|
|
|
|
|
if (equal(rinfo, refrinfo))
|
|
|
|
return refrinfo;
|
|
|
|
}
|
2002-11-24 22:52:15 +01:00
|
|
|
|
2003-06-16 00:51:45 +02:00
|
|
|
/* check for redundant merge clauses */
|
|
|
|
if (rinfo->mergejoinoperator != InvalidOid)
|
2002-11-24 22:52:15 +01:00
|
|
|
{
|
2004-01-04 04:51:52 +01:00
|
|
|
/* do the cheap test first: is it a "var = const" clause? */
|
|
|
|
if (bms_is_empty(rinfo->left_relids) ||
|
|
|
|
bms_is_empty(rinfo->right_relids))
|
2004-02-27 22:48:04 +01:00
|
|
|
return NULL; /* var = const, so not redundant */
|
2004-01-04 04:51:52 +01:00
|
|
|
|
2003-06-16 00:51:45 +02:00
|
|
|
cache_mergeclause_pathkeys(root, rinfo);
|
2002-11-24 22:52:15 +01:00
|
|
|
|
2003-06-16 00:51:45 +02:00
|
|
|
foreach(refitem, reference_list)
|
2002-11-24 22:52:15 +01:00
|
|
|
{
|
2003-06-16 00:51:45 +02:00
|
|
|
RestrictInfo *refrinfo = (RestrictInfo *) lfirst(refitem);
|
2002-11-24 22:52:15 +01:00
|
|
|
|
2004-02-27 22:48:04 +01:00
|
|
|
if (refrinfo->mergejoinoperator != InvalidOid)
|
2002-11-24 22:52:15 +01:00
|
|
|
{
|
2004-02-27 22:48:04 +01:00
|
|
|
cache_mergeclause_pathkeys(root, refrinfo);
|
|
|
|
|
|
|
|
if (rinfo->left_pathkey == refrinfo->left_pathkey &&
|
|
|
|
rinfo->right_pathkey == refrinfo->right_pathkey &&
|
|
|
|
(rinfo->is_pushed_down == refrinfo->is_pushed_down ||
|
2005-04-22 23:58:32 +02:00
|
|
|
!isouterjoin))
|
2004-02-27 22:48:04 +01:00
|
|
|
{
|
|
|
|
/* Yup, it's redundant */
|
|
|
|
return refrinfo;
|
|
|
|
}
|
2003-01-24 04:58:44 +01:00
|
|
|
}
|
2002-11-24 22:52:15 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-06-16 00:51:45 +02:00
|
|
|
/* otherwise, not redundant */
|
2004-02-27 22:48:04 +01:00
|
|
|
return NULL;
|
2002-11-24 22:52:15 +01:00
|
|
|
}
|