Support SizeOf (#45)

Author: hbxie

src/main/java/com/yahoo/bullet/parsing/Clause.java

@@ -39,6 +39,8 @@ public enum Operation {
         LESS_EQUALS,
         @SerializedName("RLIKE")
         REGEX_LIKE,
+        @SerializedName("SIZEOF")
+        SIZE_OF,
         @SerializedName("AND")
         AND,
         @SerializedName("OR")
@@ -47,7 +49,7 @@ public enum Operation {
         NOT;
 
         public static final List<String> LOGICALS = asList("AND", "OR", "NOT");
-        public static final List<String> RELATIONALS = asList("==", "!=", ">=", "<=", ">", "<", "RLIKE");
+        public static final List<String> RELATIONALS = asList("==", "!=", ">=", "<=", ">", "<", "RLIKE", "SIZEOF");
     }
 
     @Expose

src/main/java/com/yahoo/bullet/querying/FilterOperations.java

@@ -7,6 +7,7 @@
 
 import com.yahoo.bullet.parsing.FilterClause;
 import com.yahoo.bullet.parsing.LogicalClause;
+import com.yahoo.bullet.typesystem.Type;
 import com.yahoo.bullet.typesystem.TypedObject;
 import com.yahoo.bullet.parsing.Clause;
 import com.yahoo.bullet.record.BulletRecord;
@@ -57,6 +58,7 @@ public interface LogicalOperator extends BiPredicate<BulletRecord, Stream<Boolea
     private static final Comparator<TypedObject> GE = (t, s) -> s.anyMatch(i -> t.compareTo(i) >= 0);
     private static final Comparator<TypedObject> LE = (t, s) -> s.anyMatch(i -> t.compareTo(i) <= 0);
     private static final Comparator<Pattern> RLIKE = (t, s) -> s.map(p -> p.matcher(t.toString())).anyMatch(Matcher::matches);
+    private static final Comparator<TypedObject> SIZEOF = (t, s) -> s.anyMatch(i -> sizeOf(t) == i.getValue());
     private static final LogicalOperator AND = (r, s) -> s.allMatch(Boolean::valueOf);
     private static final LogicalOperator OR = (r, s) -> s.anyMatch(Boolean::valueOf);
     private static final LogicalOperator NOT = (r, s) -> !s.findFirst().get();
@@ -71,6 +73,7 @@ public interface LogicalOperator extends BiPredicate<BulletRecord, Stream<Boolea
         COMPARATORS.put(Clause.Operation.LESS_EQUALS, isNotNullAnd(LE));
     }
     static final Comparator<Pattern> REGEX_LIKE = isNotNullAnd(RLIKE);
+    static final Comparator<TypedObject> SIZE_OF = isNotNullAnd(SIZEOF);
     static final Map<Clause.Operation, LogicalOperator> LOGICAL_OPERATORS = new EnumMap<>(Clause.Operation.class);
     static {
         LOGICAL_OPERATORS.put(Clause.Operation.AND, AND);
@@ -95,16 +98,34 @@ private static <T> Comparator<T> isNotNullAnd(Comparator<T> comparator) {
         return (t, s) -> IS_NOT_NULL.test(t) && comparator.compare(t, s);
     }
 
+    private static Integer sizeOf(TypedObject object) {
+        Object o = object.getValue();
+        if (o instanceof List) {
+            return List.class.cast(o).size();
+        }
+        if (o instanceof Map) {
+            return Map.class.cast(o).size();
+        }
+        if (o instanceof String) {
+            return String.class.cast(o).length();
+        }
+        return 1;
+    }
+
     private static boolean performRelational(BulletRecord record, FilterClause clause) {
         Clause.Operation operator = clause.getOperation();
         if (isEmpty(clause.getValues())) {
             return true;
         }
         TypedObject object = extractTypedObject(clause.getField(), record);
-        if (operator == Clause.Operation.REGEX_LIKE) {
-            return REGEX_LIKE.compare(object, clause.getPatterns().stream());
+        switch (operator) {
+            case REGEX_LIKE:
+                return REGEX_LIKE.compare(object, clause.getPatterns().stream());
+            case SIZE_OF:
+                return SIZE_OF.compare(object, cast(new TypedObject(Type.INTEGER, 0), clause.getValues()));
+            default:
+                return COMPARATORS.get(operator).compare(object, cast(object, clause.getValues()));
         }
-        return COMPARATORS.get(operator).compare(object, cast(object, clause.getValues()));
     }
 
     private static boolean performLogical(BulletRecord record, LogicalClause clause) {

src/test/java/com/yahoo/bullet/querying/FilterOperationsTest.java

@@ -17,14 +17,14 @@
 import org.testng.Assert;
 import org.testng.annotations.Test;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import static com.yahoo.bullet.parsing.FilterUtils.getFieldFilter;
-import static com.yahoo.bullet.parsing.FilterUtils.makeClause;
 import static com.yahoo.bullet.parsing.Clause.Operation.AND;
 import static com.yahoo.bullet.parsing.Clause.Operation.EQUALS;
 import static com.yahoo.bullet.parsing.Clause.Operation.GREATER_EQUALS;
@@ -35,6 +35,9 @@
 import static com.yahoo.bullet.parsing.Clause.Operation.NOT_EQUALS;
 import static com.yahoo.bullet.parsing.Clause.Operation.OR;
 import static com.yahoo.bullet.parsing.Clause.Operation.REGEX_LIKE;
+import static com.yahoo.bullet.parsing.Clause.Operation.SIZE_OF;
+import static com.yahoo.bullet.parsing.FilterUtils.getFieldFilter;
+import static com.yahoo.bullet.parsing.FilterUtils.makeClause;
 import static java.util.Arrays.asList;
 import static java.util.Collections.emptyList;
 import static java.util.Collections.singletonList;
@@ -352,6 +355,21 @@ public void testBadRegex() {
         Assert.assertFalse(FilterOperations.perform(RecordBox.get().add("id", "*TEST*").getRecord(), clause));
     }
 
+    @Test
+    public void testSizeOf() {
+        FilterClause clause = getFieldFilter("id", SIZE_OF, "1", "2");
+        Assert.assertFalse(FilterOperations.perform(RecordBox.get().getRecord(), clause));
+        Assert.assertTrue(FilterOperations.perform(RecordBox.get().add("id", 1).getRecord(), clause));
+        Assert.assertTrue(FilterOperations.perform(RecordBox.get().add("id", "12").getRecord(), clause));
+        Assert.assertFalse(FilterOperations.perform(RecordBox.get().add("id", "123").getRecord(), clause));
+        Assert.assertFalse(FilterOperations.perform(RecordBox.get().getRecord().setListOfStringMap("id", new ArrayList<>()), clause));
+        Assert.assertTrue(FilterOperations.perform(RecordBox.get().addList("id", singletonMap("1", 1)).getRecord(), clause));
+        Assert.assertTrue(FilterOperations.perform(RecordBox.get().addList("id", singletonMap("1", 1), singletonMap("2", 2)).getRecord(), clause));
+        Assert.assertFalse(FilterOperations.perform(RecordBox.get().addList("id", singletonMap("1", 1), singletonMap("2", 2), singletonMap("3", 3)).getRecord(), clause));
+        Assert.assertFalse(FilterOperations.perform(RecordBox.get().getRecord().setStringMap("id", new HashMap<>()), clause));
+        Assert.assertTrue(FilterOperations.perform(RecordBox.get().addMap("id", Pair.of("1", 1), Pair.of("2", 2)).getRecord(), clause));
+    }
+
     @Test
     public void testComparisonNestedField() {
         FilterClause clause = getFieldFilter("demographic_map.age", GREATER_THAN, "30");