feat: support all objectbox numeric types

Author: vaind

objectbox/model/__init__.py

@@ -22,5 +22,6 @@
     'Entity',
     'Id',
     'IdUid',
-    'Property'
+    'Property',
+    'PropertyType'
 ]

objectbox/model/entity.py

@@ -64,6 +64,8 @@ def fill_properties(self):
                     "programming error - invalid type OB & FB type combination"
                 self.offset_properties.append(prop)
 
+            # print('Property {}.{}: {} (ob:{} fb:{})'.format(self.name, prop._name, prop._py_type, prop._ob_type, prop._fb_type))
+
         if not self.id_property:
             raise Exception("ID property is not defined")
         elif self.id_property._ob_type != OBXPropertyType_Long:

objectbox/model/properties.py

@@ -12,22 +12,54 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from enum import IntEnum
 
 from objectbox.c import *
 import flatbuffers.number_types
 
 
-# base property
+class PropertyType(IntEnum):
+    bool = OBXPropertyType_Bool
+    byte = OBXPropertyType_Byte
+    short = OBXPropertyType_Short
+    char = OBXPropertyType_Char
+    int = OBXPropertyType_Int
+    long = OBXPropertyType_Long
+    float = OBXPropertyType_Float
+    double = OBXPropertyType_Double
+    string = OBXPropertyType_String
+    # date = OBXPropertyType_Date
+    # relation = OBXPropertyType_Relation
+    byteVector = OBXPropertyType_ByteVector
+    # stringVector = OBXPropertyType_StringVector
+
+
+fb_type_map = {
+    PropertyType.bool: flatbuffers.number_types.BoolFlags,
+    PropertyType.byte: flatbuffers.number_types.Int8Flags,
+    PropertyType.short: flatbuffers.number_types.Int16Flags,
+    PropertyType.char: flatbuffers.number_types.Int8Flags,
+    PropertyType.int: flatbuffers.number_types.Int32Flags,
+    PropertyType.long: flatbuffers.number_types.Int64Flags,
+    PropertyType.float: flatbuffers.number_types.Float32Flags,
+    PropertyType.double: flatbuffers.number_types.Float64Flags,
+    PropertyType.string: flatbuffers.number_types.UOffsetTFlags,
+    # PropertyType.date: flatbuffers.number_types.Int64Flags,
+    # PropertyType.relation: flatbuffers.number_types.Int64Flags,
+    PropertyType.byteVector: flatbuffers.number_types.UOffsetTFlags,
+    # PropertyType.stringVector: flatbuffers.number_types.UOffsetTFlags,
+}
+
+
 class Property:
-    def __init__(self, py_type: type, id: int, uid: int):
+    def __init__(self, py_type: type, id: int, uid: int, type: PropertyType = None):
         self._id = id
         self._uid = uid
-        self._name = ""  # set in Entity.fillProperties()
+        self._name = ""  # set in Entity.fill_properties()
 
-        self._fb_type = None  # flatbuffers.number_types
         self._py_type = py_type
-        self._ob_type = OBXPropertyType(0)
-        self.__set_basic_type()
+        self._ob_type: OBXPropertyType = type if type != None else self.__determine_ob_type()
+        self._fb_type = fb_type_map[self._ob_type]
 
         self._is_id = isinstance(self, Id)
         self._flags = OBXPropertyFlags(0)
@@ -37,23 +69,18 @@ def __init__(self, py_type: type, id: int, uid: int):
         self._fb_slot = self._id - 1
         self._fb_v_offset = 4 + 2*self._fb_slot
 
-    def __set_basic_type(self) -> OBXPropertyType:
+    def __determine_ob_type(self) -> OBXPropertyType:
         ts = self._py_type
         if ts == str:
-            self._ob_type = OBXPropertyType_String
-            self._fb_type = flatbuffers.number_types.UOffsetTFlags
+            return OBXPropertyType_String
         elif ts == int:
-            self._ob_type = OBXPropertyType_Long
-            self._fb_type = flatbuffers.number_types.Int64Flags
+            return OBXPropertyType_Long
         elif ts == bytes:  # or ts == bytearray: might require further tests on read objects due to mutability
