#include "postgres.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "executor/executor.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/clauses.h"
#include "optimizer/predtest.h"
#include "utils/array.h"
#include "utils/inval.h"
#include "utils/lsyscache.h"
#include "utils/syscache.h"

Include dependency graph for predtest.c:

Data Structures
struct	PredIterInfoData

struct	ArrayConstIterState

struct	ArrayExprIterState

struct	OprProofCacheKey

struct	OprProofCacheEntry

Macros
#define	MAX_SAOP_ARRAY_SIZE 100

#define	iterate_begin(item, clause, info)

#define	iterate_end(info)

#define	BTLT BTLessStrategyNumber

#define	BTLE BTLessEqualStrategyNumber

#define	BTEQ BTEqualStrategyNumber

#define	BTGE BTGreaterEqualStrategyNumber

#define	BTGT BTGreaterStrategyNumber

#define	BTNE ROWCOMPARE_NE

#define	none 0

Typedefs
typedef struct PredIterInfoData *	PredIterInfo

typedef struct PredIterInfoData	PredIterInfoData

typedef struct OprProofCacheKey	OprProofCacheKey

typedef struct OprProofCacheEntry	OprProofCacheEntry

Enumerations
enum	PredClass { CLASS_ATOM, CLASS_AND, CLASS_OR }

Functions
static bool	predicate_implied_by_recurse (Node clause, Node predicate, bool clause_is_check)

static bool	predicate_refuted_by_recurse (Node clause, Node predicate, bool clause_is_check)

static PredClass	predicate_classify (Node *clause, PredIterInfo info)

static void	list_startup_fn (Node *clause, PredIterInfo info)

static Node *	list_next_fn (PredIterInfo info)

static void	list_cleanup_fn (PredIterInfo info)

static void	boolexpr_startup_fn (Node *clause, PredIterInfo info)

static void	arrayconst_startup_fn (Node *clause, PredIterInfo info)

static Node *	arrayconst_next_fn (PredIterInfo info)

static void	arrayconst_cleanup_fn (PredIterInfo info)

static void	arrayexpr_startup_fn (Node *clause, PredIterInfo info)

static Node *	arrayexpr_next_fn (PredIterInfo info)

static void	arrayexpr_cleanup_fn (PredIterInfo info)

static bool	predicate_implied_by_simple_clause (Expr predicate, Node clause, bool clause_is_check)

static bool	predicate_refuted_by_simple_clause (Expr predicate, Node clause, bool clause_is_check)

static Node *	extract_not_arg (Node *clause)

static Node *	extract_strong_not_arg (Node *clause)

static bool	list_member_strip (List list, Expr datum)

static bool	operator_predicate_proof (Expr predicate, Node clause, bool refute_it)

static bool	operator_same_subexprs_proof (Oid pred_op, Oid clause_op, bool refute_it)

static bool	operator_same_subexprs_lookup (Oid pred_op, Oid clause_op, bool refute_it)

static Oid	get_btree_test_op (Oid pred_op, Oid clause_op, bool refute_it)

static void	InvalidateOprProofCacheCallBack (Datum arg, int cacheid, uint32 hashvalue)

bool	predicate_implied_by (List predicate_list, List clause_list, bool clause_is_check)

bool	predicate_refuted_by (List predicate_list, List clause_list, bool clause_is_check)

static OprProofCacheEntry *	lookup_proof_cache (Oid pred_op, Oid clause_op, bool refute_it)

Variables
static const bool	BT_implies_table [6][6]

static const bool	BT_refutes_table [6][6]

static const StrategyNumber	BT_implic_table [6][6]

static const StrategyNumber	BT_refute_table [6][6]

static HTAB *	OprProofCacheHash = NULL

Macro Definition Documentation

#define BTEQ BTEqualStrategyNumber

Definition at line 1350 of file predtest.c.

#define BTGE BTGreaterEqualStrategyNumber

Definition at line 1351 of file predtest.c.

#define BTGT BTGreaterStrategyNumber

Definition at line 1352 of file predtest.c.

#define BTLE BTLessEqualStrategyNumber

Definition at line 1349 of file predtest.c.

#define BTLT BTLessStrategyNumber

Definition at line 1348 of file predtest.c.

#define BTNE ROWCOMPARE_NE

Definition at line 1353 of file predtest.c.

Referenced by lookup_proof_cache().

#define iterate_begin	(	item,
		clause,
		info
	)

Value:

do { \
		Node   *item; \
        (info).startup_fn((clause), &(info)); \
        while ((item = (info).next_fn(&(info))) != NULL)

Definition at line 69 of file predtest.c.

Referenced by predicate_implied_by_recurse(), and predicate_refuted_by_recurse().

#define iterate_end ( info )

Value:

(info).cleanup_fn(&(info)); \

} while (0)

Definition at line 75 of file predtest.c.

Referenced by predicate_implied_by_recurse(), and predicate_refuted_by_recurse().

#define MAX_SAOP_ARRAY_SIZE 100

Definition at line 38 of file predtest.c.

Referenced by predicate_classify().

#define none 0

Definition at line 1356 of file predtest.c.

Typedef Documentation

typedef struct OprProofCacheEntry OprProofCacheEntry

typedef struct OprProofCacheKey OprProofCacheKey

typedef struct PredIterInfoData* PredIterInfo

Definition at line 55 of file predtest.c.

typedef struct PredIterInfoData PredIterInfoData

Enumeration Type Documentation

enum PredClass

Enumerator
CLASS_ATOM
CLASS_AND
CLASS_OR

Definition at line 48 of file predtest.c.

 {
     CLASS_ATOM,                 /* expression that's not AND or OR */
     CLASS_AND,                  /* expression with AND semantics */
     CLASS_OR                    /* expression with OR semantics */
 } PredClass;

Function Documentation

static void arrayconst_cleanup_fn ( PredIterInfo info )

static

Definition at line 978 of file predtest.c.

References OpExpr::args, ArrayConstIterState::elem_nulls, ArrayConstIterState::elem_values, list_free(), ArrayConstIterState::opexpr, pfree(), and PredIterInfoData::state.

Referenced by predicate_classify().

 {
     ArrayConstIterState *state = (ArrayConstIterState *) info->state;
 
     pfree(state->elem_values);
     pfree(state->elem_nulls);
     list_free(state->opexpr.args);
     pfree(state);
 }

static Node * arrayconst_next_fn ( PredIterInfo info )

static

Definition at line 965 of file predtest.c.

References ArrayConstIterState::constexpr, Const::constisnull, Const::constvalue, ArrayConstIterState::elem_nulls, ArrayConstIterState::elem_values, ArrayConstIterState::next_elem, NULL, ArrayConstIterState::num_elems, ArrayConstIterState::opexpr, and PredIterInfoData::state.

