Merge branch 'string-array-support' into release-3.0.0-alpha2

Author: greenrobot-team

objectbox-java/src/main/java/io/objectbox/Cursor.java

@@ -106,6 +106,10 @@ protected static native long collect004000(long cursor, long keyIfComplete, int
                                                int idLong3, long valueLong3, int idLong4, long valueLong4
     );
 
+    protected static native long collectStringArray(long cursor, long keyIfComplete, int flags,
+                                                    int idStringArray, String[] stringArray
+    );
+
     native int nativePropertyId(long cursor, String propertyValue);
 
     native List nativeGetBacklinkEntities(long cursor, int entityId, int propertyId, long key);

tests/objectbox-java-test/src/main/java/io/objectbox/TestEntity.java

@@ -32,6 +32,8 @@ public class TestEntity {
     private String simpleString;
     /** Not-null value. */
     private byte[] simpleByteArray;
+    /** Not-null value. */
+    private String[] simpleStringArray;
     /** In "real" entity would be annotated with @Unsigned. */
     private short simpleShortU;
     /** In "real" entity would be annotated with @Unsigned. */
@@ -49,7 +51,7 @@ public TestEntity(long id) {
         this.id = id;
     }
 
-    public TestEntity(long id, boolean simpleBoolean, byte simpleByte, short simpleShort, int simpleInt, long simpleLong, float simpleFloat, double simpleDouble, String simpleString, byte[] simpleByteArray, short simpleShortU, int simpleIntU, long simpleLongU) {
+    public TestEntity(long id, boolean simpleBoolean, byte simpleByte, short simpleShort, int simpleInt, long simpleLong, float simpleFloat, double simpleDouble, String simpleString, byte[] simpleByteArray, String[] simpleStringArray, short simpleShortU, int simpleIntU, long simpleLongU) {
         this.id = id;
         this.simpleBoolean = simpleBoolean;
         this.simpleByte = simpleByte;
@@ -60,6 +62,7 @@ public TestEntity(long id, boolean simpleBoolean, byte simpleByte, short simpleS
         this.simpleDouble = simpleDouble;
         this.simpleString = simpleString;
         this.simpleByteArray = simpleByteArray;
+        this.simpleStringArray = simpleStringArray;
         this.simpleShortU = simpleShortU;
         this.simpleIntU = simpleIntU;
         this.simpleLongU = simpleLongU;
@@ -149,6 +152,15 @@ public void setSimpleByteArray(byte[] simpleByteArray) {
         this.simpleByteArray = simpleByteArray;
     }
 
+    /** Not-null value. */
+    public String[] getSimpleStringArray() {
+        return simpleStringArray;
+    }
+
+    /** Not-null value; ensure this value is available before it is saved to the database. */
+    public void setSimpleStringArray(String[] simpleStringArray) {
+        this.simpleStringArray = simpleStringArray;
+    }
     public short getSimpleShortU() {
         return simpleShortU;
     }

tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityCursor.java

@@ -51,6 +51,7 @@ public Cursor<TestEntity> createCursor(io.objectbox.Transaction tx, long cursorH
     private final static int __ID_simpleDouble = TestEntity_.simpleDouble.id;
     private final static int __ID_simpleString = TestEntity_.simpleString.id;
     private final static int __ID_simpleByteArray = TestEntity_.simpleByteArray.id;
+    private final static int __ID_simpleStringArray = TestEntity_.simpleStringArray.id;
     private final static int __ID_simpleShortU = TestEntity_.simpleShortU.id;
     private final static int __ID_simpleIntU = TestEntity_.simpleIntU.id;
     private final static int __ID_simpleLongU = TestEntity_.simpleLongU.id;
@@ -71,12 +72,18 @@ public final long getId(TestEntity entity) {
      */
     @Override
     public final long put(TestEntity entity) {
+        String[] simpleStringArray = entity.getSimpleStringArray();
+        int __id10 = simpleStringArray != null ? __ID_simpleStringArray : 0;
+
+        collectStringArray(cursor, 0, PUT_FLAG_FIRST,
+                __id10, simpleStringArray);
+
         String simpleString = entity.getSimpleString();
         int __id8 = simpleString != null ? __ID_simpleString : 0;
         byte[] simpleByteArray = entity.getSimpleByteArray();
         int __id9 = simpleByteArray != null ? __ID_simpleByteArray : 0;
 
-        collect313311(cursor, 0, PUT_FLAG_FIRST,
+        collect313311(cursor, 0, 0,
                 __id8, simpleString, 0, null,
                 0, null, __id9, simpleByteArray,
                 __ID_simpleLong, entity.getSimpleLong(), __ID_simpleLongU, entity.getSimpleLongU(),

tests/objectbox-java-test/src/main/java/io/objectbox/TestEntity_.java

@@ -77,14 +77,17 @@ public final class TestEntity_ implements EntityInfo<TestEntity> {
     public final static io.objectbox.Property<TestEntity> simpleByteArray =
             new io.objectbox.Property<>(__INSTANCE, 9, 10, byte[].class, "simpleByteArray");
 
+    public final static io.objectbox.Property<TestEntity> simpleStringArray =
+            new io.objectbox.Property<>(__INSTANCE, 10, 11, String[].class, "simpleStringArray", false, "simpleStringArray");
+
     public final static io.objectbox.Property<TestEntity> simpleShortU =
-            new io.objectbox.Property<>(__INSTANCE, 10, 11, short.class, "simpleShortU");
+            new io.objectbox.Property<>(__INSTANCE, 11, 12, short.class, "simpleShortU");
 
     public final static io.objectbox.Property<TestEntity> simpleIntU =
-            new io.objectbox.Property<>(__INSTANCE, 11, 12, int.class, "simpleIntU");
+            new io.objectbox.Property<>(__INSTANCE, 12, 13, int.class, "simpleIntU");
 
     public final static io.objectbox.Property<TestEntity> simpleLongU =
-            new io.objectbox.Property<>(__INSTANCE, 12, 13, long.class, "simpleLongU");
+            new io.objectbox.Property<>(__INSTANCE, 13, 14, long.class, "simpleLongU");
 
     @SuppressWarnings("unchecked")
     public final static io.objectbox.Property<TestEntity>[] __ALL_PROPERTIES = new io.objectbox.Property[]{
@@ -98,6 +101,7 @@ public final class TestEntity_ implements EntityInfo<TestEntity> {
             simpleDouble,
             simpleString,
             simpleByteArray,
+            simpleStringArray,
             simpleShortU,
             simpleIntU,
             simpleLongU

tests/objectbox-java-test/src/test/java/io/objectbox/AbstractObjectBoxTest.java

@@ -34,6 +34,8 @@
 import io.objectbox.model.PropertyFlags;
 import io.objectbox.model.PropertyType;
 
+
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
@@ -197,6 +199,7 @@ private void addTestEntity(ModelBuilder modelBuilder, boolean withIndex) {
             pb.flags(PropertyFlags.INDEXED).indexId(++lastIndexId, lastIndexUid);
         }
         entityBuilder.property("simpleByteArray", PropertyType.ByteVector).id(TestEntity_.simpleByteArray.id, ++lastUid);
+        entityBuilder.property("simpleStringArray", PropertyType.StringVector).id(TestEntity_.simpleStringArray.id, ++lastUid);
 
         // Unsigned integers.
         entityBuilder.property("simpleShortU", PropertyType.Short).id(TestEntity_.simpleShortU.id, ++lastUid)
@@ -241,12 +244,34 @@ protected TestEntity createTestEntity(@Nullable String simpleString, int nr) {
         entity.setSimpleFloat(200 + nr / 10f);
         entity.setSimpleDouble(2000 + nr / 100f);
         entity.setSimpleByteArray(new byte[]{1, 2, (byte) nr});
+        entity.setSimpleStringArray(new String[]{simpleString});
         entity.setSimpleShortU((short) (100 + nr));
         entity.setSimpleIntU(nr);
         entity.setSimpleLongU(1000 + nr);
         return entity;
     }
 
+    /**
+     * Asserts all properties, excluding id. Assumes entity was created with {@link #createTestEntity(String, int)}.
+     */
+    protected void assertTestEntity(TestEntity actual, @Nullable String simpleString, int nr) {
+        assertEquals(simpleString, actual.getSimpleString());
+        assertEquals(nr, actual.getSimpleInt());
+        assertEquals((byte) (10 + nr), actual.getSimpleByte());
+        assertEquals(nr % 2 == 0, actual.getSimpleBoolean());
+        assertEquals((short) (100 + nr), actual.getSimpleShort());
+        assertEquals(1000 + nr, actual.getSimpleLong());
+        assertEquals(200 + nr / 10f, actual.getSimpleFloat(), 0);
+        assertEquals(2000 + nr / 100f, actual.getSimpleDouble(), 0);
+        assertArrayEquals(new byte[]{1, 2, (byte) nr}, actual.getSimpleByteArray());
+        // null array items are ignored, so array will be empty
+        String[] expectedStringArray = simpleString == null ? new String[]{} : new String[]{simpleString};
+        assertArrayEquals(expectedStringArray, actual.getSimpleStringArray());
+        assertEquals((short) (100 + nr), actual.getSimpleShortU());
+        assertEquals(nr, actual.getSimpleIntU());
+        assertEquals(1000 + nr, actual.getSimpleLongU());
+    }
+
     protected TestEntity putTestEntity(@Nullable String simpleString, int nr) {
         TestEntity entity = createTestEntity(simpleString, nr);
         long key = getTestEntityBox().put(entity);

tests/objectbox-java-test/src/test/java/io/objectbox/BoxTest.java

@@ -37,15 +37,46 @@ public void setUpBox() {
 
     @Test
     public void testPutAndGet() {
-        TestEntity entity = new TestEntity();
-        entity.setSimpleInt(1977);
+        final String simpleString = "sunrise";
+        final int simpleInt = 1977;
+
+        TestEntity entity = createTestEntity(simpleString, simpleInt);
         long key = box.put(entity);
         assertTrue(key != 0);
         assertEquals(key, entity.getId());
 
         TestEntity entityRead = box.get(key);
         assertNotNull(entityRead);
-        assertEquals(1977, entityRead.getSimpleInt());
+        assertEquals(key, entityRead.getId());
+        assertTestEntity(entityRead, simpleString, simpleInt);
+    }
+
+    @Test
+    public void testPutStringArray_withNull_ignoresNull() {
+        final String[] stringArray = new String[]{"sunrise", null, "sunset"};
+        final String[] expectedStringArray = new String[]{"sunrise", "sunset"};
+
+        TestEntity entity = new TestEntity();
+        entity.setSimpleStringArray(stringArray);
+        box.put(entity);
+
+        TestEntity entityRead = box.get(entity.getId());
+        assertNotNull(entityRead);
+        assertArrayEquals(expectedStringArray, entityRead.getSimpleStringArray());
+    }
+
+    @Test
+    public void testPutStringArray_onlyNull_isEmpty() {
+        final String[] stringArray = new String[]{null};
+        final String[] expectedStringArray = new String[]{};
+
+        TestEntity entity = new TestEntity();
+        entity.setSimpleStringArray(stringArray);
+        box.put(entity);
+
+        TestEntity entityRead = box.get(entity.getId());
+        assertNotNull(entityRead);
+        assertArrayEquals(expectedStringArray, entityRead.getSimpleStringArray());
     }
 
     @Test

tests/objectbox-java-test/src/test/java/io/objectbox/NonArgConstructorTest.java

@@ -19,12 +19,11 @@
 import org.junit.Before;
 import org.junit.Test;
 
-import java.util.Arrays;
-
 import io.objectbox.ModelBuilder.EntityBuilder;
 import io.objectbox.model.EntityFlags;
 
 
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
@@ -56,6 +55,8 @@ public void testPutAndGet() {
         entity.setSimpleLong(789437444354L);
         entity.setSimpleShort((short) 233);
         entity.setSimpleString("foo");
+        String[] strings = {"foo", "bar"};
+        entity.setSimpleStringArray(strings);
         long key = box.put(entity);
 
         TestEntity entityRead = box.get(key);
@@ -68,8 +69,9 @@ public void testPutAndGet() {
         assertEquals(789437444354L, entityRead.getSimpleLong());
         assertEquals(3.14f, entityRead.getSimpleFloat(), 0.000001f);
         assertEquals(3.141f, entityRead.getSimpleDouble(), 0.000001);
-        assertTrue(Arrays.equals(bytes, entityRead.getSimpleByteArray()));
+        assertArrayEquals(bytes, entityRead.getSimpleByteArray());
         assertEquals("foo", entityRead.getSimpleString());
+        assertArrayEquals(strings, entityRead.getSimpleStringArray());
     }
 
 }

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

@@ -47,6 +47,7 @@
 import static io.objectbox.TestEntity_.simpleLong;
 import static io.objectbox.TestEntity_.simpleShort;
 import static io.objectbox.TestEntity_.simpleString;
+import static io.objectbox.TestEntity_.simpleStringArray;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
@@ -243,6 +244,16 @@ public void testString() {
         assertEquals(2, box.query().contains(simpleString, "nana").build().count());
     }
 
+    @Test
+    public void testStringArray() {
+        putTestEntitiesStrings();
+        // contains(prop, value) matches if value is equal to one of the array items.
+        // Verify by not matching entity where 'banana' is only a substring of an array item ('banana milk shake').
+        List<TestEntity> results = box.query().contains(simpleStringArray, "banana").build().find();
+        assertEquals(1, results.size());
+        assertEquals("banana", results.get(0).getSimpleStringArray()[0]);
+    }
+
     @Test
     public void testStringLess() {
         putTestEntitiesStrings();