Merge branch '10-flex-types' into dev

Author: greenrobot

objectbox/c.py

@@ -395,6 +395,7 @@ def c_voidp_as_bytes(voidp, size):
 OBXPropertyType_Date = 10
 OBXPropertyType_Relation = 11
 OBXPropertyType_DateNano = 12
+OBXPropertyType_Flex = 13
 OBXPropertyType_ByteVector = 23
 OBXPropertyType_IntVector = 26
 OBXPropertyType_LongVector = 27

objectbox/model/entity.py

@@ -14,6 +14,8 @@
 
 
 import flatbuffers
+import flatbuffers.flexbuffers
+from typing import Generic
 import numpy as np
 from math import floor
 from datetime import datetime
@@ -74,6 +76,7 @@ def fill_properties(self):
                     OBXPropertyType_LongVector,
                     OBXPropertyType_FloatVector,
                     OBXPropertyType_DoubleVector,
+                    OBXPropertyType_Flex,
                 ], "programming error - invalid type OB & FB type combination"
                 self.offset_properties.append(prop)
 
@@ -90,11 +93,13 @@ def get_value(self, object, prop: Property):
         if prop._py_type == np.ndarray:
             if (val == np.array(prop)).all():
                 return np.array([])
-        elif prop._py_type == datetime:
-            if val == prop:
-                return datetime.fromtimestamp(0)
         elif val == prop:
-            return prop._py_type()  # default (empty) value for the given type
+            if prop._py_type == datetime:
+                return datetime.fromtimestamp(0)
+            if prop._ob_type == OBXPropertyType_Flex:
+                return None
+            else:
+                return prop._py_type()  # default (empty) value for the given type
         return val
 
     def get_object_id(self, object) -> int:
@@ -122,6 +127,11 @@ def marshal(self, object, id: int) -> bytearray:
                 offsets[prop._id] = builder.CreateNumpyVector(np.array(val, dtype=np.float32))
             elif prop._ob_type == OBXPropertyType_DoubleVector:
                 offsets[prop._id] = builder.CreateNumpyVector(np.array(val, dtype=np.float64))
+            elif prop._ob_type == OBXPropertyType_Flex:
+                flex_builder = flatbuffers.flexbuffers.Builder()
+                flex_builder.Add(val)
+                buffer = flex_builder.Finish()
+                offsets[prop._id] = builder.CreateByteVector(bytes(buffer))
             else:
                 assert False, "programming error - invalid type OB & FB type combination"
 
@@ -186,6 +196,13 @@ def unmarshal(self, data: bytes):
                 val = table.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o)
             elif prop._ob_type == OBXPropertyType_DoubleVector:
                 val = table.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
+            elif prop._ob_type == OBXPropertyType_Flex:
+                # access the FB byte vector information
+                start = table.Vector(o)
+                size = table.VectorLen(o)
+                # slice the vector as bytes
+                buf = table.Bytes[start:start+size]
+                val = flatbuffers.flexbuffers.Loads(buf)
             else:
                 val = table.Get(prop._fb_type, o + table.Pos)
             if prop._py_type == list:

objectbox/model/properties.py

@@ -31,6 +31,7 @@ class PropertyType(IntEnum):
     string = OBXPropertyType_String
     date = OBXPropertyType_Date
     dateNano = OBXPropertyType_DateNano
+    flex = OBXPropertyType_Flex
     # relation = OBXPropertyType_Relation
     byteVector = OBXPropertyType_ByteVector
     intVector = OBXPropertyType_IntVector
@@ -52,6 +53,7 @@ class PropertyType(IntEnum):
     PropertyType.string: flatbuffers.number_types.UOffsetTFlags,
     PropertyType.date: flatbuffers.number_types.Int64Flags,
     PropertyType.dateNano: flatbuffers.number_types.Int64Flags,
+    PropertyType.flex: flatbuffers.number_types.UOffsetTFlags,
     # PropertyType.relation: flatbuffers.number_types.Int64Flags,
     PropertyType.byteVector: flatbuffers.number_types.UOffsetTFlags,
     PropertyType.intVector: flatbuffers.number_types.UOffsetTFlags,

tests/common.py

@@ -2,7 +2,7 @@
 import os
 import shutil
 import pytest
-from tests.model import TestEntity, TestEntityDatetime
+from tests.model import TestEntity, TestEntityDatetime, TestEntityFlex
 import numpy as np
 
 test_dir = 'testdata'
@@ -24,7 +24,7 @@ def autocleanup():
 def load_empty_test_objectbox(name: str = "") -> objectbox.ObjectBox:
     model = objectbox.Model()
     from objectbox.model import IdUid
-    model.entity(TestEntity, last_property_id=IdUid(20, 1020))
+    model.entity(TestEntity, last_property_id=IdUid(21, 1021))
     model.last_entity_id = IdUid(2, 2)
 
     db_name = test_dir if len(name) == 0 else test_dir + "/" + name
@@ -35,14 +35,25 @@ def load_empty_test_objectbox(name: str = "") -> objectbox.ObjectBox:
 def load_empty_test_datetime(name: str = "") -> objectbox.ObjectBox:
     model = objectbox.Model()
     from objectbox.model import IdUid
-    model.entity(TestEntityDatetime, last_property_id=IdUid(3, 2003))
+    model.entity(TestEntityDatetime, last_property_id=IdUid(4, 2004))
     model.last_entity_id = IdUid(2, 2)
 
     db_name = test_dir if len(name) == 0 else test_dir + "/" + name
 
     return objectbox.Builder().model(model).directory(db_name).build()
 
 
