/*
* 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.
*
* We assume the predicate has already been checked to contain only
* immutable functions and operators. (In most current uses this is true
* because the predicate is part of an index predicate that has passed
* CheckPredicate().) We dare not make deductions based on non-immutable
* functions, because they might change answers between the time we make
* the plan and the time we execute the plan.
*/
bool
predicate_implied_by(List *predicate_list, List *restrictinfo_list)
{
Node *p,
*r;
if (predicate_list == NIL)
return true; /* no predicate: implication is vacuous */
if (restrictinfo_list == NIL)
return false; /* no restriction: implication must fail */
/*
* If either input is a single-element list, replace it with its lone
* member; this avoids one useless level of AND-recursion. We only need
* to worry about this at top level, since eval_const_expressions should
* have gotten rid of any trivial ANDs or ORs below that.
*/
if (list_length(predicate_list) == 1)
p = (Node *) linitial(predicate_list);
else
p = (Node *) predicate_list;
if (list_length(restrictinfo_list) == 1)
r = (Node *) linitial(restrictinfo_list);
else
r = (Node *) restrictinfo_list;
/* And away we go ... */
return predicate_implied_by_recurse(r, p);
}
/*
* 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.
*
* We assume the predicate has already been checked to contain only
* immutable functions and operators. (In most current uses this is true
* because the predicate is part of an index predicate that has passed
* CheckPredicate().) We dare not make deductions based on non-immutable
* functions, because they might change answers between the time we make
* the plan and the time we execute the plan.
*/
bool
predicate_implied_by(List *predicate_list, List *restrictinfo_list)
{
if (predicate_list == NIL)
return true; /* no predicate: implication is vacuous */
if (restrictinfo_list == NIL)
return false; /* no restriction: implication must fail */
/* Otherwise, away we go ... */
return predicate_implied_by_recurse((Node *) restrictinfo_list,
(Node *) predicate_list);
}
/*----------
* 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.
*
* 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)
{
PredIterInfoData clause_info;
PredIterInfoData pred_info;
PredClass pclass;
bool result;
/* skip through RestrictInfo */
Assert(clause != NULL);
if (IsA(clause, RestrictInfo))
clause = (Node *) ((RestrictInfo *) clause)->clause;
pclass = predicate_classify(predicate, &pred_info);
switch (predicate_classify(clause, &clause_info))
{
case CLASS_AND:
switch (pclass)
{
case CLASS_AND:
/*
* AND-clause => AND-clause if A implies each of B's items
*/
result = true;
iterate_begin(pitem, predicate, pred_info)
{
if (!predicate_implied_by_recurse(clause, pitem))
{
result = false;
break;
}
}
iterate_end(pred_info);
return result;
case CLASS_OR:
/*
* AND-clause => OR-clause if A implies any of B's items
*
* Needed to handle (x AND y) => ((x AND y) OR z)
*/
result = false;
iterate_begin(pitem, predicate, pred_info)
{
if (predicate_implied_by_recurse(clause, pitem))
{
result = true;
break;
}
}
iterate_end(pred_info);
if (result)
return result;
/*
* Also check if any of A's items implies B
*
* Needed to handle ((x OR y) AND z) => (x OR y)
*/
iterate_begin(citem, clause, clause_info)
{
if (predicate_implied_by_recurse(citem, predicate))
{
result = true;
break;
}
}
iterate_end(clause_info);
return result;
case CLASS_ATOM:
/*
* AND-clause => atom if any of A's items implies B
*/
result = false;
iterate_begin(citem, clause, clause_info)
{
if (predicate_implied_by_recurse(citem, predicate))
{
result = true;
break;
}
}
iterate_end(clause_info);
return result;
}
break;
case CLASS_OR:
switch (pclass)
{
case CLASS_OR:
/*
* 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.
*/
result = true;
iterate_begin(citem, clause, clause_info)
{
bool presult = false;
iterate_begin(pitem, predicate, pred_info)
{
if (predicate_implied_by_recurse(citem, pitem))
{
presult = true;
break;
}
}
iterate_end(pred_info);
if (!presult)
{
result = false; /* doesn't imply any of B's */
break;
}
}
iterate_end(clause_info);
return result;
case CLASS_AND:
case CLASS_ATOM:
/*
* OR-clause => AND-clause if each of A's items implies B
*
* OR-clause => atom if each of A's items implies B
*/
result = true;
iterate_begin(citem, clause, clause_info)
{
if (!predicate_implied_by_recurse(citem, predicate))
{
result = false;
break;
}
}
iterate_end(clause_info);
return result;
}
break;
case CLASS_ATOM:
switch (pclass)
{
case CLASS_AND:
/*
* atom => AND-clause if A implies each of B's items
*/
result = true;
iterate_begin(pitem, predicate, pred_info)
{
if (!predicate_implied_by_recurse(clause, pitem))
{
result = false;
break;
}
}
iterate_end(pred_info);
return result;
case CLASS_OR:
/*
* atom => OR-clause if A implies any of B's items
*/
result = false;
iterate_begin(pitem, predicate, pred_info)
{
if (predicate_implied_by_recurse(clause, pitem))
{
result = true;
break;
}
}
iterate_end(pred_info);
return result;
case CLASS_ATOM:
/*
* atom => atom is the base case
*/
return
predicate_implied_by_simple_clause((Expr *) predicate,
clause);
}
break;
}
