40#define MAX_SAOP_ARRAY_SIZE 100
72#define iterate_begin(item, clause, info) \
75 (info).startup_fn((clause), &(info)); \
76 while ((item = (info).next_fn(&(info))) != NULL)
78#define iterate_end(info) \
79 (info).cleanup_fn(&(info)); \
106 bool refute_it,
bool weak);
158 if (predicate_list ==
NIL)
160 if (clause_list ==
NIL)
172 p = (
Node *) predicate_list;
176 c = (
Node *) clause_list;
228 if (predicate_list ==
NIL)
230 if (clause_list ==
NIL)
242 p = (
Node *) predicate_list;
246 c = (
Node *) clause_list;
398 bool presult =
false;
495 elog(
ERROR,
"predicate_classify returned a bogus value");
674 bool presult =
false;
806 elog(
ERROR,
"predicate_classify returned a bogus value");
872 if (arraynode &&
IsA(arraynode,
Const) &&
873 !((
Const *) arraynode)->constisnull)
977 &elmlen, &elmbyval, &elmalign);
980 elmlen, elmbyval, elmalign,
985 state->opexpr.xpr.type = T_OpExpr;
987 state->opexpr.opfuncid = saop->opfuncid;
988 state->opexpr.opresulttype = BOOLOID;
989 state->opexpr.opretset =
false;
991 state->opexpr.inputcollid = saop->inputcollid;
995 state->const_expr.xpr.type = T_Const;
997 state->const_expr.consttypmod = -1;
998 state->const_expr.constcollid = arrayconst->constcollid;
999 state->const_expr.constlen = elmlen;
1000 state->const_expr.constbyval = elmbyval;
1004 state->next_elem = 0;
1053 state->opexpr.xpr.type = T_OpExpr;
1055 state->opexpr.opfuncid = saop->opfuncid;
1056 state->opexpr.opresulttype = BOOLOID;
1057 state->opexpr.opretset =
false;
1059 state->opexpr.inputcollid = saop->inputcollid;
1134 if (op->
opno == BooleanEqualOperator)
1141 if (rightop &&
IsA(rightop,
Const) &&
1142 !((
Const *) rightop)->constisnull)
1149 if (
equal(predicate, leftop))
1191 !predntest->argisrow &&
1239 if ((
Node *) predicate == clause)
1250 if (clausentest->argisrow)
1267 if (predntest->argisrow)
1316 if (predntest->argisrow)
1333 if (clausentest->argisrow)
1465 if (clause == NULL || subexpr == NULL)
1480 if (
equal(clause, subexpr))
1491 foreach(lc, ((
OpExpr *) clause)->args)
1501 foreach(lc, ((
FuncExpr *) clause)->args)
1554 if (allow_false && saop->
useOr)
1557 if (arraynode &&
IsA(arraynode,
Const))
1566 if (arrayconst->constisnull)
1601 return ((
Const *) clause)->constisnull;
1662#define BTLT BTLessStrategyNumber
1663#define BTLE BTLessEqualStrategyNumber
1664#define BTEQ BTEqualStrategyNumber
1665#define BTGE BTGreaterEqualStrategyNumber
1666#define BTGT BTGreaterStrategyNumber
1667#define BTNE COMPARE_NE
1780 bool refute_it,
bool weak)
1812 pred_opexpr = (
OpExpr *) predicate;
1817 clause_opexpr = (
OpExpr *) clause;
1825 pred_collation = pred_opexpr->inputcollid;
1826 clause_collation = clause_opexpr->inputcollid;
1827 if (pred_collation != clause_collation)
1831 pred_op = pred_opexpr->
opno;
1832 clause_op = clause_opexpr->
opno;
1842 if (
equal(pred_leftop, clause_leftop))
1844 if (
equal(pred_rightop, clause_rightop))
1852 if (pred_rightop == NULL || !
IsA(pred_rightop,
Const))
1854 pred_const = (
Const *) pred_rightop;
1855 if (clause_rightop == NULL || !
IsA(clause_rightop,
Const))
1857 clause_const = (
Const *) clause_rightop;
1860 else if (
equal(pred_rightop, clause_rightop))
1863 if (pred_leftop == NULL || !
IsA(pred_leftop,
Const))
1865 pred_const = (
Const *) pred_leftop;
1866 if (clause_leftop == NULL || !
IsA(clause_leftop,
Const))
1868 clause_const = (
Const *) clause_leftop;
1877 else if (
equal(pred_leftop, clause_rightop))
1879 if (
equal(pred_rightop, clause_leftop))
1891 if (pred_rightop == NULL || !
IsA(pred_rightop,
Const))
1893 pred_const = (
Const *) pred_rightop;
1894 if (clause_leftop == NULL || !
IsA(clause_leftop,
Const))
1896 clause_const = (
Const *) clause_leftop;
1903 else if (
equal(pred_rightop, clause_leftop))
1906 if (pred_leftop == NULL || !
IsA(pred_leftop,
Const))
1908 pred_const = (
Const *) pred_leftop;
1909 if (clause_rightop == NULL || !
IsA(clause_rightop,
Const))
1911 clause_const = (
Const *) clause_rightop;
1930 if (clause_const->constisnull)
1942 if (!(weak && !refute_it))
1950 if (pred_const->constisnull &&
op_strict(pred_op))
1955 if (pred_const->constisnull)
1992 (
Expr *) pred_const,
1993 (
Expr *) clause_const,
2054 if (pred_op == clause_op)
2106 bool same_subexprs =
false;
2109 List *pred_op_infos,
2133 key.pred_op = pred_op;
2134 key.clause_op = clause_op;
2169 if (clause_op_infos)
2172 pred_op_infos =
NIL;
2174 foreach(lcp, pred_op_infos)
2179 foreach(lcc, clause_op_infos)
2192 pred_strategy = pred_op_info->
strategy;
2193 clause_strategy = clause_op_info->
strategy;
2208 test_strategy =
BT_refute_table[clause_strategy - 1][pred_strategy - 1];
2210 test_strategy =
BT_implic_table[clause_strategy - 1][pred_strategy - 1];
2212 if (test_strategy == 0)
2222 if (test_strategy ==
BTNE)
2251 if (
op_volatile(test_op) == PROVOLATILE_IMMUTABLE)
2278 if (same_subexprs &&
2280 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 Assert(condition)
#define OidIsValid(objectId)
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
void * hash_seq_search(HASH_SEQ_STATUS *status)
HTAB * hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
bool equal(const void *a, const void *b)
ExprState * ExecInitExpr(Expr *node, PlanState *parent)
void FreeExecutorState(EState *estate)
EState * CreateExecutorState(void)
#define GetPerTupleExprContext(estate)
static Datum ExecEvalExprSwitchContext(ExprState *state, ExprContext *econtext, bool *isNull)
void CacheRegisterSyscacheCallback(int cacheid, SyscacheCallbackFunction func, Datum arg)
if(TABLE==NULL||TABLE_index==NULL)
List * list_copy(const List *oldlist)
void list_free(List *list)
void list_free_deep(List *list)
List * get_op_btree_interpretation(Oid opno)
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)
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)
static bool is_notclause(const void *clause)
static Expr * get_notclausearg(const void *notclause)
#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 bool DatumGetBool(Datum X)
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 OprProofCacheEntry * lookup_proof_cache(Oid pred_op, Oid clause_op, bool refute_it)
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 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)