Referenced by predicate_classify().

 {
     ArrayConstIterState *state = (ArrayConstIterState *) info->state;
 
     if (state->next_elem >= state->num_elems)
         return NULL;
     state->constexpr.constvalue = state->elem_values[state->next_elem];
     state->constexpr.constisnull = state->elem_nulls[state->next_elem];
     state->next_elem++;
     return (Node *) &(state->opexpr);
 }

static void arrayconst_startup_fn	(	Node *	clause,
		PredIterInfo	info
	)

static

Definition at line 916 of file predtest.c.

References OpExpr::args, ScalarArrayOpExpr::args, ARR_ELEMTYPE, BOOLOID, Const::constbyval, Const::constcollid, ArrayConstIterState::constexpr, Const::constlen, Const::consttype, Const::consttypmod, Const::constvalue, DatumGetArrayTypeP, deconstruct_array(), ArrayConstIterState::elem_nulls, ArrayConstIterState::elem_values, get_typlenbyvalalign(), OpExpr::inputcollid, ScalarArrayOpExpr::inputcollid, InvalidOid, list_copy(), lsecond, ArrayConstIterState::next_elem, ArrayConstIterState::num_elems, OpExpr::opcollid, ArrayConstIterState::opexpr, OpExpr::opfuncid, ScalarArrayOpExpr::opfuncid, OpExpr::opno, ScalarArrayOpExpr::opno, OpExpr::opresulttype, OpExpr::opretset, palloc(), PredIterInfoData::state, T_Const, T_OpExpr, Expr::type, Const::xpr, and OpExpr::xpr.

Referenced by predicate_classify().

 {
     ScalarArrayOpExpr *saop = (ScalarArrayOpExpr *) clause;
     ArrayConstIterState *state;
     Const      *arrayconst;
     ArrayType  *arrayval;
     int16       elmlen;
     bool        elmbyval;
     char        elmalign;
 
     /* Create working state struct */
     state = (ArrayConstIterState *) palloc(sizeof(ArrayConstIterState));
     info->state = (void *) state;
 
     /* Deconstruct the array literal */
     arrayconst = (Const *) lsecond(saop->args);
     arrayval = DatumGetArrayTypeP(arrayconst->constvalue);
     get_typlenbyvalalign(ARR_ELEMTYPE(arrayval),
                          &elmlen, &elmbyval, &elmalign);
     deconstruct_array(arrayval,
                       ARR_ELEMTYPE(arrayval),
                       elmlen, elmbyval, elmalign,
                       &state->elem_values, &state->elem_nulls,
                       &state->num_elems);
 
     /* Set up a dummy OpExpr to return as the per-item node */
     state->opexpr.xpr.type = T_OpExpr;
     state->opexpr.opno = saop->opno;
     state->opexpr.opfuncid = saop->opfuncid;
     state->opexpr.opresulttype = BOOLOID;
     state->opexpr.opretset = false;
     state->opexpr.opcollid = InvalidOid;
     state->opexpr.inputcollid = saop->inputcollid;
     state->opexpr.args = list_copy(saop->args);
 
     /* Set up a dummy Const node to hold the per-element values */
     state->constexpr.xpr.type = T_Const;
     state->constexpr.consttype = ARR_ELEMTYPE(arrayval);
     state->constexpr.consttypmod = -1;
     state->constexpr.constcollid = arrayconst->constcollid;
     state->constexpr.constlen = elmlen;
     state->constexpr.constbyval = elmbyval;
     lsecond(state->opexpr.args) = &state->constexpr;
 
     /* Initialize iteration state */
     state->next_elem = 0;
 }

static void arrayexpr_cleanup_fn ( PredIterInfo info )

static

Definition at line 1037 of file predtest.c.

References OpExpr::args, list_free(), ArrayExprIterState::opexpr, pfree(), and PredIterInfoData::state.

Referenced by predicate_classify().

 {
     ArrayExprIterState *state = (ArrayExprIterState *) info->state;
 
     list_free(state->opexpr.args);
     pfree(state);
 }

static Node * arrayexpr_next_fn ( PredIterInfo info )

static

Definition at line 1025 of file predtest.c.

References OpExpr::args, lfirst, lnext, lsecond, ArrayExprIterState::next, NULL, ArrayExprIterState::opexpr, and PredIterInfoData::state.

Referenced by predicate_classify().

 {
     ArrayExprIterState *state = (ArrayExprIterState *) info->state;
 
     if (state->next == NULL)
         return NULL;
     lsecond(state->opexpr.args) = lfirst(state->next);
     state->next = lnext(state->next);
     return (Node *) &(state->opexpr);
 }

static void arrayexpr_startup_fn	(	Node *	clause,
		PredIterInfo	info
	)

static

Definition at line 999 of file predtest.c.

References OpExpr::args, ScalarArrayOpExpr::args, BOOLOID, ArrayExpr::elements, OpExpr::inputcollid, ScalarArrayOpExpr::inputcollid, InvalidOid, list_copy(), list_head(), lsecond, ArrayExprIterState::next, OpExpr::opcollid, ArrayExprIterState::opexpr, OpExpr::opfuncid, ScalarArrayOpExpr::opfuncid, OpExpr::opno, ScalarArrayOpExpr::opno, OpExpr::opresulttype, OpExpr::opretset, palloc(), PredIterInfoData::state, T_OpExpr, Expr::type, and OpExpr::xpr.

Referenced by predicate_classify().

 {
     ScalarArrayOpExpr *saop = (ScalarArrayOpExpr *) clause;
     ArrayExprIterState *state;
     ArrayExpr  *arrayexpr;
 
     /* Create working state struct */
     state = (ArrayExprIterState *) palloc(sizeof(ArrayExprIterState));
     info->state = (void *) state;
 
     /* Set up a dummy OpExpr to return as the per-item node */
     state->opexpr.xpr.type = T_OpExpr;
     state->opexpr.opno = saop->opno;
     state->opexpr.opfuncid = saop->opfuncid;
     state->opexpr.opresulttype = BOOLOID;
     state->opexpr.opretset = false;
     state->opexpr.opcollid = InvalidOid;
     state->opexpr.inputcollid = saop->inputcollid;
     state->opexpr.args = list_copy(saop->args);
 
     /* Initialize iteration variable to first member of ArrayExpr */
     arrayexpr = (ArrayExpr *) lsecond(saop->args);
     state->next = list_head(arrayexpr->elements);
 }

static void boolexpr_startup_fn	(	Node *	clause,
		PredIterInfo	info
	)

static

Definition at line 896 of file predtest.c.

References list_head(), and PredIterInfoData::state.

Referenced by predicate_classify().

 {
     info->state = (void *) list_head(((BoolExpr *) clause)->args);
 }

static Node * extract_not_arg ( Node * clause )

static

Definition at line 1213 of file predtest.c.

