@Override public Expression or(Expression leftResult, Expression rightResult) { return Expressions.or(leftResult, rightResult); }
@Override public Expression or(Expression leftResult, Expression rightResult) { return Expressions.or(leftResult, rightResult); }
@Override public Expression or(Expression leftResult, Expression rightResult) { return Expressions.or(leftResult, rightResult); }
@Override public Expression or(Expression leftResult, Expression rightResult) { return Expressions.or(leftResult, rightResult); }
/** * Add a filter to match files to delete. A file will be deleted if all of the rows it contains * match this or any other filter passed to this method. * * @param expr an expression to match rows. */ protected void deleteByRowFilter(Expression expr) { Preconditions.checkNotNull(expr, "Cannot delete files using filter: null"); this.filterUpdated = true; this.deleteExpression = Expressions.or(deleteExpression, expr); }
@Override public Expression negate() { // not(and(a, b)) => or(not(a), not(b)) return Expressions.or(left.negate(), right.negate()); }
private static com.netflix.iceberg.expressions.Expression convertIn(Expression expr, Collection<Object> values) { if (expr instanceof Attribute) { Attribute attr = (Attribute) expr; com.netflix.iceberg.expressions.Expression converted = alwaysFalse(); for (Object item : values) { converted = or(converted, equal(attr.name(), item)); } return converted; } return null; }
@Override public Object visit(final ASTOR node, final Object data) { return Expressions.or((Expression) node.jjtGetChild(0).jjtAccept(this, data), (Expression) node.jjtGetChild(1).jjtAccept(this, data)); }
@Override public Object visit(final ASTOR node, final Object data) { return Expressions.or((Expression) node.jjtGetChild(0).jjtAccept(this, data), (Expression) node.jjtGetChild(1).jjtAccept(this, data)); }
@Test public void testSimplifyOr() { Assert.assertEquals("alwaysTrue or pred => alwaysTrue", alwaysTrue(), or(alwaysTrue(), pred)); Assert.assertEquals("pred or alwaysTrue => alwaysTrue", alwaysTrue(), or(pred, alwaysTrue())); Assert.assertEquals("alwaysFalse or pred => pred", pred, or(alwaysFalse(), pred)); Assert.assertEquals("pred or alwaysTrue => pred", pred, or(pred, alwaysFalse())); }
@Override public Object visit(final ASTBETWEEN node, final Object data) { final Object value = node.jjtGetChild(0).jjtAccept(this, data); final Object startValue = node.jjtGetChild(1).jjtAccept(this, data); final Object endValue = node.jjtGetChild(2).jjtAccept(this, data); final Expression compare1 = createIcebergExpression(value, startValue, node.not ? Compare.LT : Compare.GTE); final Expression compare2 = createIcebergExpression(value, endValue, node.not ? Compare.GT : Compare.LTE); return (node.not) ? Expressions.or(compare1, compare2) : Expressions.and(compare1, compare2); }
@Override public Object visit(final ASTBETWEEN node, final Object data) { final Object value = node.jjtGetChild(0).jjtAccept(this, data); final Object startValue = node.jjtGetChild(1).jjtAccept(this, data); final Object endValue = node.jjtGetChild(2).jjtAccept(this, data); final Expression compare1 = createIcebergExpression(value, startValue, node.not ? Compare.LT : Compare.GTE); final Expression compare2 = createIcebergExpression(value, endValue, node.not ? Compare.GT : Compare.LTE); return (node.not) ? Expressions.or(compare1, compare2) : Expressions.and(compare1, compare2); }
@Test public void testOr() { // this test case must use a real predicate, not alwaysTrue(), or binding will simplify it out boolean shouldRead = new InclusiveMetricsEvaluator(SCHEMA, or(lessThan("id", 5), greaterThanOrEqual("id", 80))).eval(FILE); Assert.assertFalse("Should skip: or(false, false)", shouldRead); shouldRead = new InclusiveMetricsEvaluator(SCHEMA, or(lessThan("id", 5), greaterThanOrEqual("id", 60))).eval(FILE); Assert.assertTrue("Should read: or(false, true)", shouldRead); }
@Test public void testOr() { // this test case must use a real predicate, not alwaysTrue(), or binding will simplify it out boolean shouldRead = new ParquetMetricsRowGroupFilter(SCHEMA, or(lessThan("id", 5), greaterThanOrEqual("id", 80))) .shouldRead(PARQUET_SCHEMA, ROW_GROUP_METADATA); Assert.assertFalse("Should skip: or(false, false)", shouldRead); shouldRead = new ParquetMetricsRowGroupFilter(SCHEMA, or(lessThan("id", 5), greaterThanOrEqual("id", 60))) .shouldRead(PARQUET_SCHEMA, ROW_GROUP_METADATA); Assert.assertTrue("Should read: or(false, true)", shouldRead); }
@Test public void testOr() { // this test case must use a real predicate, not alwaysTrue(), or binding will simplify it out boolean shouldRead = new ParquetDictionaryRowGroupFilter(SCHEMA, or(lessThan("id", 5), greaterThanOrEqual("id", 80))) .shouldRead(PARQUET_SCHEMA, ROW_GROUP_METADATA, DICTIONARY_STORE); Assert.assertFalse("Should skip: or(false, false)", shouldRead); shouldRead = new ParquetDictionaryRowGroupFilter(SCHEMA, or(lessThan("id", 5), greaterThanOrEqual("id", 60))) .shouldRead(PARQUET_SCHEMA, ROW_GROUP_METADATA, DICTIONARY_STORE); Assert.assertTrue("Should read: or(false, true)", shouldRead); }
@Test public void testOr() { // this test case must use a real predicate, not alwaysTrue(), or binding will simplify it out boolean shouldRead = new StrictMetricsEvaluator(SCHEMA, or(lessThan("id", 5), greaterThanOrEqual("id", 80))).eval(FILE); Assert.assertFalse("Should not match: no matching values", shouldRead); shouldRead = new StrictMetricsEvaluator(SCHEMA, or(lessThan("id", 5), greaterThanOrEqual("id", 60))).eval(FILE); Assert.assertFalse("Should not match: some values do not match", shouldRead); shouldRead = new StrictMetricsEvaluator(SCHEMA, or(lessThan("id", 5), greaterThanOrEqual("id", 30))).eval(FILE); Assert.assertTrue("Should match: all values match > 30", shouldRead); }
@Test public void testOr() { // this test case must use a real predicate, not alwaysTrue(), or binding will simplify it out boolean shouldRead = new InclusiveManifestEvaluator( SPEC, or(lessThan("id", 5), greaterThanOrEqual("id", 80))).eval(FILE); Assert.assertFalse("Should skip: or(false, false)", shouldRead); shouldRead = new InclusiveManifestEvaluator( SPEC, or(lessThan("id", 5), greaterThanOrEqual("id", 60))).eval(FILE); Assert.assertTrue("Should read: or(false, true)", shouldRead); }
@Test public void testMultipleReferences() { Expression expr = or(and(equal("x", 7), lessThan("y", 100)), greaterThan("z", -100)); TestHelpers.assertAllReferencesBound("Multiple references", Binder.bind(STRUCT, expr)); }
@Test public void testOr() { Evaluator evaluator = new Evaluator(STRUCT, or(equal("x", 7), notNull("z"))); Assert.assertTrue("7, 3 => true", evaluator.eval(TestHelpers.Row.of(7, 0, 3))); Assert.assertTrue("8, 3 => true", evaluator.eval(TestHelpers.Row.of(8, 0, 3))); Assert.assertTrue("7, null => true", evaluator.eval(TestHelpers.Row.of(7, 0, null))); Assert.assertFalse("8, null => false", evaluator.eval(TestHelpers.Row.of(8, 0, null))); }
@Test public void testOr() { Expression expr = or(greaterThan("z", -100), lessThan("y", 100)); Expression boundExpr = Binder.bind(STRUCT, expr); TestHelpers.assertAllReferencesBound("Or", boundExpr); // make sure the result is an Or Or or = TestHelpers.assertAndUnwrap(boundExpr, Or.class); // make sure the refs are for the right fields BoundPredicate<?> left = TestHelpers.assertAndUnwrap(or.left()); Assert.assertEquals("Should bind z correctly", 2, left.ref().fieldId()); BoundPredicate<?> right = TestHelpers.assertAndUnwrap(or.right()); Assert.assertEquals("Should bind y correctly", 1, right.ref().fieldId()); }