Query: add relation count condition (#150)

Author: greenrobot-team

objectbox-java/src/main/java/io/objectbox/query/QueryBuilder.java

@@ -152,6 +152,9 @@ private native long nativeLink(long handle, long storeHandle, int relationOwnerE
 
     private native void nativeSetParameterAlias(long conditionHandle, String alias);
 
+    private native long nativeRelationCount(long handle, long storeHandle, int relationOwnerEntityId, int propertyId,
+                                            int relationCount);
+
     // ------------------------------ (Not)Null------------------------------
 
     private native long nativeNull(long handle, int propertyId);
@@ -582,6 +585,13 @@ public QueryBuilder<T> notNull(Property<T> property) {
         return this;
     }
 
+    public QueryBuilder<T> relationCount(RelationInfo<T, ?> relationInfo, int relationCount) {
+        verifyHandle();
+        checkCombineCondition(nativeRelationCount(handle, storeHandle, relationInfo.targetInfo.getEntityId(),
+                relationInfo.targetIdProperty.id, relationCount));
+        return this;
+    }
+
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //                                              Integers
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

objectbox-java/src/main/java/io/objectbox/query/RelationCountCondition.java

@@ -0,0 +1,20 @@
+package io.objectbox.query;
+
+import io.objectbox.relation.RelationInfo;
+
+public class RelationCountCondition<T> extends QueryConditionImpl<T> {
+
+    private final RelationInfo<T, ?> relationInfo;
+    private final int relationCount;
+
+
+    public RelationCountCondition(RelationInfo<T, ?> relationInfo, int relationCount) {
+        this.relationInfo = relationInfo;
+        this.relationCount = relationCount;
+    }
+
+    @Override
+    void apply(QueryBuilder<T> builder) {
+        builder.relationCount(relationInfo, relationCount);
+    }
+}

objectbox-java/src/main/java/io/objectbox/relation/RelationInfo.java

@@ -25,6 +25,8 @@
 import io.objectbox.annotation.apihint.Internal;
 import io.objectbox.internal.ToManyGetter;
 import io.objectbox.internal.ToOneGetter;
+import io.objectbox.query.QueryCondition;
+import io.objectbox.query.RelationCountCondition;
 
 /**
  * Meta info describing a relation including source and target entity.
@@ -130,5 +132,31 @@ public boolean isBacklink() {
     public String toString() {
         return "RelationInfo from " + sourceInfo.getEntityClass() + " to " + targetInfo.getEntityClass();
     }
+
+    /**
+     * Creates a condition to match objects that have {@code relationCount} related objects pointing to them.
+     * <pre>
+     * try (Query&lt;Customer&gt; query = customerBox
+     *         .query(Customer_.orders.relationCount(2))
+     *         .build()) {
+     *     List&lt;Customer&gt; customersWithTwoOrders = query.find();
+     * }
+     * </pre>
+     * {@code relationCount} may be 0 to match objects that do not have related objects.
+     * It typically should be a low number.
+     * <p>
+     * This condition has some limitations:
+     * <ul>
+     *     <li>only 1:N (ToMany using @Backlink) relations are supported,</li>
+     *     <li>the complexity is {@code O(n * (relationCount + 1))} and cannot be improved via indexes,</li>
+     *     <li>the relation count cannot be changed with setParameter once the query is built.</li>
+     * </ul>
+     */
+    public QueryCondition<SOURCE> relationCount(int relationCount) {
+        if (targetIdProperty == null) {
+            throw new IllegalStateException("The relation count condition is only supported for 1:N (ToMany using @Backlink) relations.");
+        }
+        return new RelationCountCondition<>(this, relationCount);
+    }
 }
 

tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryRelationCountTest.java

@@ -0,0 +1,50 @@
+package io.objectbox.query;
+
+import io.objectbox.relation.AbstractRelationTest;
+import io.objectbox.relation.Customer;
+import io.objectbox.relation.Customer_;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class QueryRelationCountTest extends AbstractRelationTest {
+
+    @Test
+    public void queryRelationCount() {
+        // Customer without orders.
+        putCustomer();
+        // Customer with 2 orders.
+        Customer customerWithOrders = putCustomer();
+        putOrder(customerWithOrders, "First order");
+        putOrder(customerWithOrders, "Second order");
+
+        // Find customer with no orders.
+        try (Query<Customer> query = customerBox
+                .query(Customer_.orders.relationCount(0))
+                .build()) {
+            List<Customer> customer = query.find();
+            assertEquals(1, customer.size());
+            assertEquals(0, customer.get(0).getOrders().size());
+        }
+
+        // Find customer with two orders.
+        try (Query<Customer> query = customerBox
+                .query(Customer_.orders.relationCount(2))
+                .build()) {
+            List<Customer> customer = query.find();
+            assertEquals(1, customer.size());
+            assertEquals(2, customer.get(0).getOrders().size());
+        }
+
+        // Find no customer with three orders.
+        try (Query<Customer> query = customerBox
+                .query(Customer_.orders.relationCount(3))
+                .build()) {
+            List<Customer> customer = query.find();
+            assertEquals(0, customer.size());
+        }
+    }
+
+}