References BooleanTest::arg, BoolExpr::args, BoolExpr::boolop, BooleanTest::booltesttype, IS_FALSE, IS_NOT_TRUE, IS_UNKNOWN, IsA, linitial, NOT_EXPR, and NULL.

Referenced by predicate_refuted_by_recurse().

 {
     if (clause == NULL)
         return NULL;
     if (IsA(clause, BoolExpr))
     {
         BoolExpr   *bexpr = (BoolExpr *) clause;
 
         if (bexpr->boolop == NOT_EXPR)
             return (Node *) linitial(bexpr->args);
     }
     else if (IsA(clause, BooleanTest))
     {
         BooleanTest *btest = (BooleanTest *) clause;
 
         if (btest->booltesttype == IS_NOT_TRUE ||
             btest->booltesttype == IS_FALSE ||
             btest->booltesttype == IS_UNKNOWN)
             return (Node *) btest->arg;
     }
     return NULL;
 }

static Node * extract_strong_not_arg ( Node * clause )

static

Definition at line 1241 of file predtest.c.

References BooleanTest::arg, BoolExpr::args, BoolExpr::boolop, BooleanTest::booltesttype, IS_FALSE, IsA, linitial, NOT_EXPR, and NULL.

Referenced by predicate_refuted_by_recurse().

 {
     if (clause == NULL)
         return NULL;
     if (IsA(clause, BoolExpr))
     {
         BoolExpr   *bexpr = (BoolExpr *) clause;
 
         if (bexpr->boolop == NOT_EXPR)
             return (Node *) linitial(bexpr->args);
     }
     else if (IsA(clause, BooleanTest))
     {
         BooleanTest *btest = (BooleanTest *) clause;
 
         if (btest->booltesttype == IS_FALSE)
             return (Node *) btest->arg;
     }
     return NULL;
 }

static Oid get_btree_test_op	(	Oid	pred_op,
		Oid	clause_op,
		bool	refute_it
	)

static

Definition at line 1966 of file predtest.c.

References OprProofCacheEntry::implic_test_op, lookup_proof_cache(), and OprProofCacheEntry::refute_test_op.

Referenced by operator_predicate_proof().

 {
     OprProofCacheEntry *cache_entry;
 
     cache_entry = lookup_proof_cache(pred_op, clause_op, refute_it);
     if (refute_it)
         return cache_entry->refute_test_op;
     else
         return cache_entry->implic_test_op;
 }

static void InvalidateOprProofCacheCallBack	(	Datum	arg,
		int	cacheid,
		uint32	hashvalue
	)

static

Definition at line 1982 of file predtest.c.

References Assert, hash_seq_init(), hash_seq_search(), OprProofCacheEntry::have_implic, OprProofCacheEntry::have_refute, NULL, and status().

Referenced by lookup_proof_cache().

 {
     HASH_SEQ_STATUS status;
     OprProofCacheEntry *hentry;
 
     Assert(OprProofCacheHash != NULL);
 
     /* Currently we just reset all entries; hard to be smarter ... */
     hash_seq_init(&status, OprProofCacheHash);
 
     while ((hentry = (OprProofCacheEntry *) hash_seq_search(&status)) != NULL)
     {
         hentry->have_implic = false;
         hentry->have_refute = false;
     }
 }

static void list_cleanup_fn ( PredIterInfo info )

static

Definition at line 886 of file predtest.c.

Referenced by predicate_classify().

 {
     /* Nothing to clean up */
 }

static bool list_member_strip	(	List *	list,
		Expr *	datum
	)

static

Definition at line 1271 of file predtest.c.

References arg, equal(), IsA, and lfirst.

Referenced by predicate_implied_by_simple_clause(), and predicate_refuted_by_simple_clause().

 {
     ListCell   *cell;
 
     if (datum && IsA(datum, RelabelType))
         datum = ((RelabelType *) datum)->arg;
 
     foreach(cell, list)
     {
         Expr       *elem = (Expr *) lfirst(cell);
 
         if (elem && IsA(elem, RelabelType))
             elem = ((RelabelType *) elem)->arg;
 
         if (equal(elem, datum))
             return true;
     }
 
     return false;
 }

static Node * list_next_fn ( PredIterInfo info )

static

Definition at line 873 of file predtest.c.

References lfirst, lnext, NULL, and PredIterInfoData::state.

Referenced by predicate_classify().

 {
     ListCell   *l = (ListCell *) info->state;
     Node       *n;
 
     if (l == NULL)
         return NULL;
     n = lfirst(l);
     info->state = (void *) lnext(l);
     return n;
 }

static void list_startup_fn	(	Node *	clause,
		PredIterInfo	info
	)

static

Definition at line 867 of file predtest.c.

References list_head(), and PredIterInfoData::state.

Referenced by predicate_classify().

 {
     info->state = (void *) list_head((List *) clause);
 }

static OprProofCacheEntry* lookup_proof_cache	(	Oid	pred_op,
		Oid	clause_op,
		bool	refute_it
	)

static

Definition at line 1736 of file predtest.c.

References AMOPOPID, Assert, BT_implic_table, BT_implies_table, BT_refute_table, BT_refutes_table, BTEqualStrategyNumber, BTNE, CacheRegisterSyscacheCallback(), OprProofCacheKey::clause_op, HASHCTL::entrysize, get_negator(), get_op_btree_interpretation(), get_opfamily_member(), HASH_BLOBS, hash_create(), HASH_ELEM, HASH_ENTER, hash_search(), OprProofCacheEntry::have_implic, OprProofCacheEntry::have_refute, OprProofCacheEntry::implic_test_op, InvalidateOprProofCacheCallBack(), InvalidOid, HASHCTL::keysize, lfirst, list_free_deep(), MemSet, NIL, NULL, OidIsValid, op_volatile(), OpBtreeInterpretation::opfamily_id, OpBtreeInterpretation::oplefttype, OpBtreeInterpretation::oprighttype, OprProofCacheKey::pred_op, PROVOLATILE_IMMUTABLE, OprProofCacheEntry::refute_test_op, OprProofCacheEntry::same_subexprs_implies, OprProofCacheEntry::same_subexprs_refutes, and OpBtreeInterpretation::strategy.

