39 #define MAX_SAOP_ARRAY_SIZE 100
71 #define iterate_begin(item, clause, info) \
74 (info).startup_fn((clause), &(info)); \
75 while ((item = (info).next_fn(&(info))) != NULL)
77 #define iterate_end(info) \
78 (info).cleanup_fn(&(info)); \
105 bool refute_it,
bool weak);
157 if (predicate_list ==
NIL)
159 if (clause_list ==
NIL)
171 p = (
Node *) predicate_list;
175 c = (
Node *) clause_list;
227 if (predicate_list ==
NIL)
229 if (clause_list ==
NIL)
241 p = (
Node *) predicate_list;
245 c = (
Node *) clause_list;
397 bool presult =
false;
494 elog(
ERROR,
"predicate_classify returned a bogus value");
673 bool presult =
false;
805 elog(
ERROR,
"predicate_classify returned a bogus value");
871 if (arraynode &&
IsA(arraynode,
Const) &&
872 !((
Const *) arraynode)->constisnull)
976 &elmlen, &elmbyval, &elmalign);
979 elmlen, elmbyval, elmalign,
987 state->opexpr.opresulttype = BOOLOID;
988 state->opexpr.opretset =
false;
996 state->constexpr.consttypmod = -1;
998 state->constexpr.constlen = elmlen;
999 state->constexpr.constbyval = elmbyval;
1003 state->next_elem = 0;
1055 state->opexpr.opresulttype = BOOLOID;
1056 state->opexpr.opretset =
false;
1187 if ((
Node *) predicate == clause)
1197 if (((
NullTest *) predicate)->argisrow)
1207 !((
NullTest *) clause)->argisrow &&
1221 if (((
NullTest *) clause)->argisrow)
1227 !((
NullTest *) predicate)->argisrow &&
1328 if (clause == NULL || subexpr == NULL)
1343 if (
equal(clause, subexpr))
1354 foreach(lc, ((
OpExpr *) clause)->args)
1364 foreach(lc, ((
FuncExpr *) clause)->args)
1417 if (allow_false && saop->
useOr)
1420 if (arraynode &&
IsA(arraynode,
Const))
1464 return ((
Const *) clause)->constisnull;
1525 #define BTLT BTLessStrategyNumber
1526 #define BTLE BTLessEqualStrategyNumber
1527 #define BTEQ BTEqualStrategyNumber
1528 #define BTGE BTGreaterEqualStrategyNumber
1529 #define BTGT BTGreaterStrategyNumber
1530 #define BTNE ROWCOMPARE_NE
1643 bool refute_it,
bool weak)
1675 pred_opexpr = (
OpExpr *) predicate;
1680 clause_opexpr = (
OpExpr *) clause;
1690 if (pred_collation != clause_collation)
1694 pred_op = pred_opexpr->
opno;
1695 clause_op = clause_opexpr->
opno;
1705 if (
equal(pred_leftop, clause_leftop))
1707 if (
equal(pred_rightop, clause_rightop))
1715 if (pred_rightop == NULL || !
IsA(pred_rightop,
Const))
1717 pred_const = (
Const *) pred_rightop;
1718 if (clause_rightop == NULL || !
IsA(clause_rightop,
Const))
1720 clause_const = (
Const *) clause_rightop;
1723 else if (
equal(pred_rightop, clause_rightop))
1726 if (pred_leftop == NULL || !
IsA(pred_leftop,
Const))
1728 pred_const = (
Const *) pred_leftop;
1729 if (clause_leftop == NULL || !
IsA(clause_leftop,
Const))
1731 clause_const = (
Const *) clause_leftop;
1740 else if (
equal(pred_leftop, clause_rightop))
1742 if (
equal(pred_rightop, clause_leftop))
1754 if (pred_rightop == NULL || !
IsA(pred_rightop,
Const))
1756 pred_const = (
Const *) pred_rightop;
1757 if (clause_leftop == NULL || !
IsA(clause_leftop,
Const))
1759 clause_const = (
Const *) clause_leftop;
1766 else if (
equal(pred_rightop, clause_leftop))
1769 if (pred_leftop == NULL || !
IsA(pred_leftop,
Const))
1771 pred_const = (
Const *) pred_leftop;
1772 if (clause_rightop == NULL || !
IsA(clause_rightop,
Const))
1774 clause_const = (
Const *) clause_rightop;
1805 if (!(weak && !refute_it))
1855 (
Expr *) pred_const,
1856 (
Expr *) clause_const,
1917 if (pred_op == clause_op)
1969 bool same_subexprs =
false;
1972 List *pred_op_infos,
1996 key.pred_op = pred_op;
1997 key.clause_op = clause_op;
2032 if (clause_op_infos)
2035 pred_op_infos =
NIL;
2037 foreach(lcp, pred_op_infos)
2042 foreach(lcc, clause_op_infos)
2055 pred_strategy = pred_op_info->
strategy;
2056 clause_strategy = clause_op_info->
strategy;
2071 test_strategy =
BT_refute_table[clause_strategy - 1][pred_strategy - 1];
2073 test_strategy =
BT_implic_table[clause_strategy - 1][pred_strategy - 1];
2075 if (test_strategy == 0)
2085 if (test_strategy ==
BTNE)
2114 if (
op_volatile(test_op) == PROVOLATILE_IMMUTABLE)
2141 if (same_subexprs &&
2143 same_subexprs =
false;
#define DatumGetArrayTypeP(X)
void deconstruct_array(ArrayType *array, Oid elmtype, int elmlen, bool elmbyval, char elmalign, Datum **elemsp, bool **nullsp, int *nelemsp)
int ArrayGetNItems(int ndim, const int *dims)
#define OidIsValid(objectId)
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
HTAB * hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
void * hash_seq_search(HASH_SEQ_STATUS *status)
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
bool equal(const void *a, const void *b)
ExprState * ExecInitExpr(Expr *node, PlanState *parent)
EState * CreateExecutorState(void)
void FreeExecutorState(EState *estate)
#define GetPerTupleExprContext(estate)
static Datum ExecEvalExprSwitchContext(ExprState *state, ExprContext *econtext, bool *isNull)
void CacheRegisterSyscacheCallback(int cacheid, SyscacheCallbackFunction func, Datum arg)
Assert(fmt[strlen(fmt) - 1] !='\n')
List * list_copy(const List *oldlist)
void list_free(List *list)
void list_free_deep(List *list)
void get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval, char *typalign)
Oid get_opfamily_member(Oid opfamily, Oid lefttype, Oid righttype, int16 strategy)
bool func_strict(Oid funcid)
List * get_op_btree_interpretation(Oid opno)
char op_volatile(Oid opno)
Oid get_negator(Oid opno)
Oid get_commutator(Oid opno)
Expr * make_opclause(Oid opno, Oid opresulttype, bool opretset, Expr *leftop, Expr *rightop, Oid opcollid, Oid inputcollid)
void pfree(void *pointer)
#define CHECK_FOR_INTERRUPTS()
void fix_opfuncids(Node *node)
static bool is_andclause(const void *clause)
static bool is_orclause(const void *clause)
static bool is_opclause(const void *clause)
static bool is_funcclause(const void *clause)
#define IsA(nodeptr, _type_)
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
static int list_length(const List *l)
static ListCell * list_head(const List *l)
static ListCell * lnext(const List *l, const ListCell *c)
static void static void status(const char *fmt,...) pg_attribute_printf(1
static bool predicate_refuted_by_simple_clause(Expr *predicate, Node *clause, bool weak)
static Node * arrayconst_next_fn(PredIterInfo info)
struct PredIterInfoData * PredIterInfo
static Node * arrayexpr_next_fn(PredIterInfo info)
bool predicate_refuted_by(List *predicate_list, List *clause_list, bool weak)
static bool operator_same_subexprs_proof(Oid pred_op, Oid clause_op, bool refute_it)
static const StrategyNumber BT_refute_table[6][6]
static HTAB * OprProofCacheHash
#define iterate_end(info)
static void InvalidateOprProofCacheCallBack(Datum arg, int cacheid, uint32 hashvalue)
static bool predicate_implied_by_recurse(Node *clause, Node *predicate, bool weak)
static void arrayexpr_startup_fn(Node *clause, PredIterInfo info)
struct OprProofCacheEntry OprProofCacheEntry
static Node * extract_strong_not_arg(Node *clause)
static bool predicate_implied_by_simple_clause(Expr *predicate, Node *clause, bool weak)
static const bool BT_refutes_table[6][6]
static Node * extract_not_arg(Node *clause)
static PredClass predicate_classify(Node *clause, PredIterInfo info)
static bool predicate_refuted_by_recurse(Node *clause, Node *predicate, bool weak)
static bool clause_is_strict_for(Node *clause, Node *subexpr, bool allow_false)
static bool operator_predicate_proof(Expr *predicate, Node *clause, bool refute_it, bool weak)
bool predicate_implied_by(List *predicate_list, List *clause_list, bool weak)
static void boolexpr_startup_fn(Node *clause, PredIterInfo info)
static void arrayconst_startup_fn(Node *clause, PredIterInfo info)
#define MAX_SAOP_ARRAY_SIZE
static void list_cleanup_fn(PredIterInfo info)
static const bool BT_implies_table[6][6]
struct PredIterInfoData PredIterInfoData
struct OprProofCacheKey OprProofCacheKey
static Node * list_next_fn(PredIterInfo info)
static void arrayconst_cleanup_fn(PredIterInfo info)
static Oid get_btree_test_op(Oid pred_op, Oid clause_op, bool refute_it)
static OprProofCacheEntry * lookup_proof_cache(Oid pred_op, Oid clause_op, bool refute_it)
static const StrategyNumber BT_implic_table[6][6]
#define iterate_begin(item, clause, info)
static void list_startup_fn(Node *clause, PredIterInfo info)
static void arrayexpr_cleanup_fn(PredIterInfo info)
static bool operator_same_subexprs_lookup(Oid pred_op, Oid clause_op, bool refute_it)
#define BTEqualStrategyNumber
BoolTestType booltesttype
MemoryContext es_query_cxt
NullTestType nulltesttype
bool same_subexprs_refutes
bool same_subexprs_implies
void(* startup_fn)(Node *clause, PredIterInfo info)
void(* cleanup_fn)(PredIterInfo info)
Node *(* next_fn)(PredIterInfo info)