public static OrDimFilter or(List<DimFilter> filters) { return new OrDimFilter(filters); }
@Override public DimFilter optimize() { List<DimFilter> elements = DimFilters.optimize(fields); return elements.size() == 1 ? elements.get(0) : new OrDimFilter(elements); }
public static OrDimFilter OR(DimFilter... filters) { return new OrDimFilter(Arrays.asList(filters)); }
@JsonCreator public IntervalDimFilter( @JsonProperty("dimension") String dimension, @JsonProperty("intervals") List<Interval> intervals, @JsonProperty("extractionFn") ExtractionFn extractionFn ) { Preconditions.checkNotNull(dimension, "dimension can not be null"); Preconditions.checkNotNull(intervals, "intervals can not be null"); Preconditions.checkArgument(intervals.size() > 0, "must specify at least one interval"); this.dimension = dimension; this.intervals = Collections.unmodifiableList(JodaUtils.condenseIntervals(intervals)); this.extractionFn = extractionFn; this.intervalLongs = makeIntervalLongs(); this.convertedFilter = new OrDimFilter(makeBoundDimFilters()); }
return checkedProcess(new OrDimFilter(newFilters)); } else { return checkedProcess(filter);
@Test public void testSimpleOptimize() { SelectorDimFilter selectorDimFilter = new SelectorDimFilter("abc", "d", null); DimFilter filter = new AndDimFilter( Collections.singletonList( new OrDimFilter( Collections.singletonList( new AndDimFilter(Arrays.asList(selectorDimFilter, null)) ) ) ) ); Assert.assertEquals(selectorDimFilter, filter.optimize()); }
/** * There are some special cases involving null that require special casing for And and Or instead of simply taking * the complement * * Example 1 : "NOT ( [0,INF) OR null)" The inside of NOT would evaluate to null, and the complement would also * be null. However, by breaking the NOT, this statement is "NOT([0,INF)) AND NOT(null)", which means it should * actually evaluate to (-INF, 0). * * Example 2 : "NOT ( [0,INF) AND null )" The inside of NOT would evaluate to [0,INF), and the complement would be * (-INF, 0). However the statement is actually "NOT([0,INF)) OR NOT(null)", and it should be evaluated to null. */ @Override public RangeSet<String> getDimensionRangeSet(String dimension) { if (field instanceof AndDimFilter) { List<DimFilter> fields = ((AndDimFilter) field).getFields(); return new OrDimFilter(Lists.transform(fields, NotDimFilter::new)).getDimensionRangeSet(dimension); } if (field instanceof OrDimFilter) { List<DimFilter> fields = ((OrDimFilter) field).getFields(); return new AndDimFilter(Lists.transform(fields, NotDimFilter::new)).getDimensionRangeSet(dimension); } if (field instanceof NotDimFilter) { return ((NotDimFilter) field).getField().getDimensionRangeSet(dimension); } RangeSet<String> rangeSet = field.getDimensionRangeSet(dimension); return rangeSet == null ? null : rangeSet.complement(); }
@Test public void testAggregateWithOrFilter() { final float[] values = {0.15f, 0.27f, 0.14f}; final TestFloatColumnSelector selector = new TestFloatColumnSelector(values); FilteredAggregatorFactory factory = new FilteredAggregatorFactory( new DoubleSumAggregatorFactory("billy", "value"), new OrDimFilter(Lists.newArrayList(new SelectorDimFilter("dim", "a", null), new SelectorDimFilter("dim", "b", null))) ); FilteredAggregator agg = (FilteredAggregator) factory.factorize( makeColumnSelector(selector) ); double expectedFirst = new Float(values[0]).doubleValue(); double expectedSecond = new Float(values[1]).doubleValue() + expectedFirst; double expectedThird = expectedSecond + new Float(values[2]).doubleValue(); assertValues(agg, selector, expectedFirst, expectedSecond, expectedThird); }
@Test public void testOrFilter() { DimFilter or1 = new OrDimFilter(ImmutableList.of(selector1, selector2, selector5)); RangeSet expected1 = rangeSet(ImmutableList.of(point(null), point("a"), point("z"))); Assert.assertEquals(expected1, or1.getDimensionRangeSet("dim1")); DimFilter or2 = new OrDimFilter(ImmutableList.of(selector5, in1, in3)); RangeSet expected2 = rangeSet(ImmutableList.of(point("testing"), point("this"), point("filter"), point("tillend"), point("null"), point(null) )); Assert.assertEquals(expected2, or2.getDimensionRangeSet("dim1")); DimFilter or3 = new OrDimFilter(ImmutableList.of(bound1, bound2, bound3)); Assert.assertEquals(all, or3.getDimensionRangeSet("dim1")); DimFilter or4 = new OrDimFilter(ImmutableList.of(selector1, selector2, selector3, selector4, selector5)); Assert.assertNull(or4.getDimensionRangeSet("dim1")); Assert.assertNull(or4.getDimensionRangeSet("dim2")); DimFilter or5 = new OrDimFilter(ImmutableList.of(or1, or2, bound1)); RangeSet expected5 = rangeSet(ImmutableList.of(point(null), point("a"), point("filter"), Range.closed("from", "to"), point("z") )); Assert.assertEquals(expected5, or5.getDimensionRangeSet("dim1")); }
public void readComplexOrFilterCNF(Blackhole blackhole) DimFilter dimFilter1 = new OrDimFilter(Arrays.asList( new SelectorDimFilter("dimSequential", "199", null), new AndDimFilter(Arrays.asList( DimFilter dimFilter2 = new OrDimFilter(Arrays.asList( new SelectorDimFilter("dimSequential", "299", null), new SelectorDimFilter("dimSequential", "399", null), DimFilter dimFilter3 = new OrDimFilter(Arrays.asList( dimFilter1, dimFilter2,
public void readWithFilters(Blackhole blackhole) DimFilter filter = new OrDimFilter( Arrays.asList( new BoundDimFilter("dimSequential", "-1", "-1", true, true, null, null, StringComparators.ALPHANUMERIC),
public void readComplexOrFilter(Blackhole blackhole) DimFilter dimFilter1 = new OrDimFilter(Arrays.asList( new SelectorDimFilter("dimSequential", "199", null), new AndDimFilter(Arrays.asList( DimFilter dimFilter2 = new OrDimFilter(Arrays.asList( new SelectorDimFilter("dimSequential", "299", null), new SelectorDimFilter("dimSequential", "399", null), DimFilter dimFilter3 = new OrDimFilter(Arrays.asList( dimFilter1, dimFilter2,
private TimeseriesQuery makeFilteredTimeseriesQuery() { return Druids.newTimeseriesQueryBuilder() .dataSource(dataSource) .granularity(allGran) .intervals(fullOnInterval) .filters( new OrDimFilter( new SelectorDimFilter(marketDimension, "spot", null), new SelectorDimFilter(marketDimension, "total_market", null) ) ) .aggregators( Lists.newArrayList( Iterables.concat( commonAggregators, Lists.newArrayList( new DoubleMaxAggregatorFactory("maxIndex", "index"), new DoubleMinAggregatorFactory("minIndex", "index") ) ) ) ) .postAggregators(addRowsIndexConstant) .build(); }
@Test public void testDistributeOrCNF() DimFilter dimFilter1 = new OrDimFilter(Arrays.asList( new SelectorDimFilter("dim0", "6", null), new AndDimFilter(Arrays.asList( ); DimFilter dimFilter2 = new OrDimFilter(Arrays.asList( new SelectorDimFilter("dim0", "2", null), new SelectorDimFilter("dim0", "3", null), ); DimFilter dimFilter3 = new OrDimFilter(Arrays.asList( dimFilter1, dimFilter2,
new AndDimFilter( ImmutableList.of( new OrDimFilter( ImmutableList.of( new BoundDimFilter("rows", "2", null, true, false, null, null, StringComparators.NUMERIC),
@Test public void testSearchWithMultiOrFilter() { List<SearchHit> expectedHits = new ArrayList<>(); expectedHits.add(new SearchHit(QueryRunnerTestHelper.qualityDimension, "automotive", 93)); DimFilter filter = new OrDimFilter( new SelectorDimFilter(QueryRunnerTestHelper.qualityDimension, "total_market", null), new SelectorDimFilter(QueryRunnerTestHelper.qualityDimension, "automotive", null) ); checkSearchQuery( Druids.newSearchQueryBuilder() .dataSource(QueryRunnerTestHelper.dataSource) .granularity(QueryRunnerTestHelper.allGran) .dimensions(QueryRunnerTestHelper.qualityDimension) .filters(filter) .intervals(QueryRunnerTestHelper.fullOnIntervalSpec) .query("a") .build(), expectedHits ); }
new OrDimFilter(QueryRunnerTestHelper.qualityDimension, "automotive", "business", "billyblank") ); TimeseriesQuery query = Druids.newTimeseriesQueryBuilder()
new OrDimFilter(QueryRunnerTestHelper.placementishDimension, "a", "b") ); TimeseriesQuery query = Druids new OrDimFilter(QueryRunnerTestHelper.qualityDimension, "automotive", "business") );
.setGranularity(QueryRunnerTestHelper.allGran) .setDimFilter( new OrDimFilter( Arrays.asList( new SelectorDimFilter("market", "spot", null),
.setAggregatorSpecs(new DoubleMaxAggregatorFactory("idx", "idx")) .setDimFilter( new OrDimFilter( Lists.newArrayList( new SelectorDimFilter("quality", "automotive", null),