Referenced by get_btree_test_op(), and operator_same_subexprs_lookup().

 {
     OprProofCacheKey key;
     OprProofCacheEntry *cache_entry;
     bool        cfound;
     bool        same_subexprs = false;
     Oid         test_op = InvalidOid;
     bool        found = false;
     List       *pred_op_infos,
                *clause_op_infos;
     ListCell   *lcp,
                *lcc;
 
     /*
      * Find or make a cache entry for this pair of operators.
      */
     if (OprProofCacheHash == NULL)
     {
         /* First time through: initialize the hash table */
         HASHCTL     ctl;
 
         MemSet(&ctl, 0, sizeof(ctl));
         ctl.keysize = sizeof(OprProofCacheKey);
         ctl.entrysize = sizeof(OprProofCacheEntry);
         OprProofCacheHash = hash_create("Btree proof lookup cache", 256,
                                         &ctl, HASH_ELEM | HASH_BLOBS);
 
         /* Arrange to flush cache on pg_amop changes */
         CacheRegisterSyscacheCallback(AMOPOPID,
                                       InvalidateOprProofCacheCallBack,
                                       (Datum) 0);
     }
 
     key.pred_op = pred_op;
     key.clause_op = clause_op;
     cache_entry = (OprProofCacheEntry *) hash_search(OprProofCacheHash,
                                                      (void *) &key,
                                                      HASH_ENTER, &cfound);
     if (!cfound)
     {
         /* new cache entry, set it invalid */
         cache_entry->have_implic = false;
         cache_entry->have_refute = false;
     }
     else
     {
         /* pre-existing cache entry, see if we know the answer yet */
         if (refute_it ? cache_entry->have_refute : cache_entry->have_implic)
             return cache_entry;
     }
 
     /*
      * Try to find a btree opfamily containing the given operators.
      *
      * We must find a btree opfamily that contains both operators, else the
      * implication can't be determined.  Also, the opfamily must contain a
      * suitable test operator taking the operators' righthand datatypes.
      *
      * If there are multiple matching opfamilies, 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 opfamilies.
      *
      * Note that we can determine the operators' relationship for
      * same-subexprs cases even from an opfamily that lacks a usable test
      * operator.  This can happen in cases with incomplete sets of cross-type
      * comparison operators.
      */
     clause_op_infos = get_op_btree_interpretation(clause_op);
     if (clause_op_infos)
         pred_op_infos = get_op_btree_interpretation(pred_op);
     else                        /* no point in looking */
         pred_op_infos = NIL;
 
     foreach(lcp, pred_op_infos)
     {
         OpBtreeInterpretation *pred_op_info = lfirst(lcp);
         Oid         opfamily_id = pred_op_info->opfamily_id;
 
         foreach(lcc, clause_op_infos)
         {
             OpBtreeInterpretation *clause_op_info = lfirst(lcc);
             StrategyNumber pred_strategy,
                         clause_strategy,
                         test_strategy;
 
             /* Must find them in same opfamily */
             if (opfamily_id != clause_op_info->opfamily_id)
                 continue;
             /* Lefttypes should match */
             Assert(clause_op_info->oplefttype == pred_op_info->oplefttype);
 
             pred_strategy = pred_op_info->strategy;
             clause_strategy = clause_op_info->strategy;
 
             /*
              * Check to see if we can make a proof for same-subexpressions
              * cases based on the operators' relationship in this opfamily.
              */
             if (refute_it)
                 same_subexprs |= BT_refutes_table[clause_strategy - 1][pred_strategy - 1];
             else
                 same_subexprs |= BT_implies_table[clause_strategy - 1][pred_strategy - 1];
 
             /*
              * Look up the "test" strategy number in the implication table
              */
             if (refute_it)
                 test_strategy = BT_refute_table[clause_strategy - 1][pred_strategy - 1];
             else
                 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 opfamily has an operator for the test strategy and the
              * datatypes.
              */
             if (test_strategy == BTNE)
             {
                 test_op = get_opfamily_member(opfamily_id,
                                               pred_op_info->oprighttype,
                                               clause_op_info->oprighttype,
                                               BTEqualStrategyNumber);
                 if (OidIsValid(test_op))
                     test_op = get_negator(test_op);
             }
             else
             {
                 test_op = get_opfamily_member(opfamily_id,
                                               pred_op_info->oprighttype,
                                               clause_op_info->oprighttype,
                                               test_strategy);
             }
 
             if (!OidIsValid(test_op))
                 continue;
 
             /*
              * 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 is assumed to have been checked
              * immutable by the caller.)  Essentially we are assuming that the
              * opfamily is consistent even if it contains operators that are
              * merely stable.
              */
             if (op_volatile(test_op) == PROVOLATILE_IMMUTABLE)
             {
                 found = true;
                 break;
             }
         }
 
         if (found)
             break;
     }
 
     list_free_deep(pred_op_infos);
     list_free_deep(clause_op_infos);
 
     if (!found)
     {
         /* couldn't find a suitable comparison operator */
         test_op = InvalidOid;
     }
 
     /*
      * If we think we were able to prove something about same-subexpressions
      * cases, check to make sure the clause_op is immutable before believing
      * it completely.  (Usually, the clause_op would be immutable if the
      * pred_op is, but it's not entirely clear that this must be true in all
      * cases, so let's check.)
      */
     if (same_subexprs &&
         op_volatile(clause_op) != PROVOLATILE_IMMUTABLE)
         same_subexprs = false;
 
     /* Cache the results, whether positive or negative */
     if (refute_it)
     {
         cache_entry->refute_test_op = test_op;
         cache_entry->same_subexprs_refutes = same_subexprs;
         cache_entry->have_refute = true;
     }
     else
     {
         cache_entry->implic_test_op = test_op;
         cache_entry->same_subexprs_implies = same_subexprs;
         cache_entry->have_implic = true;
     }
 
     return cache_entry;
 }

static bool operator_predicate_proof	(	Expr *	predicate,
		Node *	clause,
		bool	refute_it
	)

static

Definition at line 1449 of file predtest.c.

References OpExpr::args, BOOLOID, Const::constisnull, CreateExecutorState(), DatumGetBool, DEBUG2, elog, equal(), EState::es_query_cxt, ExecEvalExprSwitchContext(), ExecInitExpr(), fix_opfuncids(), FreeExecutorState(), get_btree_test_op(), get_commutator(), GetPerTupleExprContext, OpExpr::inputcollid, InvalidOid, is_opclause, IsA, linitial, list_length(), lsecond, make_opclause(), MemoryContextSwitchTo(), NULL, OidIsValid, operator_same_subexprs_proof(), and OpExpr::opno.

