Query: sort using Comparator

Author: greenrobot

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

@@ -1,5 +1,7 @@
 package io.objectbox.query;
 
+import java.util.Collections;
+import java.util.Comparator;
 import java.util.Date;
 import java.util.Iterator;
 import java.util.List;
@@ -75,16 +77,19 @@ native static void nativeSetParameters(long handle, int propertyId, String param
     private final QueryPublisher<T> publisher;
     private final List<EagerRelation> eagerRelations;
     private final QueryFilter<T> filter;
+    private final Comparator<T> comparator;
     long handle;
 
-    Query(Box<T> box, long queryHandle, boolean hasOrder, List<EagerRelation> eagerRelations, QueryFilter<T> filter) {
+    Query(Box<T> box, long queryHandle, boolean hasOrder, List<EagerRelation> eagerRelations, QueryFilter<T> filter,
+          Comparator<T> comparator) {
         this.box = box;
         store = box.getStore();
         handle = queryHandle;
         this.hasOrder = hasOrder;
         publisher = new QueryPublisher<>(this, box);
         this.eagerRelations = eagerRelations;
         this.filter = filter;
+        this.comparator = comparator;
     }
 
     @Override
@@ -108,7 +113,7 @@ public synchronized void close() {
      */
     @Nullable
     public T findFirst() {
-        ensureNoFilter();
+        ensureNoFilterNoComparator();
         return store.callInReadTx(new Callable<T>() {
             @Override
             public T call() {
@@ -120,11 +125,19 @@ public T call() {
         });
     }
 
-    private void ensureNoFilter() {
+    private void ensureNoFilterNoComparator() {
         if (filter != null) {
             throw new UnsupportedOperationException("Does not yet work with a filter yet. " +
                     "At this point, only find() and forEach() are supported with filters.");
         }
+        ensureNoComparator();
+    }
+
+    private void ensureNoComparator() {
+        if (comparator != null) {
+            throw new UnsupportedOperationException("Does not yet work with a sorting comparator yet. " +
+                    "At this point, only find() is supported with sorting comparators.");
+        }
     }
 
     /**
@@ -134,7 +147,7 @@ private void ensureNoFilter() {
      */
     @Nullable
     public T findUnique() {
-        ensureNoFilter();
+        ensureNoFilterNoComparator();
         return store.callInReadTx(new Callable<T>() {
             @Override
             public T call() {
@@ -166,6 +179,9 @@ public List<T> call() throws Exception {
                     }
                 }
                 resolveEagerRelations(entities);
+                if (comparator != null) {
+                    Collections.sort(entities, comparator);
+                }
                 return entities;
             }
         });
@@ -176,7 +192,7 @@ public List<T> call() throws Exception {
      */
     @Nonnull
     public List<T> find(final long offset, final long limit) {
-        ensureNoFilter();
+        ensureNoFilterNoComparator();
         return store.callInReadTx(new Callable<List<T>>() {
             @Override
             public List<T> call() {
@@ -191,7 +207,7 @@ public List<T> call() {
     /**
      * Very efficient way to get just the IDs without creating any objects. IDs can later be used to lookup objects
      * (lookups by ID are also very efficient in ObjectBox).
-     *
+     * <p>
      * Note: a filter set with {@link QueryBuilder#filter} will be silently ignored!
      */
     @Nonnull
@@ -211,7 +227,7 @@ public long[] call(long cursorHandle) {
      * Find all Objects matching the query without actually loading the Objects. See @{@link LazyList} for details.
      */
     public LazyList<T> findLazy() {
-        ensureNoFilter();
+        ensureNoFilterNoComparator();
         return new LazyList<>(box, findIds(), false);
     }
 
@@ -225,6 +241,7 @@ public LazyList<T> findLazy() {
      * Note: because the consumer is called within a read transaction it may not write to the database.
      */
     public void forEach(final QueryConsumer<T> consumer) {
+        ensureNoComparator();
         box.getStore().runInReadTx(new Runnable() {
             @Override
             public void run() {
@@ -258,7 +275,7 @@ public void run() {
      */
     @Nonnull
     public LazyList<T> findLazyCached() {
-        ensureNoFilter();
+        ensureNoFilterNoComparator();
         return new LazyList<>(box, findIds(), true);
     }
 

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

@@ -1,6 +1,7 @@
 package io.objectbox.query;
 
 import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.Date;
 import java.util.List;
 
@@ -78,6 +79,8 @@ enum Operator {
 
     private QueryFilter<T> filter;
 
+    private Comparator<T> comparator;
+
     private static native long nativeCreate(long storeHandle, String entityName);
 
     private static native void nativeDestroy(long handle);
@@ -159,7 +162,7 @@ public Query<T> build() {
             throw new IllegalStateException("Incomplete logic condition. Use or()/and() between two conditions only.");
         }
         long queryHandle = nativeBuild(handle);
-        Query<T> query = new Query<>(box, queryHandle, hasOrder, eagerRelations, filter);
+        Query<T> query = new Query<>(box, queryHandle, hasOrder, eagerRelations, filter, comparator);
         close();
         return query;
     }
@@ -215,6 +218,11 @@ public QueryBuilder<T> order(Property property, int flags) {
         return this;
     }
 
+    public QueryBuilder<T> sort(Comparator<T> comparator) {
+        this.comparator = comparator;
+        return this;
+    }
+
     /**
      * Specifies relations that should be resolved eagerly.
      * This prepares the given relation objects to be preloaded (cached) avoiding further get operations from the db.

tests/objectbox-java-test/src/main/java/io/objectbox/query/QueryTest.java

@@ -20,23 +20,16 @@
 import org.junit.Test;
 
 import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.List;
 
 import io.objectbox.AbstractObjectBoxTest;
 import io.objectbox.Box;
 import io.objectbox.TestEntity;
 import io.objectbox.query.QueryBuilder.StringOrder;
 
-
-import static io.objectbox.TestEntity_.simpleBoolean;
-import static io.objectbox.TestEntity_.simpleFloat;
-import static io.objectbox.TestEntity_.simpleInt;
-import static io.objectbox.TestEntity_.simpleLong;
-import static io.objectbox.TestEntity_.simpleShort;
-import static io.objectbox.TestEntity_.simpleString;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
+import static io.objectbox.TestEntity_.*;
+import static org.junit.Assert.*;
 
 public class QueryTest extends AbstractObjectBoxTest {
 
@@ -422,6 +415,23 @@ public void testFindWithFilter() {
         assertEquals("banana milk shake", entities.get(1).getSimpleString());
     }
 
+    @Test
+    public void testFindWithComparator() {
+        putTestEntitiesStrings();
+        List<TestEntity> entities = box.query().sort(new Comparator<TestEntity>() {
+            @Override
+            public int compare(TestEntity o1, TestEntity o2) {
+                return o1.getSimpleString().substring(1).compareTo(o2.getSimpleString().substring(1));
+            }
+        }).build().find();
+        assertEquals(5, entities.size());
+        assertEquals("banana", entities.get(0).getSimpleString());
+        assertEquals("banana milk shake", entities.get(1).getSimpleString());
+        assertEquals("bar", entities.get(2).getSimpleString());
+        assertEquals("foo bar", entities.get(3).getSimpleString());
+        assertEquals("apple", entities.get(4).getSimpleString());
+    }
+
     private QueryFilter<TestEntity> createTestFilter() {
         return new QueryFilter<TestEntity>() {
             @Override