def test_case_sensitive_int_not_eq_rewritten(inc_man_spec, inc_man_file, val,
expected):
with pytest.raises(ValidationException):
assert InclusiveManifestEvaluator(
inc_man_spec,
Expressions.not_(Expressions.equal("ID", val)),
case_sensitive=True).eval(inc_man_file) == expected
def test_basic_simplification(assert_and_unwrap):
# Should simplify or expression to alwaysTrue
assert Expressions.always_true() == Binder.bind(
STRUCT,
Expressions.or_(Expressions.less_than("y", 100),
Expressions.greater_than("z", -9999999999)))
# Should simplify or expression to alwaysfalse
assert Expressions.always_false() == Binder.bind(
STRUCT,
Expressions.and_(Expressions.less_than("y", 100),
Expressions.less_than("z", -9999999999)))
bound = Binder.bind(
STRUCT,
Expressions.not_(Expressions.not_(Expressions.less_than("y", 100))))
pred = assert_and_unwrap(bound, None)
assert 1 == pred.ref.field_id
def test_not_eq_rewritten(strict_schema, strict_file):
assert StrictMetricsEvaluator(strict_schema, Expressions.not_(Expressions.equal("id", 5))).eval(strict_file)
assert StrictMetricsEvaluator(strict_schema, Expressions.not_(Expressions.equal("id", 29))).eval(strict_file)
assert not StrictMetricsEvaluator(strict_schema, Expressions.not_(Expressions.equal("id", 30))).eval(strict_file)
assert not StrictMetricsEvaluator(strict_schema, Expressions.not_(Expressions.equal("id", 75))).eval(strict_file)
assert not StrictMetricsEvaluator(strict_schema, Expressions.not_(Expressions.equal("id", 79))).eval(strict_file)
assert StrictMetricsEvaluator(strict_schema, Expressions.not_(Expressions.equal("id", 80))).eval(strict_file)
assert StrictMetricsEvaluator(strict_schema, Expressions.not_(Expressions.equal("id", 85))).eval(strict_file)
def test_not(assert_all_bound, assert_and_unwrap):
expr = Expressions.not_(Expressions.equal("x", 7))
bound_expr = Binder.bind(STRUCT, expr)
assert_all_bound("Not", bound_expr)
not_ = assert_and_unwrap(bound_expr, Not)
child = assert_and_unwrap(not_.child, None)
# should bind x correctly
assert 0 == child.ref.field_id
def test_not():
expected_expr = Expressions.not_("col_a")
conv_expr = Expressions.convert_string_to_expr("not col_a")
assert expected_expr == conv_expr
def test_compound_not_equal():
expected_expr = Expressions.not_(Expressions.equal("col_a", 7))
conv_expr = Expressions.convert_string_to_expr("not (col_a = 7)")
assert expected_expr == conv_expr
def test_not_conversion():
expr = Expressions.not_(Expressions.greater_than('a', 1))
translated_dataset_filter = get_dataset_filter(expr, {'a': 'a'})
assert (~(ds.field("a") > 1)).equals(translated_dataset_filter)
def test_case_insensitive_int_not_eq_rewritten(schema, file, not_eq_uc):
assert InclusiveMetricsEvaluator(schema,
Expressions.not_(not_eq_uc),
case_sensitive=False).eval(file)
def test_case_insensitive_reference(assert_all_bound):
expr = Expressions.not_(Expressions.equal("X", 7))
assert_all_bound("Single reference",
Binder.bind(STRUCT, expr, case_sensitive=False))
yield request.param
@pytest.fixture(scope="session",
params=[
Expressions.always_false(),
Expressions.always_true(),
Expressions.less_than("x", 5),
Expressions.less_than_or_equal("y", -3),
Expressions.greater_than("z", 0),
Expressions.greater_than_or_equal("t", 129),
Expressions.equal("col", "data"),
Expressions.not_equal("col", "abc"),
Expressions.not_null("maybeNull"),
Expressions.is_null("maybeNull2"),
Expressions.not_(Expressions.greater_than("a", 10)),
Expressions.and_(Expressions.greater_than_or_equal("a", 0),
Expressions.less_than("a", 3)),
Expressions.or_(Expressions.less_than("a", 0),
Expressions.greater_than("a", 10)),
Expressions.equal("a", 5).bind(exp_schema.as_struct())
])
def expression(request):
yield request.param
@pytest.fixture(scope="session",
params=[
Expressions.less_than("no_stats", 5),
Expressions.less_than_or_equal("no_stats", 30),
Expressions.equal("no_stats", 70),
def test_not(inc_man_spec, inc_man_file, expression, expected):
assert InclusiveManifestEvaluator(inc_man_spec, Expressions.not_(expression)).eval(inc_man_file) == expected
def test_case_insensitive_int_not_eq_rewritten(inc_man_spec, inc_man_file, val, expected):
assert InclusiveManifestEvaluator(inc_man_spec,
Expressions.not_(Expressions.equal("ID", val)),
case_sensitive=False).eval(inc_man_file) == expected
def test_int_not_eq_rewritten(inc_man_spec, inc_man_file, val, expected):
assert InclusiveManifestEvaluator(inc_man_spec,
Expressions.not_(Expressions.equal("id", val))).eval(inc_man_file) == expected
def test_not(strict_schema, strict_file):
assert StrictMetricsEvaluator(strict_schema,
Expressions.not_(Expressions.less_than("id", 5))).eval(strict_file)
assert not StrictMetricsEvaluator(strict_schema,
Expressions.not_(Expressions.greater_than("id", 5))).eval(strict_file)
def test_case_sensitive_int_not_eq_rewritten(schema, file, not_eq_uc):
with raises(ValidationException):
assert InclusiveMetricsEvaluator(schema,
Expressions.not_(not_eq_uc),
case_sensitive=True).eval(file)
def test_bound_expression_fails():
with raises(RuntimeError):
expr = Expressions.not_(Expressions.equal("x", 7))
Binder.bind(STRUCT, Binder.bind(STRUCT, expr))
def test_single_reference(assert_all_bound):
expr = Expressions.not_(Expressions.equal("x", 7))
assert_all_bound("Single reference", Binder.bind(STRUCT, expr))
def test_not_eq_rewritten(schema, file, not_eq_rewrite):
assert InclusiveMetricsEvaluator(schema, Expressions.not_(not_eq_rewrite)).eval(file)
def test_case_sensitive_reference():
with raises(ice_ex.ValidationException):
expr = Expressions.not_(Expressions.equal("X", 7))
Binder.bind(STRUCT, expr, case_sensitive=True)
def test_not(schema, file):
assert InclusiveMetricsEvaluator(schema, Expressions.not_(Expressions.less_than("id", 5))).eval(file)
assert not InclusiveMetricsEvaluator(schema,
Expressions.not_(Expressions.greater_than("id", 5))).eval(file)
