finish model building and start ObjectBox

Author: Ivan Dlugos

.gitignore

@@ -4,4 +4,7 @@
 # Environment
 .venv/
 
-.pytest_cache/
+.pytest_cache/
+
+# Test temporary files
+testdata/

objectbox/builder.py

@@ -1,14 +1,26 @@
-from objectbox.c import C
+from objectbox.c import *
 from objectbox.model import Model
+from objectbox.objectbox import ObjectBox
 
 
 class Builder:
     def __init__(self):
-        self.__model = Model()
+        self._model = Model()
+        self._directory: str = ''
+
+    def directory(self, path: str) -> 'Builder':
+        self._directory = path
+        return self
 
     def model(self, model: Model) -> 'Builder':
-        self.__model = model
+        self._model = model
+        self._model._finish()
         return self
 
     def build(self) -> 'ObjectBox':
-        return self
+        c_options = OBX_store_options()
+        if len(self._directory) > 0:
+            c_options.directory = c_str(self._directory)
+
+        c_store = obx_store_open(self._model._c_model, c_options.p())
+        return ObjectBox(c_store)

objectbox/c.py

@@ -1,5 +1,7 @@
 import ctypes.util
 
+# This file contains C-API bindings based on the objectbox.h, linking to the 'objectbox' shared library
+
 # initialize the C library
 C = ctypes.CDLL(ctypes.util.find_library("objectbox"))
 
@@ -40,6 +42,9 @@ class OBX_store_options(ctypes.Structure):
         ('maxReaders', ctypes.c_uint)
     ]
 
+    def p(self) -> 'ctypes.POINTER(OBX_store_options)':
+        return ctypes.pointer(self)
+
 
 OBX_store_options_p = ctypes.POINTER(OBX_store_options)
 
@@ -108,33 +113,77 @@ class OBX_query(ctypes.Structure):
 
 OBX_query_p = ctypes.POINTER(OBX_query)
 
+# manually configure error methods, we can't use `fn()` defined bellow yet due to circular dependencies
+C.obx_last_error_message.restype = ctypes.c_char_p
+C.obx_last_error_code.restype = obx_err
+
 
 class CError(Exception):
+    codes = {
+        0: "SUCCESS",
+        404: "NOT_FOUND",
+        10001: "ILLEGAL_STATE",
+        10002: "ILLEGAL_ARGUMENT",
+        10003: "ALLOCATION",
+        10097: "NO_ERROR_INFO",
+        10098: "GENERAL",
+        10099: "UNKNOWN",
+        10101: "DB_FULL",
+        10102: "MAX_READERS_EXCEEDED",
+        10103: "STORE_MUST_SHUTDOWN",
+        10199: "STORAGE_GENERAL",
+        10201: "UNIQUE_VIOLATED",
+        10202: "NON_UNIQUE_RESULT",
+        10203: "PROPERTY_TYPE_MISMATCH",
+        10299: "CONSTRAINT_VIOLATED",
+        10301: "STD_ILLEGAL_ARGUMENT",
+        10302: "STD_OUT_OF_RANGE",
+        10303: "STD_LENGTH",
+        10304: "STD_BAD_ALLOC",
+        10305: "STD_RANGE",
+        10306: "STD_OVERFLOW",
+        10399: "STD_OTHER",
+        10501: "SCHEMA",
+        10502: "FILE_CORRUPT"
+    }
+
     def __init__(self, code):
         self.code = code
-        self.message = ctypes.c_char_p(C.obx_last_error_message()).value.decode("utf8")
-        super(CError, self).__init__(self.message)
+        self.message = py_str(C.obx_last_error_message())
+        super(CError, self).__init__("%d (%s) - %s" % (code, self.codes[code], self.message))
 
 
 # check obx_err and raise an error
-def errcheck(code: obx_err, func, args):
+def check_obx_err(code: obx_err, func, args):
     if code != 0:
         raise CError(code)
 
 
+# check if the returned pointer is null and raise an error
+def check_ptr_result(result, func, args):
+    if not result:
+        raise CError(C.obx_last_error_code())
+    return result
+
+
 # creates a global function "name" with the given restype & argtypes, calling C function with the same name
 def fn(name: str, restype: type, argtypes):
     func = C.__getattr__(name)
 
-    if restype == obx_err:
-        func.errcheck = errcheck
-    else:
+    if restype is obx_err:
+        func.errcheck = check_obx_err
+    elif restype is not None:
+        func.errcheck = check_ptr_result
         func.restype = restype
 
     func.argtypes = argtypes
     return func
 
 
+def py_str(ptr: ctypes.c_char_p) -> str:
+    return ctypes.c_char_p(ptr).value.decode("utf-8")
+
+
 def c_str(string: str) -> ctypes.c_char_p:
     return string.encode('utf-8')
 