+def load_empty_test_flex(name: str = "") -> objectbox.ObjectBox:
+    model = objectbox.Model()
+    from objectbox.model import IdUid
+    model.entity(TestEntityFlex, last_property_id=IdUid(3, 3003))
+    model.last_entity_id = IdUid(3, 3)
+
+    db_name = test_dir if len(name) == 0 else test_dir + "/" + name
+
+    return objectbox.Builder().model(model).directory(db_name).build()
+
+
 def assert_equal_prop(actual, expected, default):
     assert actual == expected or (isinstance(
         expected, objectbox.model.Property) and actual == default)
@@ -75,4 +86,5 @@ def assert_equal(actual: TestEntity, expected: TestEntity):
     assert_equal_prop_approx(actual.floats_list, expected.floats_list, [])
     assert_equal_prop_approx(actual.doubles_list, expected.doubles_list, [])
     assert_equal_prop_approx(actual.date, expected.date, 0)
-    assert_equal_prop(actual.date_nano, expected.date_nano, 0)
+    assert_equal_prop(actual.date_nano, expected.date_nano, 0)
+    assert_equal_prop(actual.flex, expected.flex, None)

tests/model.py

@@ -1,6 +1,7 @@
 from objectbox.model import *
 import numpy as np
 from datetime import datetime
+from typing import Generic, Dict, Any
 
 
 @Entity(id=1, uid=1)
@@ -25,6 +26,7 @@ class TestEntity:
     doubles_list = Property(list, type=PropertyType.doubleVector, id=18, uid=1018)
     date = Property(int, type=PropertyType.date, id=19, uid=1019)
     date_nano = Property(int, type=PropertyType.dateNano, id=20, uid=1020)
+    flex = Property(Generic, type=PropertyType.flex, id=21, uid=1021)
     transient = ""  # not "Property" so it's not stored
 
     def __init__(self, string: str = ""):
@@ -38,3 +40,12 @@ class TestEntityDatetime:
 
     def __init__(self, string: str = ""):
         self.str = string
+
+@Entity(id=3, uid=3)
+class TestEntityFlex:
+    id = Id(id=1, uid=3001)
+    flex_dict = Property(Dict[str, Any], type=PropertyType.flex, id=2, uid=3002)
+    flex_int = Property(int, type=PropertyType.flex, id=3, uid=3003)
+
+    def __init__(self, string: str = ""):
+        self.str = string

tests/test_box.py

@@ -1,10 +1,11 @@
 import pytest
 import objectbox
-from tests.model import TestEntity, TestEntityDatetime
+from tests.model import TestEntity, TestEntityDatetime, TestEntityFlex
 from tests.common import (
     autocleanup,
     load_empty_test_objectbox,
     load_empty_test_datetime,
+    load_empty_test_flex,
     assert_equal,
 )
 import numpy as np
@@ -48,6 +49,7 @@ def test_box_basics():
     object.doubles_list = [99.1999, 88.2888, 77.3777, 66.4666, 55.6597555]
     object.date = time.time() * 1000  # milliseconds since UNIX epoch
     object.date_nano = time.time_ns()  # nanoseconds since UNIX epoch
+    object.flex = dict(a=1, b=2, c=3)
     object.transient = "abcd"
 
     id = box.put(object)
@@ -174,3 +176,74 @@ def test_datetime():
         box.get(1)
 
     ob.close()
+
+
+def test_flex():
+
+    def test_put_get(object: TestEntity, box: objectbox.Box, property):
+        object.flex = property
+        id = box.put(object)
+        assert id == object.id
+        read = box.get(object.id)
+        assert read.flex == object.flex
+
+    ob = load_empty_test_objectbox()
+    box = objectbox.Box(ob, TestEntity)
+    object = TestEntity()
+
+    # Put an empty object
+    id = box.put(object)
+    assert id == object.id
+
+    # Put a None type object
+    test_put_get(object, box, None)
+
+    # Update to int
+    test_put_get(object, box, 1)
+
+    # Update to float
+    test_put_get(object, box, 1.2)
+
+    # Update to string
+    test_put_get(object, box, "foo")
+
+    # Update to int list
+    test_put_get(object, box, [1, 2, 3])
+
+    # Update to float list
+    test_put_get(object, box, [1.1, 2.2, 3.3])
+
+    # Update to dict
+    test_put_get(object, box, {"a": 1, "b": 2})
+    
+    # Update to bool
+    test_put_get(object, box, True)
+
+    # Update to dict inside dict
+    test_put_get(object, box, {"a": 1, "b": {"c": 2}})
+
+    # Update to list inside dict
+    test_put_get(object, box, {"a": 1, "b": [1, 2, 3]})
+
+    ob.close()
+
+
+def test_flex_dict():
+    ob = load_empty_test_flex()
+    box = objectbox.Box(ob, TestEntityFlex)
+    object = TestEntityFlex()
+
+    # Put an empty object
+    id = box.put(object)
+    assert id == object.id
+    read = box.get(object.id)
+    assert read.flex_dict == None
+    assert read.flex_int == None
+
+    object.flex_dict = {"a": 1, "b": 2}
+    object.flex_int = 25
+    id = box.put(object)
+    assert id == object.id
+    read = box.get(object.id)
+    assert read.flex_dict == object.flex_dict
+    assert read.flex_int == object.flex_int