Referenced by predicate_implied_by_simple_clause(), and predicate_refuted_by_simple_clause().

 {
     OpExpr     *pred_opexpr,
                *clause_opexpr;
     Oid         pred_collation,
                 clause_collation;
     Oid         pred_op,
                 clause_op,
                 test_op;
     Node       *pred_leftop,
                *pred_rightop,
                *clause_leftop,
                *clause_rightop;
     Const      *pred_const,
                *clause_const;
     Expr       *test_expr;
     ExprState  *test_exprstate;
     Datum       test_result;
     bool        isNull;
     EState     *estate;
     MemoryContext oldcontext;
 
     /*
      * Both expressions must be binary opclauses, else we can't do anything.
      *
      * Note: in future we might extend this logic to other operator-based
      * constructs such as DistinctExpr.  But the planner isn't very smart
      * about DistinctExpr in general, and this probably isn't the first place
      * to fix if you want to improve that.
      */
     if (!is_opclause(predicate))
         return false;
     pred_opexpr = (OpExpr *) predicate;
     if (list_length(pred_opexpr->args) != 2)
         return false;
     if (!is_opclause(clause))
         return false;
     clause_opexpr = (OpExpr *) clause;
     if (list_length(clause_opexpr->args) != 2)
         return false;
 
     /*
      * If they're marked with different collations then we can't do anything.
      * This is a cheap test so let's get it out of the way early.
      */
     pred_collation = pred_opexpr->inputcollid;
     clause_collation = clause_opexpr->inputcollid;
     if (pred_collation != clause_collation)
         return false;
 
     /* Grab the operator OIDs now too.  We may commute these below. */
     pred_op = pred_opexpr->opno;
     clause_op = clause_opexpr->opno;
 
     /*
      * We have to match up at least one pair of input expressions.
      */
     pred_leftop = (Node *) linitial(pred_opexpr->args);
     pred_rightop = (Node *) lsecond(pred_opexpr->args);
     clause_leftop = (Node *) linitial(clause_opexpr->args);
     clause_rightop = (Node *) lsecond(clause_opexpr->args);
 
     if (equal(pred_leftop, clause_leftop))
     {
         if (equal(pred_rightop, clause_rightop))
         {
             /* We have x op1 y and x op2 y */
             return operator_same_subexprs_proof(pred_op, clause_op, refute_it);
         }
         else
         {
             /* Fail unless rightops are both Consts */
             if (pred_rightop == NULL || !IsA(pred_rightop, Const))
                 return false;
             pred_const = (Const *) pred_rightop;
             if (clause_rightop == NULL || !IsA(clause_rightop, Const))
                 return false;
             clause_const = (Const *) clause_rightop;
         }
     }
     else if (equal(pred_rightop, clause_rightop))
     {
         /* Fail unless leftops are both Consts */
         if (pred_leftop == NULL || !IsA(pred_leftop, Const))
             return false;
         pred_const = (Const *) pred_leftop;
         if (clause_leftop == NULL || !IsA(clause_leftop, Const))
             return false;
         clause_const = (Const *) clause_leftop;
         /* Commute both operators so we can assume Consts are on the right */
         pred_op = get_commutator(pred_op);
         if (!OidIsValid(pred_op))
             return false;
         clause_op = get_commutator(clause_op);
         if (!OidIsValid(clause_op))
             return false;
     }
     else if (equal(pred_leftop, clause_rightop))
     {
         if (equal(pred_rightop, clause_leftop))
         {
             /* We have x op1 y and y op2 x */
             /* Commute pred_op that we can treat this like a straight match */
             pred_op = get_commutator(pred_op);
             if (!OidIsValid(pred_op))
                 return false;
             return operator_same_subexprs_proof(pred_op, clause_op, refute_it);
         }
         else
         {
             /* Fail unless pred_rightop/clause_leftop are both Consts */
             if (pred_rightop == NULL || !IsA(pred_rightop, Const))
                 return false;
             pred_const = (Const *) pred_rightop;
             if (clause_leftop == NULL || !IsA(clause_leftop, Const))
                 return false;
             clause_const = (Const *) clause_leftop;
             /* Commute clause_op so we can assume Consts are on the right */
             clause_op = get_commutator(clause_op);
             if (!OidIsValid(clause_op))
                 return false;
         }
     }
     else if (equal(pred_rightop, clause_leftop))
     {
         /* Fail unless pred_leftop/clause_rightop are both Consts */
         if (pred_leftop == NULL || !IsA(pred_leftop, Const))
             return false;
         pred_const = (Const *) pred_leftop;
         if (clause_rightop == NULL || !IsA(clause_rightop, Const))
             return false;
         clause_const = (Const *) clause_rightop;
         /* Commute pred_op so we can assume Consts are on the right */
         pred_op = get_commutator(pred_op);
         if (!OidIsValid(pred_op))
             return false;
     }
     else
     {
         /* Failed to match up any of the subexpressions, so we lose */
         return false;
     }
 
     /*
      * We have two identical subexpressions, and two other subexpressions that
      * are not identical but are both Consts; and we have commuted the
      * operators if necessary so that the Consts are on the right.  We'll need
      * to compare the Consts' values.  If either is NULL, fail.
      */
     if (pred_const->constisnull)
         return false;
     if (clause_const->constisnull)
         return false;
 
     /*
      * Lookup the constant-comparison operator using the system catalogs and
      * the operator implication tables.
      */
     test_op = get_btree_test_op(pred_op, clause_op, refute_it);
 
     if (!OidIsValid(test_op))
     {
         /* couldn't find a suitable comparison operator */
         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,
                               InvalidOid,
                               pred_collation);
 
     /* Fill in opfuncids */
     fix_opfuncids((Node *) test_expr);
 
     /* Prepare it for execution */
     test_exprstate = ExecInitExpr(test_expr, NULL);
 
     /* And execute it. */
     test_result = ExecEvalExprSwitchContext(test_exprstate,
                                             GetPerTupleExprContext(estate),
                                             &isNull);
 
     /* Get back to outer memory context */
     MemoryContextSwitchTo(oldcontext);
 
     /* Release all the junk we just created */
     FreeExecutorState(estate);
 
     if (isNull)
     {
         /* Treat a null result as non-proof ... but it's a tad fishy ... */
         elog(DEBUG2, "null predicate test result");
         return false;
     }
     return DatumGetBool(test_result);
 }

static bool operator_same_subexprs_lookup	(	Oid	pred_op,
		Oid	clause_op,
		bool	refute_it
	)

static

Definition at line 1941 of file predtest.c.

References lookup_proof_cache(), OprProofCacheEntry::same_subexprs_implies, and OprProofCacheEntry::same_subexprs_refutes.

Referenced by operator_same_subexprs_proof().

 {
     OprProofCacheEntry *cache_entry;
 
     cache_entry = lookup_proof_cache(pred_op, clause_op, refute_it);
     if (refute_it)
         return cache_entry->same_subexprs_refutes;
     else
         return cache_entry->same_subexprs_implies;
 }

static bool operator_same_subexprs_proof	(	Oid	pred_op,
		Oid	clause_op,
		bool	refute_it
	)

static

Definition at line 1667 of file predtest.c.

References get_negator(), and operator_same_subexprs_lookup().