@@ -149,6 +198,28 @@ def c_str(string: str) -> ctypes.c_char_p:
 obx_model_property = fn('obx_model_property', obx_err,
                         [OBX_model_p, ctypes.c_char_p, OBXPropertyType, obx_schema_id, obx_uid])
 
+# obx_err (OBX_model* model, OBXPropertyFlags flags);
+obx_model_property_flags = fn('obx_model_property_flags', obx_err, [OBX_model_p, OBXPropertyFlags])
+
+# obx_err (OBX_model*, obx_schema_id entity_id, obx_uid entity_uid);
+obx_model_last_entity_id = fn('obx_model_last_entity_id', obx_err, [OBX_model_p, obx_schema_id, obx_uid])
+
+# obx_err (OBX_model* model, obx_schema_id index_id, obx_uid index_uid);
+obx_model_last_index_id = fn('obx_model_last_index_id', obx_err, [OBX_model_p, obx_schema_id, obx_uid])
+
+# obx_err (OBX_model* model, obx_schema_id relation_id, obx_uid relation_uid);
+obx_model_last_relation_id = fn('obx_model_last_relation_id', obx_err, [OBX_model_p, obx_schema_id, obx_uid])
+
+# obx_err (OBX_model* model, obx_schema_id property_id, obx_uid property_uid);
+obx_model_entity_last_property_id = fn('obx_model_entity_last_property_id', obx_err,
+                                       [OBX_model_p, obx_schema_id, obx_uid])
+
+# OBX_store* (OBX_model* model, const OBX_store_options* options);
+obx_store_open = fn('obx_store_open', OBX_store_p, [OBX_model_p, OBX_store_options_p])
+
+# obx_err (OBX_store* store);
+obx_store_close = fn('obx_store_close', obx_err, [OBX_store_p])
+
 OBXPropertyType_Bool = 1
 OBXPropertyType_Byte = 2
 OBXPropertyType_Short = 3
@@ -184,7 +255,6 @@ def c_str(string: str) -> ctypes.c_char_p:
 OBXDebugFlags_LOG_QUERY_PARAMETERS = 8,
 OBXDebugFlags_LOG_ASYNC_QUEUE = 16,
 
-
 # Standard put ("insert or update")
 OBXPutMode_PUT = 1,
 
@@ -198,7 +268,6 @@ def c_str(string: str) -> ctypes.c_char_p:
 # This is primarily used internally. Wrong usage leads to inconsistent data (e.g. index data not updated)!
 OBXPutMode_PUT_ID_GUARANTEED_TO_BE_NEW = 4
 
-
 # Reverts the order from ascending (default) to descending.
 OBXOrderFlags_DESCENDING = 1,
 

objectbox/model/__init__.py

@@ -5,5 +5,6 @@
 __all__ = [
     'Model',
     'Entity',
-    'Id'
+    'Id',
+    'IdUid'
 ]

objectbox/model/entity.py

@@ -32,7 +32,7 @@ def fillProperties(self):
         variables = {k: v for k, v in variables.items() if issubclass(type(v), Property)}
 
         for k, v in variables.items():
-            v.__name = k
+            v._name = k
             self.properties.append(v)
 
 

objectbox/model/model.py

@@ -11,27 +11,40 @@ def __init__(self, id: int, uid: int):
         self.id = id
         self.uid = uid
 
+    def __bool__(self):
+        return self.id != 0 or self.uid != 0
 
-class Model:
-    last_entity: IdUid
-    last_index: IdUid
-    last_relation: IdUid
-
-    retired_entity_uids: List[int]
-    retired_property_uids: List[int]
-    retired_index_uids: List[int]
-    retired_relation_uids: List[int]
 
+class Model:
     def __init__(self):
-        self.__entities: List[type] = list()
-        self.__model = obx_model_create()
+        self._entities: List[type] = list()
+        self._c_model = obx_model_create()
+        self.last_entity_id = IdUid(0, 0)
+        self.last_index_id = IdUid(0, 0)
+        self.last_relation_id = IdUid(0, 0)
 
-    def entity(self, entity: _Entity):
+    def entity(self, entity: _Entity, last_property_id: IdUid):
         if not isinstance(entity, _Entity):
             raise ValueError("Given type is not an Entity. Are you passing an instance instead of a type or did you "
                              "forget the '@Entity' annotation?")
 
-        obx_model_entity(self.__model, c_str(entity.name), entity.id, entity.uid)
+        obx_model_entity(self._c_model, c_str(entity.name), entity.id, entity.uid)
 
         for v in entity.properties:
