public ScanBuilder where(Expression rowFilter) { this.where = Expressions.and(where, rowFilter); return this; }
@Override public Expression and(Expression leftResult, Expression rightResult) { return Expressions.and(leftResult, rightResult); }
@Override public FilteredManifest filterPartitions(Expression expr) { return new FilteredManifest(reader, Expressions.and(partFilter, expr), rowFilter, columns); }
static Expression joinFilters(List<Expression> expressions) { Expression result = Expressions.alwaysTrue(); for (Expression expression : expressions) { result = Expressions.and(result, expression); } return result; }
@Override public Expression negate() { // not(or(a, b)) => and(not(a), not(b)) return Expressions.and(left.negate(), right.negate()); }
@Override public Object visit(final ASTAND node, final Object data) { return Expressions.and((Expression) node.jjtGetChild(0).jjtAccept(this, data), (Expression) node.jjtGetChild(1).jjtAccept(this, data)); }
@Override public Object visit(final ASTAND node, final Object data) { return Expressions.and((Expression) node.jjtGetChild(0).jjtAccept(this, data), (Expression) node.jjtGetChild(1).jjtAccept(this, data)); }
@Test public void testSimplifyAnd() { Assert.assertEquals("alwaysTrue and pred => pred", pred, and(alwaysTrue(), pred)); Assert.assertEquals("pred and alwaysTrue => pred", pred, and(pred, alwaysTrue())); Assert.assertEquals("alwaysFalse and pred => alwaysFalse", alwaysFalse(), and(alwaysFalse(), pred)); Assert.assertEquals("pred and alwaysFalse => alwaysFalse", alwaysFalse(), and(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 testMissingReference() { Expression expr = and(equal("t", 5), equal("x", 7)); try { Binder.bind(STRUCT, expr); Assert.fail("Should not successfully bind to struct without field 't'"); } catch (ValidationException e) { Assert.assertTrue("Should complain about missing field", e.getMessage().contains("Cannot find field 't' in struct:")); } }
@Test public void testAnd() { // this test case must use a real predicate, not alwaysTrue(), or binding will simplify it out boolean shouldRead = new StrictMetricsEvaluator(SCHEMA, and(greaterThan("id", 5), lessThanOrEqual("id", 30))).eval(FILE); Assert.assertFalse("Should not match: range overlaps data", shouldRead); shouldRead = new StrictMetricsEvaluator(SCHEMA, and(lessThan("id", 5), greaterThanOrEqual("id", 0))).eval(FILE); Assert.assertFalse("Should match: range does not overlap data", shouldRead); shouldRead = new StrictMetricsEvaluator(SCHEMA, and(lessThan("id", 85), greaterThanOrEqual("id", 0))).eval(FILE); Assert.assertTrue("Should match: range includes all data", shouldRead); }
@Test public void testAnd() { // this test case must use a real predicate, not alwaysTrue(), or binding will simplify it out boolean shouldRead = new InclusiveMetricsEvaluator(SCHEMA, and(lessThan("id", 5), greaterThanOrEqual("id", 0))).eval(FILE); Assert.assertFalse("Should skip: and(false, false)", shouldRead); shouldRead = new InclusiveMetricsEvaluator(SCHEMA, and(greaterThan("id", 5), lessThanOrEqual("id", 30))).eval(FILE); Assert.assertTrue("Should read: and(true, true)", shouldRead); }
@Test public void testAnd() { // this test case must use a real predicate, not alwaysTrue(), or binding will simplify it out boolean shouldRead = new ParquetDictionaryRowGroupFilter(SCHEMA, and(lessThan("id", 5), greaterThanOrEqual("id", 0))) .shouldRead(PARQUET_SCHEMA, ROW_GROUP_METADATA, DICTIONARY_STORE); Assert.assertFalse("Should skip: and(false, false)", shouldRead); shouldRead = new ParquetDictionaryRowGroupFilter(SCHEMA, and(greaterThan("id", 5), lessThanOrEqual("id", 30))) .shouldRead(PARQUET_SCHEMA, ROW_GROUP_METADATA, DICTIONARY_STORE); Assert.assertTrue("Should read: and(true, true)", shouldRead); }
@Test public void testAnd() { // this test case must use a real predicate, not alwaysTrue(), or binding will simplify it out boolean shouldRead = new ParquetMetricsRowGroupFilter(SCHEMA, and(lessThan("id", 5), greaterThanOrEqual("id", 0))) .shouldRead(PARQUET_SCHEMA, ROW_GROUP_METADATA); Assert.assertFalse("Should skip: and(false, false)", shouldRead); shouldRead = new ParquetMetricsRowGroupFilter(SCHEMA, and(greaterThan("id", 5), lessThanOrEqual("id", 30))) .shouldRead(PARQUET_SCHEMA, ROW_GROUP_METADATA); Assert.assertTrue("Should read: and(true, 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 testOverwriteFailsDelete() { TableMetadata base = TestTables.readMetadata(TABLE_NAME); long baseId = base.currentSnapshot().snapshotId(); OverwriteFiles overwrite = table.newOverwrite() .overwriteByRowFilter(and(equal("date", "2018-06-09"), lessThan("id", 9))); AssertHelpers.assertThrows("Should reject commit with file not matching delete expression", ValidationException.class, "Cannot delete file where some, but not all, rows match filter", overwrite::commit); Assert.assertEquals("Should not create a new snapshot", baseId, table.currentSnapshot().snapshotId()); }
@Test public void testAnd() { Evaluator evaluator = new Evaluator(STRUCT, and(equal("x", 7), notNull("z"))); Assert.assertTrue("7, 3 => true", evaluator.eval(TestHelpers.Row.of(7, 0, 3))); Assert.assertFalse("8, 3 => false", evaluator.eval(TestHelpers.Row.of(8, 0, 3))); Assert.assertFalse("7, null => false", evaluator.eval(TestHelpers.Row.of(7, 0, null))); Assert.assertFalse("8, null => false", evaluator.eval(TestHelpers.Row.of(8, 0, null))); }
@Test public void testAnd() { Expression expr = and(equal("x", 7), lessThan("y", 100)); Expression boundExpr = Binder.bind(STRUCT, expr); TestHelpers.assertAllReferencesBound("And", boundExpr); // make sure the result is an And And and = TestHelpers.assertAndUnwrap(boundExpr, And.class); // make sure the refs are for the right fields BoundPredicate<?> left = TestHelpers.assertAndUnwrap(and.left()); Assert.assertEquals("Should bind x correctly", 0, left.ref().fieldId()); BoundPredicate<?> right = TestHelpers.assertAndUnwrap(and.right()); Assert.assertEquals("Should bind y correctly", 1, right.ref().fieldId()); }