void
test__opexpr_to_pxffilter__null(void **state)
{
PxfFilterDesc *filter = (PxfFilterDesc*) palloc0(sizeof(PxfFilterDesc));
OpExpr *expr = (OpExpr*) palloc0(sizeof(OpExpr));
assert_false(opexpr_to_pxffilter(NULL, NULL));
assert_false(opexpr_to_pxffilter(NULL, filter));
assert_false(opexpr_to_pxffilter(expr, NULL));
expr->args = NIL;
assert_false(opexpr_to_pxffilter(expr, filter));
pfree(filter);
pfree(expr);
}
/*
* pxf_make_filter_list
*
* Given a scan node qual list, find the filters that are eligible to be used
* by PXF, construct a PxfFilterDesc list that describes the filter information,
* and return it to the caller.
*
* Caller is responsible for pfreeing the returned PxfFilterDesc List.
*/
static List *
pxf_make_filter_list(List *quals)
{
List *result = NIL;
ListCell *lc = NULL;
if (list_length(quals) == 0)
return NIL;
/*
* Iterate over all implicitly ANDed qualifiers and add the ones
* that are supported for push-down into the result filter list.
*/
foreach (lc, quals)
{
Node *node = (Node *) lfirst(lc);
NodeTag tag = nodeTag(node);
switch (tag)
{
case T_OpExpr:
{
OpExpr *expr = (OpExpr *) node;
PxfFilterDesc *filter;
filter = (PxfFilterDesc *) palloc0(sizeof(PxfFilterDesc));
elog(DEBUG5, "pxf_make_filter_list: node tag %d (T_OpExpr)", tag);
if (opexpr_to_pxffilter(expr, filter))
result = lappend(result, filter);
else
pfree(filter);
break;
}
case T_BoolExpr:
{
BoolExpr *expr = (BoolExpr *) node;
BoolExprType boolType = expr->boolop;
elog(DEBUG5, "pxf_make_filter_list: node tag %d (T_BoolExpr), bool node type %d %s",
tag, boolType, boolType==AND_EXPR ? "(AND_EXPR)" : "");
/* only AND_EXPR is supported */
if (expr->boolop == AND_EXPR)
{
List *inner_result = pxf_make_filter_list(expr->args);
elog(DEBUG5, "pxf_make_filter_list: inner result size %d", list_length(inner_result));
result = list_concat(result, inner_result);
}
break;
}
default:
/* expression not supported. ignore */
elog(DEBUG5, "pxf_make_filter_list: unsupported node tag %d", tag);
break;
}
}
void
test__opexpr_to_pxffilter__unary_expr(void **state)
{
PxfFilterDesc *filter = (PxfFilterDesc*) palloc0(sizeof(PxfFilterDesc));
OpExpr *expr = (OpExpr*) palloc0(sizeof(OpExpr));
Var *arg = (Var*) palloc0(sizeof(Var));
arg->xpr.type = T_Var;
assert_false(opexpr_to_pxffilter(NULL, NULL));
assert_false(opexpr_to_pxffilter(NULL, filter));
assert_false(opexpr_to_pxffilter(expr, NULL));
expr->args = NIL;
expr->args = lappend(expr->args, arg);
assert_false(opexpr_to_pxffilter(expr, filter));
pfree(arg);
pfree(filter);
pfree(expr);
}
void
test__opexpr_to_pxffilter__twoVars(void **state)
{
PxfFilterDesc *filter = (PxfFilterDesc*) palloc0(sizeof(PxfFilterDesc));
Var *arg_var_left = build_var(INT4OID, 8);
Var *arg_var_right = build_var(INT4OID, 9);
OpExpr *expr = build_op_expr(arg_var_left, arg_var_right, 0 /* whatever */);
/* run test */
assert_false(opexpr_to_pxffilter(expr, filter));
pxf_free_filter(filter);
list_free_deep(expr->args); /* free all args */
pfree(expr);
}
void
test__opexpr_to_pxffilter__unsupportedTypeCircle(void **state)
{
PxfFilterDesc *filter = (PxfFilterDesc*) palloc0(sizeof(PxfFilterDesc));
Var *arg_var = build_var(CIRCLEOID, 8);
Const *arg_const = build_const(CIRCLEOID, NULL);
OpExpr *expr = build_op_expr(arg_const, arg_var, 0 /* whatever */);
/* run test */
assert_false(opexpr_to_pxffilter(expr, filter));
pxf_free_filter(filter);
list_free_deep(expr->args); /* free all args */
pfree(expr);
}
void
test__opexpr_to_pxffilter__unsupportedOpNot(void **state)
{
PxfFilterDesc *filter = (PxfFilterDesc*) palloc0(sizeof(PxfFilterDesc));
Var *arg_var = build_var(INT2OID, 3);
char* const_value = strdup("not"); /* will be free'd by const_to_str */
Const *arg_const = build_const(INT2OID, const_value);
OpExpr *expr = build_op_expr(arg_const, arg_var, 1877 /* int2not */);
/* run test */
assert_false(opexpr_to_pxffilter(expr, filter));
pxf_free_filter(filter);
list_free_deep(expr->args); /* free all args */
pfree(expr);
}
/*
* Test for a query with different types.
* Types pairing are not checked, it is covered by the
* supported operations which are type specific.
*/
void
test__opexpr_to_pxffilter__differentTypes(void **state)
{
PxfFilterDesc *filter = (PxfFilterDesc*) palloc0(sizeof(PxfFilterDesc));
Var *arg_var = build_var(INT2OID, 3);
char* const_value = strdup("13"); /* will be free'd by const_to_str */
Const *arg_const = build_const(INT8OID, const_value);
OpExpr *expr = build_op_expr(arg_const, arg_var, 1864 /* int28lt */);
/* run test */
assert_true(opexpr_to_pxffilter(expr, filter));
PxfFilterDesc *expected = build_filter(
PXF_CONST_CODE, 0, "13",
PXF_ATTR_CODE, 3, NULL,
PXFOP_LT);
compare_filters(filter, expected);
pxf_free_filter(filter);
list_free_deep(expr->args); /* free all args */
pfree(expr);
}
/* NOTE: this test is not a use case - when the query includes
* 'is null' or 'is not null' the qualifier code is T_NullTest and not T_OpExpr */
void
test__opexpr_to_pxffilter__attributeIsNull(void **state)
{
PxfFilterDesc *filter = (PxfFilterDesc*) palloc0(sizeof(PxfFilterDesc));
Var *arg_var = build_var(INT2OID, 1);
Const* arg_const = build_const(INT2OID, NULL);
OpExpr *expr = build_op_expr(arg_var, arg_const, 94 /* int2eq */);
PxfFilterDesc* expected = build_filter(
PXF_ATTR_CODE, 1, NULL,
PXF_CONST_CODE, 0, "\"NULL\"",
PXFOP_EQ);
/* run test */
assert_true(opexpr_to_pxffilter(expr, filter));
compare_filters(filter, expected);
pxf_free_filter(filter);
pxf_free_filter(expected);
list_free_deep(expr->args); /* free all args */
pfree(expr);
}
void run__opexpr_to_pxffilter__positive(Oid dbop, PxfOperatorCode expectedPxfOp)
{
PxfFilterDesc *filter = (PxfFilterDesc*) palloc0(sizeof(PxfFilterDesc));
Var *arg_var = build_var(INT2OID, 1);
char* const_value = strdup("1984"); /* will be free'd by const_to_str */
Const* arg_const = build_const(INT2OID, const_value);
OpExpr *expr = build_op_expr(arg_var, arg_const, dbop);
PxfFilterDesc* expected = build_filter(
PXF_ATTR_CODE, 1, NULL,
PXF_CONST_CODE, 0, "1984",
expectedPxfOp);
/* run test */
assert_true(opexpr_to_pxffilter(expr, filter));
compare_filters(filter, expected);
pxf_free_filter(expected);
pxf_free_filter(filter);
list_free_deep(expr->args); /* free all args */
pfree(expr);
}