Referenced by operator_predicate_proof().

 {
     /*
      * A simple and general rule is that the predicate is proven if clause_op
      * and pred_op are the same, or refuted if they are each other's negators.
      * We need not check immutability since the pred_op is already known
      * immutable.  (Actually, by this point we may have the commutator of a
      * known-immutable pred_op, but that should certainly be immutable too.
      * Likewise we don't worry whether the pred_op's negator is immutable.)
      *
      * Note: the "same" case won't get here if we actually had EXPR1 clause_op
      * EXPR2 and EXPR1 pred_op EXPR2, because the overall-expression-equality
      * test in predicate_implied_by_simple_clause would have caught it.  But
      * we can see the same operator after having commuted the pred_op.
      */
     if (refute_it)
     {
         if (get_negator(pred_op) == clause_op)
             return true;
     }
     else
     {
         if (pred_op == clause_op)
             return true;
     }
 
     /*
      * Otherwise, see if we can determine the implication by finding the
      * operators' relationship via some btree opfamily.
      */
     return operator_same_subexprs_lookup(pred_op, clause_op, refute_it);
 }

static PredClass predicate_classify	(	Node *	clause,
		PredIterInfo	info
	)

static

Definition at line 785 of file predtest.c.

References and_clause(), ScalarArrayOpExpr::args, ARR_DIMS, ARR_NDIM, arrayconst_cleanup_fn(), arrayconst_next_fn(), arrayconst_startup_fn(), arrayexpr_cleanup_fn(), arrayexpr_next_fn(), arrayexpr_startup_fn(), ArrayGetNItems(), Assert, boolexpr_startup_fn(), CLASS_AND, CLASS_ATOM, CLASS_OR, PredIterInfoData::cleanup_fn, DatumGetArrayTypeP, IsA, list_cleanup_fn(), list_length(), list_next_fn(), list_startup_fn(), lsecond, MAX_SAOP_ARRAY_SIZE, PredIterInfoData::next_fn, NULL, or_clause(), PredIterInfoData::startup_fn, and ScalarArrayOpExpr::useOr.

Referenced by predicate_implied_by_recurse(), and predicate_refuted_by_recurse().

 {
     /* Caller should not pass us NULL, nor a RestrictInfo clause */
     Assert(clause != NULL);
     Assert(!IsA(clause, RestrictInfo));
 
     /*
      * If we see a List, assume it's an implicit-AND list; this is the correct
      * semantics for lists of RestrictInfo nodes.
      */
     if (IsA(clause, List))
     {
         info->startup_fn = list_startup_fn;
         info->next_fn = list_next_fn;
         info->cleanup_fn = list_cleanup_fn;
         return CLASS_AND;
     }
 
     /* Handle normal AND and OR boolean clauses */
     if (and_clause(clause))
     {
         info->startup_fn = boolexpr_startup_fn;
         info->next_fn = list_next_fn;
         info->cleanup_fn = list_cleanup_fn;
         return CLASS_AND;
     }
     if (or_clause(clause))
     {
         info->startup_fn = boolexpr_startup_fn;
         info->next_fn = list_next_fn;
         info->cleanup_fn = list_cleanup_fn;
         return CLASS_OR;
     }
 
     /* Handle ScalarArrayOpExpr */
     if (IsA(clause, ScalarArrayOpExpr))
     {
         ScalarArrayOpExpr *saop = (ScalarArrayOpExpr *) clause;
         Node       *arraynode = (Node *) lsecond(saop->args);
 
         /*
          * We can break this down into an AND or OR structure, but only if we
          * know how to iterate through expressions for the array's elements.
          * We can do that if the array operand is a non-null constant or a
          * simple ArrayExpr.
          */
         if (arraynode && IsA(arraynode, Const) &&
             !((Const *) arraynode)->constisnull)
         {
             ArrayType  *arrayval;
             int         nelems;
 
             arrayval = DatumGetArrayTypeP(((Const *) arraynode)->constvalue);
             nelems = ArrayGetNItems(ARR_NDIM(arrayval), ARR_DIMS(arrayval));
             if (nelems <= MAX_SAOP_ARRAY_SIZE)
             {
                 info->startup_fn = arrayconst_startup_fn;
                 info->next_fn = arrayconst_next_fn;
                 info->cleanup_fn = arrayconst_cleanup_fn;
                 return saop->useOr ? CLASS_OR : CLASS_AND;
             }
         }
         else if (arraynode && IsA(arraynode, ArrayExpr) &&
                  !((ArrayExpr *) arraynode)->multidims &&
                  list_length(((ArrayExpr *) arraynode)->elements) <= MAX_SAOP_ARRAY_SIZE)
         {
             info->startup_fn = arrayexpr_startup_fn;
             info->next_fn = arrayexpr_next_fn;
             info->cleanup_fn = arrayexpr_cleanup_fn;
             return saop->useOr ? CLASS_OR : CLASS_AND;
         }
     }
 
     /* None of the above, so it's an atom */
     return CLASS_ATOM;
 }

bool predicate_implied_by	(	List *	predicate_list,
		List *	clause_list,
		bool	clause_is_check
	)

Definition at line 135 of file predtest.c.

References linitial, list_length(), NIL, and predicate_implied_by_recurse().

Referenced by add_predicate_to_quals(), ATExecAttachPartition(), build_paths_for_OR(), check_index_predicates(), choose_bitmap_and(), create_bitmap_scan_plan(), create_bitmap_subplan(), create_indexscan_plan(), gincostestimate(), and infer_arbiter_indexes().

 {
     Node       *p,
                *r;
 
     if (predicate_list == NIL)
         return true;            /* no predicate: implication is vacuous */
     if (clause_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(clause_list) == 1)
         r = (Node *) linitial(clause_list);
     else
         r = (Node *) clause_list;
 
     /* And away we go ... */
     return predicate_implied_by_recurse(r, p, clause_is_check);
 }

static bool predicate_implied_by_recurse	(	Node *	clause,
		Node *	predicate,
		bool	clause_is_check
	)

static

Definition at line 263 of file predtest.c.

References Assert, CLASS_AND, CLASS_ATOM, CLASS_OR, elog, ERROR, IsA, iterate_begin, iterate_end, NULL, predicate_classify(), predicate_implied_by_simple_clause(), and result.

Referenced by predicate_implied_by(), and predicate_refuted_by_recurse().

 {
     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,
                                                           clause_is_check))
                         {
                             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,
                                                          clause_is_check))
                         {
                             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,
                                                          clause_is_check))
                         {
                             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,
                                                          clause_is_check))
                         {
                             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,
                                                              clause_is_check))
                             {
                                 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,
                                                           clause_is_check))
                         {
                             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,
                                                           clause_is_check))
                         {
                             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,
                                                          clause_is_check))
                         {
                             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,
                                                            clause_is_check);
             }
             break;
     }
 
     /* can't get here */
     elog(ERROR, "predicate_classify returned a bogus value");
     return false;
 }

static bool predicate_implied_by_simple_clause	(	Expr *	predicate,
		Node *	clause,
		bool	clause_is_check
	)

static

Definition at line 1077 of file predtest.c.