-            obx_model_property(self.__model, c_str(v._Property__name), v._Property__ob_type, v._Property__id, v._Property__uid)
+            obx_model_property(self._c_model, c_str(v._name), v._ob_type, v._id, v._uid)
+            if v._flags != 0:
+                obx_model_property_flags(self._c_model, v._flags)
+
+
+        obx_model_entity_last_property_id(self._c_model, last_property_id.id, last_property_id.uid)
+
+    # called by Builder
+    def _finish(self):
+        if self.last_relation_id:
+            obx_model_last_relation_id(self._c_model, self.last_relation_id.id, self.last_relation_id.uid)
+
+        if self.last_index_id:
+            obx_model_last_index_id(self._c_model, self.last_index_id.id, self.last_index_id.uid)
+
+        if self.last_entity_id:
+            obx_model_last_entity_id(self._c_model, self.last_entity_id.id, self.last_entity_id.uid)

objectbox/model/properties.py

@@ -5,37 +5,43 @@
 # base property
 class Property:
     def __init__(self, py_type: type, id: int, uid: int):
-        self.__is_id = isinstance(self, Id)
-        self.__py_type = py_type
-        self.__id = id
-        self.__uid = uid
-        self.__name: str = ""  # set when in Entity.fillProperties()
+        self._is_id = isinstance(self, Id)
+        self._id = id
+        self._uid = uid
+        self._name: str = ""  # set when in Entity.fillProperties()
 
-        self.__ob_type: OBXPropertyType
-        self.__fb_type: object  # flatbuffers.number_types
-        self._set_basic_type()
+        self._py_type: type = py_type
+        self._ob_type: OBXPropertyType
+        self._fb_type: object  # flatbuffers.number_types
+        self.__set_basic_type()
 
-    def _set_basic_type(self) -> OBXPropertyType:
-        ts = self.__py_type
+        self._flags: OBXPropertyFlags = 0
+        self.__set_flags()
+
+    def __set_basic_type(self) -> OBXPropertyType:
+        ts = self._py_type
         if ts == str:
-            self.__ob_type = OBXPropertyType_String
-            self.__fb_type = flatbuffers.number_types.UOffsetTFlags
+            self._ob_type = OBXPropertyType_String
+            self._fb_type = flatbuffers.number_types.UOffsetTFlags
         elif ts == int:
-            self.__ob_type = OBXPropertyType_Long
-            self.__fb_type = flatbuffers.number_types.Int64Flags
+            self._ob_type = OBXPropertyType_Long
+            self._fb_type = flatbuffers.number_types.Int64Flags
         # TODO support
         # elif ts == bytes or ts == bytearray:
         #     self.__ob_type = OBXPropertyType_ByteVector
         #     self.__fb_type = flatbuffers.number_types.UOffsetTFlags
         elif ts == float:
-            self.__ob_type = OBXPropertyType_Double
-            self.__fb_type = flatbuffers.number_types.Float64Flags
+            self._ob_type = OBXPropertyType_Double
+            self._fb_type = flatbuffers.number_types.Float64Flags
         elif ts == bool:
-            self.__ob_type = OBXPropertyType_Bool
-            self.__fb_type = flatbuffers.number_types.BoolFlags
+            self._ob_type = OBXPropertyType_Bool
+            self._fb_type = flatbuffers.number_types.BoolFlags
         else:
             raise TypeError("unknown property type %s" % ts)
 
+    def __set_flags(self):
+        if self._is_id:
+            self._flags = OBXPropertyFlags_ID
 
 # ID property (primary key)
 class Id(Property):

objectbox/objectbox.py

@@ -0,0 +1,9 @@
+from objectbox.c import *
+
+
+class ObjectBox:
+    def __init__(self, c_store: OBX_store_p):
+        self._c_store = c_store
+
+    def __del__(self):
+        obx_store_close(self._c_store)

tests/test_basics.py

@@ -1,6 +1,37 @@
+import os
+import shutil
+
+import objectbox
 import objectbox.version
+from tests.model import TestEntity
+import pytest
+
+db_name = 'testdata'
+
+
+def remove_test_db():
+    if os.path.exists(db_name):
+        shutil.rmtree(db_name)
+
+
+# cleanup before and after each testcase
+@pytest.fixture(autouse=True)
+def run_around_tests():
+    remove_test_db()
+    yield  # run the test function
+    remove_test_db()
 
 
 def test_version():
     info = objectbox.version.version_info()
     assert len(info) > 10
+
+
+def test_open():
+    from objectbox.model import IdUid
+
+    model = objectbox.Model()
+    model.entity(TestEntity, last_property_id=IdUid(1, 1001))
+    model.last_entity_id = IdUid(1, 1)
+
+    objectbox.Builder().model(model).directory(db_name).build()