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