PropertyQuery: add avgLong, also update avg docs to advertise it, add tests.

Author: greenrobot-team

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

@@ -94,6 +94,8 @@ native String nativeFindString(long handle, long cursorHandle, int propertyId, b
 
     native double nativeAvg(long handle, long cursorHandle, int propertyId);
 
+    native long nativeAvgLong(long handle, long cursorHandle, int propertyId);
+
     native long nativeCount(long handle, long cursorHandle, int propertyId, boolean distinct);
 
     /** Clears all values (e.g. distinct and null value). */
@@ -448,7 +450,11 @@ public Double call() {
         });
     }
 
-    /** Calculates the average of all values for the given property over all Objects matching the query. */
+    /**
+     * Calculates the average of all values for the given number property over all Objects matching the query.
+     * <p>
+     * For integer properties you can also use {@link #avgLong()}.
+     */
     public double avg() {
         return (Double) query.callInReadTx(new Callable<Double>() {
             @Override
@@ -458,6 +464,20 @@ public Double call() {
         });
     }
 
+    /**
+     * Calculates the average of all values for the given integer property over all Objects matching the query.
+     * <p>
+     * For floating-point properties use {@link #avg()}.
+     */
+    public long avgLong() {
+        return (Long) query.callInReadTx(new Callable<Long>() {
+            @Override
+            public Long call() {
+                return nativeAvgLong(queryHandle, query.cursorHandle(), propertyId);
+            }
+        });
+    }
+
     public long count() {
         return (Long) query.callInReadTx(new Callable<Long>() {
             @Override

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

@@ -42,6 +42,9 @@ private void putTestEntityInteger(byte vByte, short vShort, int vInt, long vLong
         entity.setSimpleShort(vShort);
         entity.setSimpleInt(vInt);
         entity.setSimpleLong(vLong);
+        entity.setSimpleShortU(vShort);
+        entity.setSimpleIntU(vInt);
+        entity.setSimpleLongU(vLong);
         box.put(entity);
     }
 
@@ -479,6 +482,18 @@ public void avg_notSupported() {
         assertUnsupported(() -> query.property(simpleString).avg(), exceptionMessage);
     }
 
+    @Test
+    public void avgLong_notSupported() {
+        Query<TestEntity> query = box.query().build();
+        String exceptionMessage = "Cannot calculate sum. This function is for integer types only. This operation is not supported for Property ";
+        assertUnsupported(() -> query.property(simpleByteArray).avgLong(), exceptionMessage);
+        assertUnsupported(() -> query.property(simpleString).avgLong(), exceptionMessage);
+
+        String exceptionMessage2 = "Please use the double based average instead. This operation is not supported for Property ";
+        assertUnsupported(() -> query.property(simpleFloat).avgLong(), exceptionMessage2);
+        assertUnsupported(() -> query.property(simpleDouble).avgLong(), exceptionMessage2);
+    }
+
     @Test
     public void min_notSupported() {
         Query<TestEntity> query = box.query().build();
@@ -568,6 +583,20 @@ public void avg_noData() {
         assertEquals(Double.NaN, baseQuery.property(simpleDouble).avg(), 0.0);
     }
 
+    @Test
+    public void avgLong_noData() {
+        Query<TestEntity> baseQuery = box.query().build();
+        // Integer.
+        assertEquals(0, baseQuery.property(simpleByte).avgLong());
+        assertEquals(0, baseQuery.property(simpleShort).avgLong());
+        assertEquals(0, baseQuery.property(simpleInt).avgLong());
+        assertEquals(0, baseQuery.property(simpleLong).avgLong());
+        // Integer treated as unsigned.
+        assertEquals(0, baseQuery.property(simpleShortU).avgLong());
+        assertEquals(0, baseQuery.property(simpleIntU).avgLong());
+        assertEquals(0, baseQuery.property(simpleLongU).avgLong());
+    }
+
     @Test
     public void min_noData() {
         Query<TestEntity> baseQuery = box.query().build();
@@ -668,6 +697,39 @@ public void avg_NaN() {
         assertEquals(Double.NaN, baseQuery.property(simpleDouble).avg(), 0.001);
     }
 
+    @Test
+    public void avgLong_positiveOverflow() {
+        putTestEntityInteger((byte) 0, (short) 0, 0, Long.MAX_VALUE);
+        putTestEntityInteger((byte) 0, (short) 0, 0, 1);
+
+        Query<TestEntity> baseQuery = box.query().build();
+        assertEquals(Long.MAX_VALUE / 2 + 1, baseQuery.property(simpleLong).avgLong());
+        // Should not change if treated as unsigned.
+        assertEquals(Long.MAX_VALUE / 2 + 1, baseQuery.property(simpleLongU).avgLong());
+    }
+
+    @Test
+    public void avgLong_negativeOverflow() {
+        putTestEntityInteger((byte) 0, (short) 0, 0, Long.MIN_VALUE);
+        putTestEntityInteger((byte) 0, (short) 0, 0, -1);
+
+        Query<TestEntity> baseQuery = box.query().build();
+        assertEquals(Long.MIN_VALUE / 2, baseQuery.property(simpleLong).avgLong());
+        // Should not change if treated as unsigned.
+        assertEquals(Long.MIN_VALUE / 2, baseQuery.property(simpleLongU).avgLong());
+    }
+
+    @Test
+    public void avgLong_unsignedOverflow() {
+        putTestEntityInteger((byte) 0, (short) 0, 0, -1);
+        putTestEntityInteger((byte) 0, (short) 0, 0, 1);
+
+        Query<TestEntity> baseQuery = box.query().build();
+        assertEquals(Long.MIN_VALUE, baseQuery.property(simpleLongU).avgLong());
+        // Should be different if treated as signed.
+        assertEquals(0, baseQuery.property(simpleLong).avgLong());
+    }
+
     @Test
     public void sum_byteShortIntOverflow() {
         putTestEntityInteger(Byte.MAX_VALUE, Short.MAX_VALUE, Integer.MAX_VALUE, 0);
@@ -777,6 +839,15 @@ public void testAggregates() {
         assertEquals(2100.5, shortUQuery.avg(), 0.0001);
         assertEquals(2000.5, intUQuery.avg(), 0.0001);
         assertEquals(3000.5, longUQuery.avg(), 0.0001);
+        // avgLong
+        assertEquals(1, booleanQuery.avgLong());
+        assertEquals(-38, byteQuery.avgLong());
+        assertEquals(2101, shortQuery.avgLong());
+        assertEquals(2001, intQuery.avgLong());
+        assertEquals(3001, longQuery.avgLong());
+        assertEquals(2101, shortUQuery.avgLong());
+        assertEquals(2001, intUQuery.avgLong());
+        assertEquals(3001, longUQuery.avgLong());
         // min
         assertEquals(-38, byteQuery.min());
         assertEquals(2100, shortQuery.min());