References generate_unaccent_rules::args, CHECK_FOR_INTERRUPTS, equal(), func_strict(), is_funcclause, IS_NOT_NULL, is_opclause, IsA, list_member_strip(), op_strict(), and operator_predicate_proof().

Referenced by predicate_implied_by_recurse().

 {
     /* Allow interrupting long proof attempts */
     CHECK_FOR_INTERRUPTS();
 
     /* 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;
 
         /* row IS NOT NULL does not act in the simple way we have in mind */
         if (!((NullTest *) predicate)->argisrow && !clause_is_check)
         {
             if (is_opclause(clause) &&
                 list_member_strip(((OpExpr *) clause)->args, nonnullarg) &&
                 op_strict(((OpExpr *) clause)->opno))
                 return true;
             if (is_funcclause(clause) &&
                 list_member_strip(((FuncExpr *) clause)->args, nonnullarg) &&
                 func_strict(((FuncExpr *) clause)->funcid))
                 return true;
             if (equal(clause, nonnullarg))
                 return true;
         }
         return false;           /* we can't succeed below... */
     }
 
     /* Else try operator-related knowledge */
     return operator_predicate_proof(predicate, clause, false);
 }

bool predicate_refuted_by	(	List *	predicate_list,
		List *	clause_list,
		bool	clause_is_check
	)

Definition at line 197 of file predtest.c.

References linitial, list_length(), NIL, and predicate_refuted_by_recurse().

Referenced by relation_excluded_by_constraints().

 {
     Node       *p,
                *r;
 
     if (predicate_list == NIL)
         return false;           /* no predicate: no refutation is possible */
     if (clause_list == NIL)
         return false;           /* no restriction: refutation 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(clause_list) == 1)
         r = (Node *) linitial(clause_list);
     else
         r = (Node *) clause_list;
 
     /* And away we go ... */
     return predicate_refuted_by_recurse(r, p, clause_is_check);
 }

static bool predicate_refuted_by_recurse	(	Node *	clause,
		Node *	predicate,
		bool	clause_is_check
	)

static

Definition at line 503 of file predtest.c.

References Assert, CLASS_AND, CLASS_ATOM, CLASS_OR, elog, equal(), ERROR, extract_not_arg(), extract_strong_not_arg(), IsA, iterate_begin, iterate_end, NULL, predicate_classify(), predicate_implied_by_recurse(), predicate_refuted_by_simple_clause(), and result.

Referenced by predicate_refuted_by().

 {
     PredIterInfoData clause_info;
     PredIterInfoData pred_info;
     PredClass   pclass;
     Node       *not_arg;
     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 R=> AND-clause if A refutes any of B's items
                      *
                      * Needed to handle (x AND y) R=> ((!x OR !y) AND z)
                      */
                     result = false;
                     iterate_begin(pitem, predicate, pred_info)
                     {
                         if (predicate_refuted_by_recurse(clause, pitem,
                                                          clause_is_check))
                         {
                             result = true;
                             break;
                         }
                     }
                     iterate_end(pred_info);
                     if (result)
                         return result;
 
                     /*
                      * Also check if any of A's items refutes B
                      *
                      * Needed to handle ((x OR y) AND z) R=> (!x AND !y)
                      */
                     iterate_begin(citem, clause, clause_info)
                     {
                         if (predicate_refuted_by_recurse(citem, predicate,
                                                          clause_is_check))
                         {
                             result = true;
                             break;
                         }
                     }
                     iterate_end(clause_info);
                     return result;
 
                 case CLASS_OR:
 
                     /*
                      * AND-clause R=> OR-clause if A refutes each of B's items
                      */
                     result = true;
                     iterate_begin(pitem, predicate, pred_info)
                     {
                         if (!predicate_refuted_by_recurse(clause, pitem,
                                                           clause_is_check))
                         {
                             result = false;
                             break;
                         }
                     }
                     iterate_end(pred_info);
                     return result;
 
                 case CLASS_ATOM:
 
                     /*
                      * If B is a NOT-clause, A R=> B if A => B's arg
                      */
                     not_arg = extract_not_arg(predicate);
                     if (not_arg &&
                         predicate_implied_by_recurse(clause, not_arg,
                                                      clause_is_check))
                         return true;
 
                     /*
                      * AND-clause R=> atom if any of A's items refutes B
                      */
                     result = false;
                     iterate_begin(citem, clause, clause_info)
                     {
                         if (predicate_refuted_by_recurse(citem, predicate,
                                                          clause_is_check))
                         {
                             result = true;
                             break;
                         }
                     }
                     iterate_end(clause_info);
                     return result;
             }
             break;
 
         case CLASS_OR:
             switch (pclass)
             {
                 case CLASS_OR:
 
                     /*
                      * OR-clause R=> OR-clause if A refutes each of B's items
                      */
                     result = true;
                     iterate_begin(pitem, predicate, pred_info)
                     {
                         if (!predicate_refuted_by_recurse(clause, pitem,
                                                           clause_is_check))
                         {
                             result = false;
                             break;
                         }
                     }
                     iterate_end(pred_info);
                     return result;
 
                 case CLASS_AND:
 
                     /*
                      * OR-clause R=> AND-clause if each of A's items refutes
                      * any of B's items.
                      */
                     result = true;
                     iterate_begin(citem, clause, clause_info)
                     {
                         bool        presult = false;
 
                         iterate_begin(pitem, predicate, pred_info)
                         {
                             if (predicate_refuted_by_recurse(citem, pitem,
                                                              clause_is_check))
                             {
                                 presult = true;
                                 break;
                             }
                         }
                         iterate_end(pred_info);
                         if (!presult)
                         {
                             result = false; /* citem refutes nothing */
                             break;
                         }
                     }
                     iterate_end(clause_info);
                     return result;
 
                 case CLASS_ATOM:
 
                     /*
                      * If B is a NOT-clause, A R=> B if A => B's arg
                      */
                     not_arg = extract_not_arg(predicate);
                     if (not_arg &&
                         predicate_implied_by_recurse(clause, not_arg,
                                                      clause_is_check))
                         return true;
 
                     /*
                      * OR-clause R=> atom if each of A's items refutes B
                      */
                     result = true;
                     iterate_begin(citem, clause, clause_info)
                     {
                         if (!predicate_refuted_by_recurse(citem, predicate,
                                                           clause_is_check))
                         {
                             result = false;
                             break;
                         }
                     }
                     iterate_end(clause_info);
                     return result;
             }
             break;
 
         case CLASS_ATOM:
 
             /*
              * If A is a strong NOT-clause, A R=> B if B equals A's arg
              *
              * We cannot make the stronger conclusion that B is refuted if B
              * implies A's arg; that would only prove that B is not-TRUE, not
              * that it's not NULL either.  Hence use equal() rather than
              * predicate_implied_by_recurse().  We could do the latter if we
              * ever had a need for the weak form of refutation.
              */
             not_arg = extract_strong_not_arg(clause);
             if (not_arg && equal(predicate, not_arg))
                 return true;
 
             switch (pclass)
             {
                 case CLASS_AND:
 
                     /*
                      * atom R=> AND-clause if A refutes any of B's items
                      */
                     result = false;
                     iterate_begin(pitem, predicate, pred_info)
                     {
                         if (predicate_refuted_by_recurse(clause, pitem,
                                                          clause_is_check))
                         {
                             result = true;
                             break;
                         }
                     }
                     iterate_end(pred_info);
                     return result;
 
                 case CLASS_OR:
 
                     /*
                      * atom R=> OR-clause if A refutes each of B's items
                      */
                     result = true;
                     iterate_begin(pitem, predicate, pred_info)
                     {
                         if (!predicate_refuted_by_recurse(clause, pitem,
                                                           clause_is_check))
                         {
                             result = false;
                             break;
                         }
                     }
                     iterate_end(pred_info);
                     return result;
 
                 case CLASS_ATOM:
 
                     /*
                      * If B is a NOT-clause, A R=> B if A => B's arg
                      */
                     not_arg = extract_not_arg(predicate);
                     if (not_arg &&
                         predicate_implied_by_recurse(clause, not_arg,
                                                      clause_is_check))
                         return true;
 
                     /*
                      * atom R=> atom is the base case
                      */
                     return
                         predicate_refuted_by_simple_clause((Expr *) predicate,
                                                            clause,
                                                            clause_is_check);
             }
             break;
     }
 
     /* can't get here */
     elog(ERROR, "predicate_classify returned a bogus value");
     return false;
 }

