mirror of https://github.com/postgres/postgres
in its own right. As proposed by Simon Riggs, but with some editorializing of my own.REL8_1_STABLE
Tom Lane
21 years ago
parent
111e29ef5e
commit
2f1210629c
@ -0,0 +1,671 @@ |
|||||||
|
/*-------------------------------------------------------------------------
|
||||||
|
* |
||||||
|
* predtest.c |
||||||
|
* Routines to attempt to prove logical implications between predicate |
||||||
|
* expressions. |
||||||
|
* |
||||||
|
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group |
||||||
|
* Portions Copyright (c) 1994, Regents of the University of California |
||||||
|
* |
||||||
|
* |
||||||
|
* IDENTIFICATION |
||||||
|
* $PostgreSQL: pgsql/src/backend/optimizer/util/predtest.c,v 1.1 2005/06/10 22:25:36 tgl Exp $ |
||||||
|
* |
||||||
|
*------------------------------------------------------------------------- |
||||||
|
*/ |
||||||
|
#include "postgres.h" |
||||||
|
|
||||||
|
#include "catalog/pg_amop.h" |
||||||
|
#include "catalog/pg_proc.h" |
||||||
|
#include "catalog/pg_type.h" |
||||||
|
#include "executor/executor.h" |
||||||
|
#include "optimizer/clauses.h" |
||||||
|
#include "optimizer/predtest.h" |
||||||
|
#include "utils/catcache.h" |
||||||
|
#include "utils/lsyscache.h" |
||||||
|
#include "utils/syscache.h" |
||||||
|
|
||||||
|
|
||||||
|
static bool predicate_implied_by_recurse(Node *clause, Node *predicate); |
||||||
|
static bool predicate_implied_by_simple_clause(Expr *predicate, Node *clause); |
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
* predicate_implied_by |
||||||
|
* Recursively checks whether the clauses in restrictinfo_list imply |
||||||
|
* that the given predicate is true. |
||||||
|
* |
||||||
|
* The top-level List structure of each list corresponds to an AND list. |
||||||
|
* We assume that eval_const_expressions() has been applied and so there |
||||||
|
* are no un-flattened ANDs or ORs (e.g., no AND immediately within an AND, |
||||||
|
* including AND just below the top-level List structure). |
||||||
|
* If this is not true we might fail to prove an implication that is |
||||||
|
* valid, but no worse consequences will ensue. |
||||||
|
*/ |
||||||
|
bool |
||||||
|
predicate_implied_by(List *predicate_list, List *restrictinfo_list) |
||||||
|
{ |
||||||
|
ListCell *item; |
||||||
|
|
||||||
|
if (predicate_list == NIL) |
||||||
|
return true; /* no predicate: implication is vacuous */ |
||||||
|
if (restrictinfo_list == NIL) |
||||||
|
return false; /* no restriction: implication must fail */ |
||||||
|
|
||||||
|
/*
|
||||||
|
* In all cases where the predicate is an AND-clause, |
||||||
|
* predicate_implied_by_recurse() will prefer to iterate over the |
||||||
|
* predicate's components. So we can just do that to start with here, |
||||||
|
* and eliminate the need for predicate_implied_by_recurse() to handle |
||||||
|
* a bare List on the predicate side. |
||||||
|
* |
||||||
|
* Logic is: restriction must imply each of the AND'ed predicate items. |
||||||
|
*/ |
||||||
|
foreach(item, predicate_list) |
||||||
|
{ |
||||||
|
if (!predicate_implied_by_recurse((Node *) restrictinfo_list, |
||||||
|
lfirst(item))) |
||||||
|
return false; |
||||||
|
} |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
/*----------
|
||||||
|
* predicate_implied_by_recurse |
||||||
|
* Does the predicate implication test for non-NULL restriction and |
||||||
|
* predicate clauses. |
||||||
|
* |
||||||
|
* The logic followed here is ("=>" means "implies"): |
||||||
|
* atom A => atom B iff: predicate_implied_by_simple_clause says so |
||||||
|
* atom A => AND-expr B iff: A => each of B's components |
||||||
|
* atom A => OR-expr B iff: A => any of B's components |
||||||
|
* AND-expr A => atom B iff: any of A's components => B |
||||||
|
* AND-expr A => AND-expr B iff: A => each of B's components |
||||||
|
* AND-expr A => OR-expr B iff: A => any of B's components, |
||||||
|
* *or* any of A's components => B |
||||||
|
* OR-expr A => atom B iff: each of A's components => B |
||||||
|
* OR-expr A => AND-expr B iff: A => each of B's components |
||||||
|
* OR-expr A => OR-expr B iff: each of A's components => any of B's |
||||||
|
* |
||||||
|
* An "atom" is anything other than an AND or OR node. Notice that we don't |
||||||
|
* have any special logic to handle NOT nodes; these should have been pushed |
||||||
|
* down or eliminated where feasible by prepqual.c. |
||||||
|
* |
||||||
|
* We can't recursively expand either side first, but have to interleave |
||||||
|
* the expansions per the above rules, to be sure we handle all of these |
||||||
|
* examples: |
||||||
|
* (x OR y) => (x OR y OR z) |
||||||
|
* (x AND y AND z) => (x AND y) |
||||||
|
* (x AND y) => ((x AND y) OR z) |
||||||
|
* ((x OR y) AND z) => (x OR y) |
||||||
|
* This is still not an exhaustive test, but it handles most normal cases |
||||||
|
* under the assumption that both inputs have been AND/OR flattened. |
||||||
|
* |
||||||
|
* A bare List node on the restriction side is interpreted as an AND clause, |
||||||
|
* in order to handle the top-level restriction List properly. However we |
||||||
|
* need not consider a List on the predicate side since predicate_implied_by() |
||||||
|
* already expanded it. |
||||||
|
* |
||||||
|
* We have to be prepared to handle RestrictInfo nodes in the restrictinfo |
||||||
|
* tree, though not in the predicate tree. |
||||||
|
*---------- |
||||||
|
*/ |
||||||
|
static bool |
||||||
|
predicate_implied_by_recurse(Node *clause, Node *predicate) |
||||||
|
{ |
||||||
|
ListCell *item; |
||||||
|
|
||||||
|
Assert(clause != NULL); |
||||||
|
/* skip through RestrictInfo */ |
||||||
|
if (IsA(clause, RestrictInfo)) |
||||||
|
{ |
||||||
|
clause = (Node *) ((RestrictInfo *) clause)->clause; |
||||||
|
Assert(clause != NULL); |
||||||
|
Assert(!IsA(clause, RestrictInfo)); |
||||||
|
} |
||||||
|
Assert(predicate != NULL); |
||||||
|
|
||||||
|
/*
|
||||||
|
* Since a restriction List clause is handled the same as an AND clause, |
||||||
|
* we can avoid duplicate code like this: |
||||||
|
*/ |
||||||
|
if (and_clause(clause)) |
||||||
|
clause = (Node *) ((BoolExpr *) clause)->args; |
||||||
|
|
||||||
|
if (IsA(clause, List)) |
||||||
|
{ |
||||||
|
if (and_clause(predicate)) |
||||||
|
{ |
||||||
|
/* AND-clause => AND-clause if A implies each of B's items */ |
||||||
|
foreach(item, ((BoolExpr *) predicate)->args) |
||||||
|
{ |
||||||
|
if (!predicate_implied_by_recurse(clause, lfirst(item))) |
||||||
|
return false; |
||||||
|
} |
||||||
|
return true; |
||||||
|
} |
||||||
|
else if (or_clause(predicate)) |
||||||
|
{ |
||||||
|
/* AND-clause => OR-clause if A implies any of B's items */ |
||||||
|
/* Needed to handle (x AND y) => ((x AND y) OR z) */ |
||||||
|
foreach(item, ((BoolExpr *) predicate)->args) |
||||||
|
{ |
||||||
|
if (predicate_implied_by_recurse(clause, lfirst(item))) |
||||||
|
return true; |
||||||
|
} |
||||||
|
/* Also check if any of A's items implies B */ |
||||||
|
/* Needed to handle ((x OR y) AND z) => (x OR y) */ |
||||||
|
foreach(item, (List *) clause) |
||||||
|
{ |
||||||
|
if (predicate_implied_by_recurse(lfirst(item), predicate)) |
||||||
|
return true; |
||||||
|
} |
||||||
|
return false; |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
/* AND-clause => atom if any of A's items implies B */ |
||||||
|
foreach(item, (List *) clause) |
||||||
|
{ |
||||||
|
if (predicate_implied_by_recurse(lfirst(item), predicate)) |
||||||
|
return true; |
||||||
|
} |
||||||
|
return false; |
||||||
|
} |
||||||
|
} |
||||||
|
else if (or_clause(clause)) |
||||||
|
{ |
||||||
|
if (or_clause(predicate)) |
||||||
|
{ |
||||||
|
/*
|
||||||
|
* OR-clause => OR-clause if each of A's items implies any of |
||||||
|
* B's items. Messy but can't do it any more simply. |
||||||
|
*/ |
||||||
|
foreach(item, ((BoolExpr *) clause)->args) |
||||||
|
{ |
||||||
|
Node *citem = lfirst(item); |
||||||
|
ListCell *item2; |
||||||
|
|
||||||
|
foreach(item2, ((BoolExpr *) predicate)->args) |
||||||
|
{ |
||||||
|
if (predicate_implied_by_recurse(citem, lfirst(item2))) |
||||||
|
break; |
||||||
|
} |
||||||
|
if (item2 == NULL) |
||||||
|
return false; /* doesn't imply any of B's */ |
||||||
|
} |
||||||
|
return true; |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
/* OR-clause => AND-clause if each of A's items implies B */ |
||||||
|
/* OR-clause => atom if each of A's items implies B */ |
||||||
|
foreach(item, ((BoolExpr *) clause)->args) |
||||||
|
{ |
||||||
|
if (!predicate_implied_by_recurse(lfirst(item), predicate)) |
||||||
|
return false; |
||||||
|
} |
||||||
|
return true; |
||||||
|
} |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
if (and_clause(predicate)) |
||||||
|
{ |
||||||
|
/* atom => AND-clause if A implies each of B's items */ |
||||||
|
foreach(item, ((BoolExpr *) predicate)->args) |
||||||
|
{ |
||||||
|
if (!predicate_implied_by_recurse(clause, lfirst(item))) |
||||||
|
return false; |
||||||
|
} |
||||||
|
return true; |
||||||
|
} |
||||||
|
else if (or_clause(predicate)) |
||||||
|
{ |
||||||
|
/* atom => OR-clause if A implies any of B's items */ |
||||||
|
foreach(item, ((BoolExpr *) predicate)->args) |
||||||
|
{ |
||||||
|
if (predicate_implied_by_recurse(clause, lfirst(item))) |
||||||
|
return true; |
||||||
|
} |
||||||
|
return false; |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
/* atom => atom is the base case */ |
||||||
|
return predicate_implied_by_simple_clause((Expr *) predicate, |
||||||
|
clause); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Define an "operator implication table" for btree operators ("strategies"). |
||||||
|
* |
||||||
|
* The strategy numbers defined by btree indexes (see access/skey.h) are: |
||||||
|
* (1) < (2) <= (3) = (4) >= (5) > |
||||||
|
* and in addition we use (6) to represent <>. <> is not a btree-indexable |
||||||
|
* operator, but we assume here that if the equality operator of a btree |
||||||
|
* opclass has a negator operator, the negator behaves as <> for the opclass. |
||||||
|
* |
||||||
|
* The interpretation of: |
||||||
|
* |
||||||
|
* test_op = BT_implic_table[given_op-1][target_op-1] |
||||||
|
* |
||||||
|
* where test_op, given_op and target_op are strategy numbers (from 1 to 6) |
||||||
|
* of btree operators, is as follows: |
||||||
|
* |
||||||
|
* If you know, for some ATTR, that "ATTR given_op CONST1" is true, and you |
||||||
|
* want to determine whether "ATTR target_op CONST2" must also be true, then |
||||||
|
* you can use "CONST2 test_op CONST1" as a test. If this test returns true, |
||||||
|
* then the target expression must be true; if the test returns false, then |
||||||
|
* the target expression may be false. |
||||||
|
* |
||||||
|
* An entry where test_op == 0 means the implication cannot be determined, |
||||||
|
* i.e., this test should always be considered false. |
||||||
|
*/ |
||||||
|
|
||||||
|
#define BTLT BTLessStrategyNumber |
||||||
|
#define BTLE BTLessEqualStrategyNumber |
||||||
|
#define BTEQ BTEqualStrategyNumber |
||||||
|
#define BTGE BTGreaterEqualStrategyNumber |
||||||
|
#define BTGT BTGreaterStrategyNumber |
||||||
|
#define BTNE 6 |
||||||
|
|
||||||
|
static const StrategyNumber |
||||||
|
BT_implic_table[6][6] = { |
||||||
|
/*
|
||||||
|
* The target operator: |
||||||
|
* |
||||||
|
* LT LE EQ GE GT NE |
||||||
|
*/ |
||||||
|
{BTGE, BTGE, 0, 0, 0, BTGE}, /* LT */ |
||||||
|
{BTGT, BTGE, 0, 0, 0, BTGT}, /* LE */ |
||||||
|
{BTGT, BTGE, BTEQ, BTLE, BTLT, BTNE}, /* EQ */ |
||||||
|
{0, 0, 0, BTLE, BTLT, BTLT}, /* GE */ |
||||||
|
{0, 0, 0, BTLE, BTLE, BTLE}, /* GT */ |
||||||
|
{0, 0, 0, 0, 0, BTEQ} /* NE */ |
||||||
|
}; |
||||||
|
|
||||||
|
|
||||||
|
/*----------
|
||||||
|
* predicate_implied_by_simple_clause |
||||||
|
* Does the predicate implication test for a "simple clause" predicate |
||||||
|
* and a "simple clause" restriction. |
||||||
|
* |
||||||
|
* We have three strategies for determining whether one simple clause |
||||||
|
* implies another: |
||||||
|
* |
||||||
|
* A simple and general way is to see if they are equal(); this works for any |
||||||
|
* kind of expression. (Actually, there is an implied assumption that the |
||||||
|
* functions in the expression are immutable, ie dependent only on their input |
||||||
|
* arguments --- but this was checked for the predicate by CheckPredicate().) |
||||||
|
* |
||||||
|
* When the predicate is of the form "foo IS NOT NULL", we can conclude that |
||||||
|
* the predicate is implied if the clause is a strict operator or function |
||||||
|
* that has "foo" as an input. In this case the clause must yield NULL when |
||||||
|
* "foo" is NULL, which we can take as equivalent to FALSE because we know |
||||||
|
* we are within an AND/OR subtree of a WHERE clause. (Again, "foo" is |
||||||
|
* already known immutable, so the clause will certainly always fail.) |
||||||
|
* |
||||||
|
* Our other way works only for binary boolean opclauses of the form |
||||||
|
* "foo op constant", where "foo" is the same in both clauses. The operators |
||||||
|
* and constants can be different but the operators must be in the same btree |
||||||
|
* operator class. We use the above operator implication table to be able to |
||||||
|
* derive implications between nonidentical clauses. (Note: "foo" is known |
||||||
|
* immutable, and constants are surely immutable, but we have to check that |
||||||
|
* the operators are too. As of 8.0 it's possible for opclasses to contain |
||||||
|
* operators that are merely stable, and we dare not make deductions with |
||||||
|
* these.) |
||||||
|
* |
||||||
|
* Eventually, rtree operators could also be handled by defining an |
||||||
|
* appropriate "RT_implic_table" array. |
||||||
|
*---------- |
||||||
|
*/ |
||||||
|
static bool |
||||||
|
predicate_implied_by_simple_clause(Expr *predicate, Node *clause) |
||||||
|
{ |
||||||
|
Node *leftop, |
||||||
|
*rightop; |
||||||
|
Node *pred_var, |
||||||
|
*clause_var; |
||||||
|
Const *pred_const, |
||||||
|
*clause_const; |
||||||
|
bool pred_var_on_left, |
||||||
|
clause_var_on_left, |
||||||
|
pred_op_negated; |
||||||
|
Oid pred_op, |
||||||
|
clause_op, |
||||||
|
pred_op_negator, |
||||||
|
clause_op_negator, |
||||||
|
test_op = InvalidOid; |
||||||
|
Oid opclass_id; |
||||||
|
bool found = false; |
||||||
|
StrategyNumber pred_strategy, |
||||||
|
clause_strategy, |
||||||
|
test_strategy; |
||||||
|
Oid clause_subtype; |
||||||
|
Expr *test_expr; |
||||||
|
ExprState *test_exprstate; |
||||||
|
Datum test_result; |
||||||
|
bool isNull; |
||||||
|
CatCList *catlist; |
||||||
|
int i; |
||||||
|
EState *estate; |
||||||
|
MemoryContext oldcontext; |
||||||
|
|
||||||
|
/* First try the equal() test */ |
||||||
|
if (equal((Node *) predicate, clause)) |
||||||
|
return true; |
||||||
|
|
||||||
|
/* Next try the IS NOT NULL case */ |
||||||
|
if (predicate && IsA(predicate, NullTest) && |
||||||
|
((NullTest *) predicate)->nulltesttype == IS_NOT_NULL) |
||||||
|
{ |
||||||
|
Expr *nonnullarg = ((NullTest *) predicate)->arg; |
||||||
|
|
||||||
|
if (is_opclause(clause) && |
||||||
|
list_member(((OpExpr *) clause)->args, nonnullarg) && |
||||||
|
op_strict(((OpExpr *) clause)->opno)) |
||||||
|
return true; |
||||||
|
if (is_funcclause(clause) && |
||||||
|
list_member(((FuncExpr *) clause)->args, nonnullarg) && |
||||||
|
func_strict(((FuncExpr *) clause)->funcid)) |
||||||
|
return true; |
||||||
|
return false; /* we can't succeed below... */ |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Can't do anything more unless they are both binary opclauses with a |
||||||
|
* Const on one side, and identical subexpressions on the other sides. |
||||||
|
* Note we don't have to think about binary relabeling of the Const |
||||||
|
* node, since that would have been folded right into the Const. |
||||||
|
* |
||||||
|
* If either Const is null, we also fail right away; this assumes that |
||||||
|
* the test operator will always be strict. |
||||||
|
*/ |
||||||
|
if (!is_opclause(predicate)) |
||||||
|
return false; |
||||||
|
leftop = get_leftop(predicate); |
||||||
|
rightop = get_rightop(predicate); |
||||||
|
if (rightop == NULL) |
||||||
|
return false; /* not a binary opclause */ |
||||||
|
if (IsA(rightop, Const)) |
||||||
|
{ |
||||||
|
pred_var = leftop; |
||||||
|
pred_const = (Const *) rightop; |
||||||
|
pred_var_on_left = true; |
||||||
|
} |
||||||
|
else if (IsA(leftop, Const)) |
||||||
|
{ |
||||||
|
pred_var = rightop; |
||||||
|
pred_const = (Const *) leftop; |
||||||
|
pred_var_on_left = false; |
||||||
|
} |
||||||
|
else |
||||||
|
return false; /* no Const to be found */ |
||||||
|
if (pred_const->constisnull) |
||||||
|
return false; |
||||||
|
|
||||||
|
if (!is_opclause(clause)) |
||||||
|
return false; |
||||||
|
leftop = get_leftop((Expr *) clause); |
||||||
|
rightop = get_rightop((Expr *) clause); |
||||||
|
if (rightop == NULL) |
||||||
|
return false; /* not a binary opclause */ |
||||||
|
if (IsA(rightop, Const)) |
||||||
|
{ |
||||||
|
clause_var = leftop; |
||||||
|
clause_const = (Const *) rightop; |
||||||
|
clause_var_on_left = true; |
||||||
|
} |
||||||
|
else if (IsA(leftop, Const)) |
||||||
|
{ |
||||||
|
clause_var = rightop; |
||||||
|
clause_const = (Const *) leftop; |
||||||
|
clause_var_on_left = false; |
||||||
|
} |
||||||
|
else |
||||||
|
return false; /* no Const to be found */ |
||||||
|
if (clause_const->constisnull) |
||||||
|
return false; |
||||||
|
|
||||||
|
/*
|
||||||
|
* Check for matching subexpressions on the non-Const sides. We used |
||||||
|
* to only allow a simple Var, but it's about as easy to allow any |
||||||
|
* expression. Remember we already know that the pred expression does |
||||||
|
* not contain any non-immutable functions, so identical expressions |
||||||
|
* should yield identical results. |
||||||
|
*/ |
||||||
|
if (!equal(pred_var, clause_var)) |
||||||
|
return false; |
||||||
|
|
||||||
|
/*
|
||||||
|
* Okay, get the operators in the two clauses we're comparing. Commute |
||||||
|
* them if needed so that we can assume the variables are on the left. |
||||||
|
*/ |
||||||
|
pred_op = ((OpExpr *) predicate)->opno; |
||||||
|
if (!pred_var_on_left) |
||||||
|
{ |
||||||
|
pred_op = get_commutator(pred_op); |
||||||
|
if (!OidIsValid(pred_op)) |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
clause_op = ((OpExpr *) clause)->opno; |
||||||
|
if (!clause_var_on_left) |
||||||
|
{ |
||||||
|
clause_op = get_commutator(clause_op); |
||||||
|
if (!OidIsValid(clause_op)) |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Try to find a btree opclass containing the needed operators. |
||||||
|
* |
||||||
|
* We must find a btree opclass that contains both operators, else the |
||||||
|
* implication can't be determined. Also, the pred_op has to be of |
||||||
|
* default subtype (implying left and right input datatypes are the |
||||||
|
* same); otherwise it's unsafe to put the pred_const on the left side |
||||||
|
* of the test. Also, the opclass must contain a suitable test |
||||||
|
* operator matching the clause_const's type (which we take to mean |
||||||
|
* that it has the same subtype as the original clause_operator). |
||||||
|
* |
||||||
|
* If there are multiple matching opclasses, assume we can use any one to |
||||||
|
* determine the logical relationship of the two operators and the |
||||||
|
* correct corresponding test operator. This should work for any |
||||||
|
* logically consistent opclasses. |
||||||
|
*/ |
||||||
|
catlist = SearchSysCacheList(AMOPOPID, 1, |
||||||
|
ObjectIdGetDatum(pred_op), |
||||||
|
0, 0, 0); |
||||||
|
|
||||||
|
/*
|
||||||
|
* If we couldn't find any opclass containing the pred_op, perhaps it |
||||||
|
* is a <> operator. See if it has a negator that is in an opclass. |
||||||
|
*/ |
||||||
|
pred_op_negated = false; |
||||||
|
if (catlist->n_members == 0) |
||||||
|
{ |
||||||
|
pred_op_negator = get_negator(pred_op); |
||||||
|
if (OidIsValid(pred_op_negator)) |
||||||
|
{ |
||||||
|
pred_op_negated = true; |
||||||
|
ReleaseSysCacheList(catlist); |
||||||
|
catlist = SearchSysCacheList(AMOPOPID, 1, |
||||||
|
ObjectIdGetDatum(pred_op_negator), |
||||||
|
0, 0, 0); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/* Also may need the clause_op's negator */ |
||||||
|
clause_op_negator = get_negator(clause_op); |
||||||
|
|
||||||
|
/* Now search the opclasses */ |
||||||
|
for (i = 0; i < catlist->n_members; i++) |
||||||
|
{ |
||||||
|
HeapTuple pred_tuple = &catlist->members[i]->tuple; |
||||||
|
Form_pg_amop pred_form = (Form_pg_amop) GETSTRUCT(pred_tuple); |
||||||
|
HeapTuple clause_tuple; |
||||||
|
|
||||||
|
opclass_id = pred_form->amopclaid; |
||||||
|
|
||||||
|
/* must be btree */ |
||||||
|
if (!opclass_is_btree(opclass_id)) |
||||||
|
continue; |
||||||
|
/* predicate operator must be default within this opclass */ |
||||||
|
if (pred_form->amopsubtype != InvalidOid) |
||||||
|
continue; |
||||||
|
|
||||||
|
/* Get the predicate operator's btree strategy number */ |
||||||
|
pred_strategy = (StrategyNumber) pred_form->amopstrategy; |
||||||
|
Assert(pred_strategy >= 1 && pred_strategy <= 5); |
||||||
|
|
||||||
|
if (pred_op_negated) |
||||||
|
{ |
||||||
|
/* Only consider negators that are = */ |
||||||
|
if (pred_strategy != BTEqualStrategyNumber) |
||||||
|
continue; |
||||||
|
pred_strategy = BTNE; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* From the same opclass, find a strategy number for the |
||||||
|
* clause_op, if possible |
||||||
|
*/ |
||||||
|
clause_tuple = SearchSysCache(AMOPOPID, |
||||||
|
ObjectIdGetDatum(clause_op), |
||||||
|
ObjectIdGetDatum(opclass_id), |
||||||
|
0, 0); |
||||||
|
if (HeapTupleIsValid(clause_tuple)) |
||||||
|
{ |
||||||
|
Form_pg_amop clause_form = (Form_pg_amop) GETSTRUCT(clause_tuple); |
||||||
|
|
||||||
|
/* Get the restriction clause operator's strategy/subtype */ |
||||||
|
clause_strategy = (StrategyNumber) clause_form->amopstrategy; |
||||||
|
Assert(clause_strategy >= 1 && clause_strategy <= 5); |
||||||
|
clause_subtype = clause_form->amopsubtype; |
||||||
|
ReleaseSysCache(clause_tuple); |
||||||
|
} |
||||||
|
else if (OidIsValid(clause_op_negator)) |
||||||
|
{ |
||||||
|
clause_tuple = SearchSysCache(AMOPOPID, |
||||||
|
ObjectIdGetDatum(clause_op_negator), |
||||||
|
ObjectIdGetDatum(opclass_id), |
||||||
|
0, 0); |
||||||
|
if (HeapTupleIsValid(clause_tuple)) |
||||||
|
{ |
||||||
|
Form_pg_amop clause_form = (Form_pg_amop) GETSTRUCT(clause_tuple); |
||||||
|
|
||||||
|
/* Get the restriction clause operator's strategy/subtype */ |
||||||
|
clause_strategy = (StrategyNumber) clause_form->amopstrategy; |
||||||
|
Assert(clause_strategy >= 1 && clause_strategy <= 5); |
||||||
|
clause_subtype = clause_form->amopsubtype; |
||||||
|
ReleaseSysCache(clause_tuple); |
||||||
|
|
||||||
|
/* Only consider negators that are = */ |
||||||
|
if (clause_strategy != BTEqualStrategyNumber) |
||||||
|
continue; |
||||||
|
clause_strategy = BTNE; |
||||||
|
} |
||||||
|
else |
||||||
|
continue; |
||||||
|
} |
||||||
|
else |
||||||
|
continue; |
||||||
|
|
||||||
|
/*
|
||||||
|
* Look up the "test" strategy number in the implication table |
||||||
|
*/ |
||||||
|
test_strategy = BT_implic_table[clause_strategy - 1][pred_strategy - 1]; |
||||||
|
if (test_strategy == 0) |
||||||
|
{ |
||||||
|
/* Can't determine implication using this interpretation */ |
||||||
|
continue; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* See if opclass has an operator for the test strategy and the |
||||||
|
* clause datatype. |
||||||
|
*/ |
||||||
|
if (test_strategy == BTNE) |
||||||
|
{ |
||||||
|
test_op = get_opclass_member(opclass_id, clause_subtype, |
||||||
|
BTEqualStrategyNumber); |
||||||
|
if (OidIsValid(test_op)) |
||||||
|
test_op = get_negator(test_op); |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
test_op = get_opclass_member(opclass_id, clause_subtype, |
||||||
|
test_strategy); |
||||||
|
} |
||||||
|
if (OidIsValid(test_op)) |
||||||
|
{ |
||||||
|
/*
|
||||||
|
* Last check: test_op must be immutable. |
||||||
|
* |
||||||
|
* Note that we require only the test_op to be immutable, not the |
||||||
|
* original clause_op. (pred_op must be immutable, else it |
||||||
|
* would not be allowed in an index predicate.) Essentially |
||||||
|
* we are assuming that the opclass is consistent even if it |
||||||
|
* contains operators that are merely stable. |
||||||
|
* |
||||||
|
* XXX the above reasoning doesn't hold anymore if this routine |
||||||
|
* is used to prove things that are not index predicates ... |
||||||
|
*/ |
||||||
|
if (op_volatile(test_op) == PROVOLATILE_IMMUTABLE) |
||||||
|
{ |
||||||
|
found = true; |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
ReleaseSysCacheList(catlist); |
||||||
|
|
||||||
|
if (!found) |
||||||
|
{ |
||||||
|
/* couldn't find a btree opclass to interpret the operators */ |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Evaluate the test. For this we need an EState. |
||||||
|
*/ |
||||||
|
estate = CreateExecutorState(); |
||||||
|
|
||||||
|
/* We can use the estate's working context to avoid memory leaks. */ |
||||||
|
oldcontext = MemoryContextSwitchTo(estate->es_query_cxt); |
||||||
|
|
||||||
|
/* Build expression tree */ |
||||||
|
test_expr = make_opclause(test_op, |
||||||
|
BOOLOID, |
||||||
|
false, |
||||||
|
(Expr *) pred_const, |
||||||
|
(Expr *) clause_const); |
||||||
|
|
||||||
|
/* Prepare it for execution */ |
||||||
|
test_exprstate = ExecPrepareExpr(test_expr, estate); |
||||||
|
|
||||||
|
/* And execute it. */ |
||||||
|
test_result = ExecEvalExprSwitchContext(test_exprstate, |
||||||
|
GetPerTupleExprContext(estate), |
||||||
|
&isNull, NULL); |
||||||
|
|
||||||
|
/* Get back to outer memory context */ |
||||||
|
MemoryContextSwitchTo(oldcontext); |
||||||
|
|
||||||
|
/* Release all the junk we just created */ |
||||||
|
FreeExecutorState(estate); |
||||||
|
|
||||||
|
if (isNull) |
||||||
|
{ |
||||||
|
/* Treat a null result as false ... but it's a tad fishy ... */ |
||||||
|
elog(DEBUG2, "null predicate test result"); |
||||||
|
return false; |
||||||
|
} |
||||||
|
return DatumGetBool(test_result); |
||||||
|
} |
||||||
@ -0,0 +1,23 @@ |
|||||||
|
/*-------------------------------------------------------------------------
|
||||||
|
* |
||||||
|
* predtest.h |
||||||
|
* prototypes for predtest.c |
||||||
|
* |
||||||
|
* |
||||||
|
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group |
||||||
|
* Portions Copyright (c) 1994, Regents of the University of California |
||||||
|
* |
||||||
|
* $PostgreSQL: pgsql/src/include/optimizer/predtest.h,v 1.1 2005/06/10 22:25:37 tgl Exp $ |
||||||
|
* |
||||||
|
*------------------------------------------------------------------------- |
||||||
|
*/ |
||||||
|
#ifndef PREDTEST_H |
||||||
|
#define PREDTEST_H |
||||||
|
|
||||||
|
#include "nodes/primnodes.h" |
||||||
|
|
||||||
|
|
||||||
|
extern bool predicate_implied_by(List *predicate_list, |
||||||
|
List *restrictinfo_list); |
||||||
|
|
||||||
|
#endif /* PREDTEST_H */ |
||||||
Loading…
Reference in new issue