.preAggregationFilter(new ElementFilter.Builder() .select(TestPropertyNames.COUNT) .execute(new IsMoreThan(5)) .build()) .aggregator(new ElementAggregator.Builder() assertEquals(1, preFilterComponents.size()); assertArrayEquals(new String[]{TestPropertyNames.COUNT}, preFilterComponents.get(0).getSelection()); assertEquals(new IsMoreThan(5), preFilterComponents.get(0).getPredicate());
private Pair<FilterPredicate, Set<Path>> addPrimitiveFilter(final Predicate filterFunction, final String selection, final String group) throws SerialisationException { // All supported filters will be in the if else statement below if (filterFunction instanceof IsEqual) { return addIsEqualFilter(selection, schemaUtils.getConverter(group).gafferObjectToParquetObjects(selection, ((IsEqual) filterFunction).getControlValue()), group, false); } else if (filterFunction instanceof IsLessThan) { if (((IsLessThan) filterFunction).getOrEqualTo()) { return addIsLessThanOrEqualToFilter(selection, schemaUtils.getConverter(group).gafferObjectToParquetObjects(selection, ((IsLessThan) filterFunction).getControlValue()), group); } else { return addIsLessThanFilter(selection, schemaUtils.getConverter(group).gafferObjectToParquetObjects(selection, ((IsLessThan) filterFunction).getControlValue()), group); } } else if (filterFunction instanceof IsMoreThan) { if (((IsMoreThan) filterFunction).getOrEqualTo()) { return addIsMoreThanOrEqualToFilter(selection, schemaUtils.getConverter(group).gafferObjectToParquetObjects(selection, ((IsMoreThan) filterFunction).getControlValue()), group); } else { return addIsMoreThanFilter(selection, schemaUtils.getConverter(group).gafferObjectToParquetObjects(selection, ((IsMoreThan) filterFunction).getControlValue()), group); } } else if (filterFunction instanceof IsTrue) { return new Pair<>(eq(booleanColumn(selection), Boolean.TRUE), getAllPathsForColumn(group)); } else if (filterFunction instanceof IsFalse) { return new Pair<>(eq(booleanColumn(selection), Boolean.FALSE), getAllPathsForColumn(group)); } else { LOGGER.warn(filterFunction.getClass().getCanonicalName() + " is not a natively supported filter by the Parquet store, therefore execution will take longer to perform this filter."); return null; } }
.execute(new Not<>(new Or.Builder<>() .select(0) .execute(new IsMoreThan(2)) .select(1) .execute(new IsEqual("some value"))
.execute(new Or.Builder<>() .select(0) .execute(new IsMoreThan(2)) .select(1) .execute(new IsEqual("some value"))
public void isMoreThanOrEqualTo5() { // --------------------------------------------------------- final IsMoreThan function = new IsMoreThan(5, true); // --------------------------------------------------------- runExample(function, null, 1, 5, 10); }
public void isMoreThanAString() { // --------------------------------------------------------- final IsMoreThan function = new IsMoreThan("B"); // --------------------------------------------------------- runExample(function, null, 1, "A", "B", "C"); } }
public void isMoreThan5() { // --------------------------------------------------------- final IsMoreThan function = new IsMoreThan(5); // --------------------------------------------------------- runExample(function, null, 1, 5, 10); }
public void isMoreThanALong5() { // --------------------------------------------------------- final IsMoreThan function = new IsMoreThan(5L); // --------------------------------------------------------- runExample(function, null, 1, 1L, 5, 5L, 10, 10L, "abc"); }
@Override public ValidationResult validate() { final ValidationResult result = Operation.super.validate(); result.add(FieldUtil.validateRequiredFields( new Tuple3<>("proportionToSample must be greater than 0", proportionToSample, new IsMoreThan(0f)) )); return result; }
public void isLessThan3AndIsMoreThan0() { // --------------------------------------------------------- final And function = new And<>( new IsLessThan(3), new IsMoreThan(0) ); // --------------------------------------------------------- runExample(function, null, 0, 1, 2, 3, 1L, 2L); }
public void isLessThan2EqualTo5OrIsMoreThan10() { // --------------------------------------------------------- final Or function = new Or<>( new IsLessThan(2), new IsEqual(5), new IsMoreThan(10) ); // --------------------------------------------------------- runExample(function, "When using an Or predicate with a single selected value you can just use the constructor new Or(predicates))'", 1, 2, 3, 5, 15, 1L, 3L, 5L); }
} else if (filter instanceof GreaterThan) { final GreaterThan greaterThan = (GreaterThan) filter; final Predicate<?> isMoreThan = new IsMoreThan((Comparable<?>) greaterThan.value(), false); final Set<String> relevantGroups = getGroupsFromFilter(filter); if (null != relevantGroups) { } else if (filter instanceof GreaterThanOrEqual) { final GreaterThanOrEqual greaterThan = (GreaterThanOrEqual) filter; final Predicate<?> isMoreThan = new IsMoreThan((Comparable<?>) greaterThan.value(), true); final Set<String> relevantGroups = getGroupsFromFilter(filter); if (null != relevantGroups) {
public void freqMapIsMoreThan2() { // --------------------------------------------------------- final PredicateMap function = new PredicateMap("key1", new IsMoreThan(2L)); // --------------------------------------------------------- final FreqMap map1 = new FreqMap(); map1.put("key1", 1L); final FreqMap map2 = new FreqMap(); map2.put("key1", 2L); final FreqMap map3 = new FreqMap(); map3.put("key1", 3L); final FreqMap map4 = new FreqMap(); map4.put("key1", 3L); map4.put("key2", 0L); final FreqMap map5 = new FreqMap(); map5.put("key2", 3L); runExample(function, null, map1, map2, map3, map4, map5); }
public void freqMapIsMoreThanOrEqualTo2() { // --------------------------------------------------------- final PredicateMap function = new PredicateMap("key1", new IsMoreThan(2L, true)); // --------------------------------------------------------- final FreqMap map1 = new FreqMap(); map1.put("key1", 1L); final FreqMap map2 = new FreqMap(); map2.put("key1", 2L); final FreqMap map3 = new FreqMap(); map3.put("key1", 3L); final FreqMap map4 = new FreqMap(); map4.put("key1", 3L); map4.put("key2", 0L); final FreqMap map5 = new FreqMap(); map5.put("key2", 3L); runExample(function, null, map1, map2, map3, map4, map5); }
public CloseableIterable<? extends Element> getEntitiesRelatedTo2WithCountLessThan2OrMoreThan5() { // --------------------------------------------------------- final GetElements operation = new GetElements.Builder() .input(new EntitySeed(2), new EdgeSeed(2, 3, DirectedType.EITHER)) .view(new View.Builder() .entity("entity", new ViewElementDefinition.Builder() .preAggregationFilter( new ElementFilter.Builder() .select("count") .execute(new Or<>(new IsLessThan(2), new IsMoreThan(5))) .build()) .build()) .build()) .build(); // --------------------------------------------------------- return runExample(operation, "When using an Or predicate with a single selected value you can just do 'select(propertyName)' then 'execute(new Or(predicates))'"); }
public CloseableIterable<? extends Element> getAllElementsWithCountGreaterThan2() { // --------------------------------------------------------- final GetAllElements operation = new GetAllElements.Builder() .view(new View.Builder() .entity("entity", new ViewElementDefinition.Builder() .preAggregationFilter(new ElementFilter.Builder() .select("count") .execute(new IsMoreThan(2)) .build()) .build()) .edge("edge", new ViewElementDefinition.Builder() .preAggregationFilter(new ElementFilter.Builder() .select("count") .execute(new IsMoreThan(2)) .build()) .build()) .build()) .build(); // --------------------------------------------------------- return runExample(operation, null); } }
public CloseableIterable<? extends Element> getAllEntitiesAndEdgesThatAreRelatedToEdge1to2WithCountMoreThan1() { // --------------------------------------------------------- final GetElements operation = new GetElements.Builder() .input(new EdgeSeed(1, 2, DirectedType.EITHER)) .view(new View.Builder() .entity("entity", new ViewElementDefinition.Builder() .preAggregationFilter(new ElementFilter.Builder() .select("count") .execute(new IsMoreThan(1)) .build()) .build()) .edge("edge", new ViewElementDefinition.Builder() .preAggregationFilter(new ElementFilter.Builder() .select("count") .execute(new IsMoreThan(1)) .build()) .build()) .build()) .build(); // --------------------------------------------------------- return runExample(operation, null); }
public CloseableIterable<? extends Element> getEntitiesAndEdgesByEntityId2AndEdgeId2to3WithCountMoreThan1() { // --------------------------------------------------------- final GetElements operation = new GetElements.Builder() .input(new EntitySeed(2), new EdgeSeed(2, 3, DirectedType.EITHER)) .view(new View.Builder() .entity("entity", new ViewElementDefinition.Builder() .preAggregationFilter(new ElementFilter.Builder() .select("count") .execute(new IsMoreThan(1)) .build()) .build()) .edge("edge", new ViewElementDefinition.Builder() .preAggregationFilter(new ElementFilter.Builder() .select("count") .execute(new IsMoreThan(1)) .build()) .build()) .build()) .build(); // --------------------------------------------------------- return runExample(operation, null); }
public CloseableIterable<? extends EntityId> getAdjacentIdsAlongOutboundEdgesFromVertex2WithCountGreaterThan1() { // --------------------------------------------------------- final GetAdjacentIds operation = new GetAdjacentIds.Builder() .input(new EntitySeed(2)) .inOutType(IncludeIncomingOutgoingType.OUTGOING) .view(new View.Builder() .entity("entity", new ViewElementDefinition.Builder() .preAggregationFilter(new ElementFilter.Builder() .select("count") .execute(new IsMoreThan(1)) .build()) .build()) .edge("edge", new ViewElementDefinition.Builder() .preAggregationFilter(new ElementFilter.Builder() .select("count") .execute(new IsMoreThan(1)) .build()) .build()) .build()) .build(); // --------------------------------------------------------- return runExample(operation, null); } }
public void firstItemIsLessThan2AndSecondItemIsMoreThan5() { // --------------------------------------------------------- final And function = new And.Builder() .select(0) .execute(new IsLessThan(2)) .select(1) .execute(new IsMoreThan(5)) .build(); // --------------------------------------------------------- runExample(function, null, new Tuple2<>(1, 10), new Tuple2<>(1, 1), new Tuple2<>(10, 10), new Tuple2<>(10, 1), new Tuple2<>(1L, 10L), new Tuple1<>(1)); } }