static bool predicate_refuted_by_simple_clause	(	Expr *	predicate,
		Node *	clause,
		bool	clause_is_check
	)

static

Definition at line 1139 of file predtest.c.

References arg, generate_unaccent_rules::args, CHECK_FOR_INTERRUPTS, equal(), func_strict(), is_funcclause, IS_NOT_NULL, IS_NULL, is_opclause, IsA, list_member_strip(), op_strict(), and operator_predicate_proof().

Referenced by predicate_refuted_by_recurse().

 {
     /* Allow interrupting long proof attempts */
     CHECK_FOR_INTERRUPTS();
 
     /* A simple clause can't refute itself */
     /* Worth checking because of relation_excluded_by_constraints() */
     if ((Node *) predicate == clause)
         return false;
 
     /* Try the predicate-IS-NULL case */
     if (predicate && IsA(predicate, NullTest) &&
         ((NullTest *) predicate)->nulltesttype == IS_NULL)
     {
         Expr       *isnullarg = ((NullTest *) predicate)->arg;
 
         if (clause_is_check)
             return false;
 
         /* row IS NULL does not act in the simple way we have in mind */
         if (((NullTest *) predicate)->argisrow)
             return false;
 
         /* Any strict op/func on foo refutes foo IS NULL */
         if (is_opclause(clause) &&
             list_member_strip(((OpExpr *) clause)->args, isnullarg) &&
             op_strict(((OpExpr *) clause)->opno))
             return true;
         if (is_funcclause(clause) &&
             list_member_strip(((FuncExpr *) clause)->args, isnullarg) &&
             func_strict(((FuncExpr *) clause)->funcid))
             return true;
 
         /* foo IS NOT NULL refutes foo IS NULL */
         if (clause && IsA(clause, NullTest) &&
             ((NullTest *) clause)->nulltesttype == IS_NOT_NULL &&
             !((NullTest *) clause)->argisrow &&
             equal(((NullTest *) clause)->arg, isnullarg))
             return true;
 
         return false;           /* we can't succeed below... */
     }
 
     /* Try the clause-IS-NULL case */
     if (clause && IsA(clause, NullTest) &&
         ((NullTest *) clause)->nulltesttype == IS_NULL)
     {
         Expr       *isnullarg = ((NullTest *) clause)->arg;
 
         /* row IS NULL does not act in the simple way we have in mind */
         if (((NullTest *) clause)->argisrow)
             return false;
 
         /* foo IS NULL refutes foo IS NOT NULL */
         if (predicate && IsA(predicate, NullTest) &&
             ((NullTest *) predicate)->nulltesttype == IS_NOT_NULL &&
             !((NullTest *) predicate)->argisrow &&
             equal(((NullTest *) predicate)->arg, isnullarg))
             return true;
 
         return false;           /* we can't succeed below... */
     }
 
     /* Else try operator-related knowledge */
     return operator_predicate_proof(predicate, clause, true);
 }

Variable Documentation

const StrategyNumber BT_implic_table[6][6]

static

Initial value:

= {
    {BTGE, BTGE, none, none, none, BTGE},   
    {BTGT, BTGE, none, none, none, BTGT},   
    {BTGT, BTGE, BTEQ, BTLE, BTLT, BTNE},   
    {none, none, none, BTLE, BTLT, BTLT},   
    {none, none, none, BTLE, BTLE, BTLE},   
    {none, none, none, none, none, BTEQ}    
}

Definition at line 1384 of file predtest.c.

Referenced by lookup_proof_cache().

const bool BT_implies_table[6][6]

static

Initial value:

= {
    {TRUE, TRUE, none, none, none, TRUE},   
    {none, TRUE, none, none, none, none},   
    {none, TRUE, TRUE, TRUE, none, none},   
    {none, none, none, TRUE, none, none},   
    {none, none, none, TRUE, TRUE, TRUE},   
    {none, none, none, none, none, TRUE}    
}

Definition at line 1358 of file predtest.c.

Referenced by lookup_proof_cache().

const StrategyNumber BT_refute_table[6][6]

static

Initial value:

= {
    {none, none, BTGE, BTGE, BTGE, none},   
    {none, none, BTGT, BTGT, BTGE, none},   
    {BTLE, BTLT, BTNE, BTGT, BTGE, BTEQ},   
    {BTLE, BTLT, BTLT, none, none, none},   
    {BTLE, BTLE, BTLE, none, none, none},   
    {none, none, BTEQ, none, none, none}    
}

Definition at line 1397 of file predtest.c.

Referenced by lookup_proof_cache().

const bool BT_refutes_table[6][6]

static

Initial value:

= {
    {none, none, TRUE, TRUE, TRUE, none},   
    {none, none, none, none, TRUE, none},   
    {TRUE, none, none, none, TRUE, TRUE},   
    {TRUE, none, none, none, none, none},   
    {TRUE, TRUE, TRUE, none, none, none},   
    {none, none, TRUE, none, none, none}    
}

Definition at line 1371 of file predtest.c.

Referenced by lookup_proof_cache().

HTAB* OprProofCacheHash = NULL

static

Definition at line 1728 of file predtest.c.

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation