final public void addChildren(List<? extends TupleFilter> children) { for (TupleFilter c : children) addChild(c); // subclass overrides addChild() }
@Test // Not(And(true, false)) ==> Or(false, true) public void removeNotTest2() { TupleFilter notFilter = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.NOT); TupleFilter andFilter = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.AND); andFilter.addChildren(ConstantTupleFilter.TRUE, ConstantTupleFilter.FALSE); notFilter.addChild(andFilter); TupleFilter orFilter = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.OR); orFilter.addChildren(ConstantTupleFilter.FALSE, ConstantTupleFilter.TRUE); Assert.assertEquals(orFilter, notFilter.removeNot()); }
final public void addChildren(TupleFilter... children) { for (TupleFilter c : children) addChild(c); // subclass overrides addChild() }
@Test // And(Not(true), false) ==> And(false, false) public void removeNotTest3() { TupleFilter andFilter = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.AND); TupleFilter notFilter = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.NOT); notFilter.addChild(ConstantTupleFilter.TRUE); andFilter.addChildren(notFilter, ConstantTupleFilter.FALSE); TupleFilter andFilter2 = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.AND); andFilter2.addChildren(ConstantTupleFilter.FALSE, ConstantTupleFilter.FALSE); Assert.assertEquals(andFilter2, andFilter.removeNot()); }
@Override public void addChild(TupleFilter child) { if (this.filterIndex % 2 == 0) { this.elseFilter = child; } else { this.whenFilters.add(this.elseFilter); this.thenFilters.add(child); this.elseFilter = null; } super.addChild(child); this.filterIndex++; }
@Override public void addChild(TupleFilter child) { super.addChild(child); if (child instanceof ColumnTupleFilter) { ColumnTupleFilter columnFilter = (ColumnTupleFilter) child;
private TupleFilter and(TupleFilter f1, TupleFilter f2) { if (f1 == null) return f2; if (f2 == null) return f1; if (f1.getOperator() == FilterOperatorEnum.AND) { f1.addChild(f2); return f1; } if (f2.getOperator() == FilterOperatorEnum.AND) { f2.addChild(f1); return f2; } LogicalTupleFilter and = new LogicalTupleFilter(FilterOperatorEnum.AND); and.addChild(f1); and.addChild(f2); return and; }
parentFilter.addChild(filter);
private TupleExpression getCountColumnExpression(TblColRef colRef) { List<Pair<TupleFilter, TupleExpression>> whenList = Lists.newArrayListWithExpectedSize(1); TupleFilter whenFilter = new CompareTupleFilter(TupleFilter.FilterOperatorEnum.ISNULL); whenFilter.addChild(new ColumnTupleFilter(colRef)); whenList.add(new Pair<TupleFilter, TupleExpression>(whenFilter, new NumberTupleExpression(0))); TupleExpression elseExpr = new ColumnTupleExpression(SumDynamicFunctionDesc.mockCntCol); TupleExpression ret = new CaseTupleExpression(whenList, elseExpr); ret.setDigest("_KY_COUNT(" + colRef.getName() + ")"); return ret; } }
@Test(expected = IllegalStateException.class) public void flatFilterTooFatTest() { TupleFilter topAndFilter = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.AND); for (int i = 0; i < 3; i++) { TupleFilter orFilter = new LogicalTupleFilter(FilterOperatorEnum.OR); String col = "col-" + i; for (int j = 0; j < 100; j++) { orFilter.addChild(createEQFilter(col, String.valueOf(j))); } topAndFilter.addChild(orFilter); } TupleFilter flatFilter = topAndFilter.flatFilter(500000); System.out.println(flatFilter); }
@Test public void transformTest5() throws Exception { TupleFilter or = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.AND); TupleFilter a = ConstantTupleFilter.TRUE; TupleFilter b = ConstantTupleFilter.TRUE; or.addChild(a); or.addChild(b); or = new FilterOptimizeTransformer().transform(or); Assert.assertEquals(ConstantTupleFilter.TRUE, or); }
@Test public void transformTest2() throws Exception { TupleFilter or = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.OR); TupleFilter a = ConstantTupleFilter.FALSE; TupleFilter b = ConstantTupleFilter.FALSE; or.addChild(a); or.addChild(b); or = new FilterOptimizeTransformer().transform(or); Assert.assertEquals(ConstantTupleFilter.FALSE, or); }
@Test public void transformTest6() throws Exception { TupleFilter or = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.AND); TupleFilter a = ConstantTupleFilter.FALSE; TupleFilter b = ConstantTupleFilter.TRUE; or.addChild(a); or.addChild(b); or = new FilterOptimizeTransformer().transform(or); Assert.assertEquals(ConstantTupleFilter.FALSE, or); }
@Test public void transformTest3() throws Exception { TupleFilter or = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.OR); TupleFilter a = ConstantTupleFilter.TRUE; TupleFilter b = ConstantTupleFilter.TRUE; or.addChild(a); or.addChild(b); or = new FilterOptimizeTransformer().transform(or); Assert.assertEquals(ConstantTupleFilter.TRUE, or); }
@Test public void transformTest7() throws Exception { TupleFilter or = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.OR); TupleFilter a = ConstantTupleFilter.FALSE; TupleFilter b = ConstantTupleFilter.TRUE; or.addChild(a); or.addChild(b); or = new FilterOptimizeTransformer().transform(or); Assert.assertEquals(ConstantTupleFilter.TRUE, or); } }
@Test public void transformTest4() throws Exception { TupleFilter or = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.AND); TupleFilter a = ConstantTupleFilter.FALSE; TupleFilter b = ConstantTupleFilter.FALSE; or.addChild(a); or.addChild(b); or = new FilterOptimizeTransformer().transform(or); Assert.assertEquals(ConstantTupleFilter.FALSE, or); }
@Test public void transformTest1() throws Exception { TupleFilter or = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.OR); TupleFilter a = new CompareTupleFilter(TupleFilter.FilterOperatorEnum.EQ); TupleFilter b = ConstantTupleFilter.FALSE; or.addChild(a); or.addChild(b); or = new FilterOptimizeTransformer().transform(or); Assert.assertEquals(1, or.children.size()); }
@Test public void transformTest0() throws Exception { TupleFilter or = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.AND); TupleFilter a = new CompareTupleFilter(TupleFilter.FilterOperatorEnum.EQ); TupleFilter b = ConstantTupleFilter.TRUE; or.addChild(a); or.addChild(b); or = new FilterOptimizeTransformer().transform(or); Assert.assertEquals(1, or.children.size()); }
@Test public void testMustTrueTupleFilter() { TupleFilter andFilter = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.AND); TupleFilter andFilter2 = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.AND); TupleFilter orFilter = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.OR); andFilter.addChild(andFilter2); andFilter.addChild(orFilter); Set<CompareTupleFilter> trueTupleFilters = andFilter.findMustTrueCompareFilters(); Assert.assertTrue(trueTupleFilters.isEmpty()); TupleFilter compFilter = new CompareTupleFilter(TupleFilter.FilterOperatorEnum.GT); compFilter.addChild(new ColumnTupleFilter(TblColRef.newInnerColumn("test1", TblColRef.InnerDataTypeEnum.LITERAL))); TupleFilter compFilter2 = new CompareTupleFilter(TupleFilter.FilterOperatorEnum.GT); compFilter2.addChild(new ColumnTupleFilter(TblColRef.newInnerColumn("test2", TblColRef.InnerDataTypeEnum.LITERAL))); andFilter2.addChild(compFilter); orFilter.addChild(compFilter2); Assert.assertEquals(Sets.newHashSet(compFilter), andFilter.findMustTrueCompareFilters()); Assert.assertEquals(Sets.newHashSet(compFilter2), compFilter2.findMustTrueCompareFilters()); }
@Test // Not(true) ==> false public void removeNotTest1() { TupleFilter notFilter = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.NOT); notFilter.addChild(ConstantTupleFilter.TRUE); Assert.assertEquals(ConstantTupleFilter.FALSE, notFilter.removeNot()); }