-            self._ob_type = OBXPropertyType_ByteVector
-            self._fb_type = flatbuffers.number_types.UOffsetTFlags
+            return OBXPropertyType_ByteVector
         elif ts == float:
-            self._ob_type = OBXPropertyType_Double
-            self._fb_type = flatbuffers.number_types.Float64Flags
+            return OBXPropertyType_Double
         elif ts == bool:
-            self._ob_type = OBXPropertyType_Bool
-            self._fb_type = flatbuffers.number_types.BoolFlags
+            return OBXPropertyType_Bool
         else:
             raise Exception("unknown property type %s" % ts)
 

tests/common.py

@@ -23,20 +23,26 @@ 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(6, 1006))
+    model.entity(TestEntity, last_property_id=IdUid(10, 1010))
     model.last_entity_id = IdUid(1, 1)
 
     db_name = test_dir if len(name) == 0 else test_dir + "/" + name
 
     return objectbox.Builder().model(model).directory(db_name).build()
 
 
-def assert_equal(actual, expected):
+def assert_equal_prop(actual, expected, default):
+    assert actual == expected or (isinstance(
+        expected, objectbox.model.Property) and actual == default)
+
+
+def assert_equal(actual: TestEntity, expected: TestEntity):
     """Check that two TestEntity objects have the same property data"""
     assert actual.id == expected.id
-    assert isinstance(expected.bool, objectbox.model.Property) or actual.bool == expected.bool
-    assert isinstance(expected.int, objectbox.model.Property) or actual.int == expected.int
-    assert isinstance(expected.str, objectbox.model.Property) or actual.str == expected.str
-    assert isinstance(expected.float, objectbox.model.Property) or actual.float == expected.float
-    assert isinstance(expected.bytes, objectbox.model.Property) or actual.bytes == expected.bytes
-
+    assert_equal_prop(actual.int64, expected.int64, 0)
+    assert_equal_prop(actual.int32, expected.int32, 0)
+    assert_equal_prop(actual.int16, expected.int16, 0)
+    assert_equal_prop(actual.int8, expected.int8, 0)
+    assert_equal_prop(actual.float64, expected.float64, 0)
+    assert_equal_prop(actual.float32, expected.float32, 0)
+    assert_equal_prop(actual.bytes, expected.bytes, b'')

tests/model.py

@@ -6,9 +6,13 @@ class TestEntity:
     id = Id(id=1, uid=1001)
     str = Property(str, id=2, uid=1002)
     bool = Property(bool, id=3, uid=1003)
-    int = Property(int, id=4, uid=1004)
-    float = Property(float, id=5, uid=1005)
-    bytes = Property(bytes, id=6, uid=1006)
+    int64 = Property(int, type=PropertyType.long, id=4, uid=1004)
+    int32 = Property(int, type=PropertyType.int, id=5, uid=1005)
+    int16 = Property(int, type=PropertyType.short, id=6, uid=1006)
+    int8 = Property(int, type=PropertyType.byte, id=7, uid=1007)
+    float64 = Property(float, type=PropertyType.double, id=8, uid=1008)
+    float32 = Property(float, type=PropertyType.float, id=9, uid=1009)
+    bytes = Property(bytes, id=10, uid=1010)
     transient = ""  # not "Property" so it's not stored
 
     def __init__(self, string: str = ""):

tests/test_box.py

@@ -21,9 +21,13 @@ def test_box_basics():
     object = TestEntity()
     object.id = 5
     object.bool = True
-    object.int = 42
+    object.int64 = 9223372036854775807
+    object.int32 = 2147483647
+    object.int16 = 32767
+    object.int8 = 127
     object.str = "foo"
-    object.float = 4.2
+    object.float64 = 4.2
+    object.float32 = 1.5
     object.bytes = bytes([1, 1, 2, 3, 5])
     object.transient = "abcd"
 
@@ -67,7 +71,8 @@ def test_box_bulk():
 
     box.put(TestEntity("first"))
 
-    objects = [TestEntity("second"), TestEntity("third"), TestEntity("fourth"), box.get(1)]
+    objects = [TestEntity("second"), TestEntity("third"),
+               TestEntity("fourth"), box.get(1)]
     box.put(objects)
     assert box.count() == 4
     assert objects[0].id == 2