Merge branch '64-add-box-methods' into dev

Author: greenrobot

objectbox/box.py

@@ -31,6 +31,12 @@ def __init__(self, store: Store, entity: _Entity):
         self._entity = entity
         self._c_box = obx_box(store._c_store, entity._id)
 
+    def contains(self, object_id: int) -> bool:
+        """Checks whether the box contains the given object ID."""
+        contained = ctypes.c_bool()
+        obx_box_contains(self._c_box, object_id, ctypes.byref(contained))
+        return bool(contained.value)
+
     def is_empty(self) -> bool:
         """Returns true if box is empty (i.e. no objects of entity type are available)."""
         is_empty = ctypes.c_bool()
@@ -112,6 +118,16 @@ def _put_many(self, objects) -> None:
         for k in new.keys():
             self._entity._set_object_id(objects[k], ids[k])
 
+    def update(self, object_):
+        """Updates the existing object having the same ID as the given object.
+
+        Raises if the object has no ID (i.e. it was never put) or the ID doesn't match any stored object."""
+        object_id = self._entity._get_object_id(object_)
+        if not object_id:
+            raise ValueError("Cannot update an object without an ID; use put() for new objects")
+        data = self._entity._marshal(object_, object_id)
+        obx_box_update(self._c_box, object_id, bytes(data), len(data))
+
     def get(self, id: int):
         """Get object by given Id or None if not found."""
         with self._store.read_tx():
@@ -126,6 +142,36 @@ def get(self, id: int):
             data = c_voidp_as_bytes(c_data, c_size.value)
             return self._entity._unmarshal(data)
 
+    def get_many(self, id_array: List[int]) -> list:
+        """Gets objects matching the given ID list.
+
+        :return: objects matching the ID list, preserving the order.
+            If an invalid ID is supplied, the corresponding object is None.
+        """
+
+        if not id_array:  # Empty
+            return []
+
+        c_ids = (obx_id * len(id_array))(*id_array)
+        c_id_array = OBX_id_array(ctypes.cast(c_ids, ctypes.POINTER(obx_id)), len(id_array))
+
+        with self._store.read_tx():
+            c_bytes_array_p = obx_box_get_many(self._c_box, ctypes.byref(c_id_array))
+
+            result = []
+            try:
+                c_bytes_array = c_bytes_array_p.contents
+                for i in range(c_bytes_array.count):
+                    c_bytes = c_bytes_array.data[i]
+                    if c_bytes.data is None or c_bytes.size == 0:  # User supplied an invalid ID
+                        result.append(None)
+                    else:
+                        data = c_voidp_as_bytes(c_bytes.data, c_bytes.size)
+                        result.append(self._entity._unmarshal(data))
+            finally:
+                obx_bytes_array_free(c_bytes_array_p)
+            return result
+
     def get_all(self) -> list:
         """Get all objects."""
         with self._store.read_tx():

objectbox/c.py

@@ -87,6 +87,8 @@ def shlib_name(library: str) -> str:
 OBXLogLevel = ctypes.c_int
 
 from enum import IntEnum
+
+
 class LogLevel(IntEnum):
     Verbose = 10
     Debug   = 20
@@ -581,7 +583,7 @@ def c_array_pointer(py_list: Union[List[Any], np.ndarray], c_type):
 obx_opt_async_object_bytes_max_size_to_cache = c_fn('obx_opt_async_object_bytes_max_size_to_cache', None,
                                                     [OBX_store_options_p, ctypes.c_uint64])
 
-#typedef void obx_log_callback(OBXLogLevel log_level, const char* message, size_t message_size, void* user_data);
+# typedef void obx_log_callback(OBXLogLevel log_level, const char* message, size_t message_size, void* user_data);
 obx_log_callback_fn = ctypes.CFUNCTYPE(None, OBXLogLevel, ctypes.c_char_p, ctypes.c_size_t, ctypes.c_voidp)
 
 # OBX_C_API void obx_opt_log_callback(OBX_store_options* opt, obx_log_callback* callback, void* user_data);
@@ -633,10 +635,16 @@ def c_array_pointer(py_list: Union[List[Any], np.ndarray], c_type):
 # OBX_box* (OBX_store* store, obx_schema_id entity_id);
 obx_box = c_fn('obx_box', OBX_box_p, [OBX_store_p, obx_schema_id])
 
+# OBX_C_API obx_err obx_box_contains(OBX_box* box, obx_id id, bool* out_contains);
+obx_box_contains = c_fn_rc('obx_box_contains', [OBX_box_p, obx_id, ctypes.POINTER(ctypes.c_bool)])
+
 # obx_err (OBX_box* box, obx_id id, const void** data, size_t* size);
 obx_box_get = c_fn_nocheck('obx_box_get', obx_err, [
     OBX_box_p, obx_id, ctypes.POINTER(ctypes.c_void_p), ctypes.POINTER(ctypes.c_size_t)])
 
+# OBX_C_API OBX_bytes_array* obx_box_get_many(OBX_box* box, const OBX_id_array* ids);
+obx_box_get_many = c_fn('obx_box_get_many', OBX_bytes_array_p, [OBX_box_p, OBX_id_array_p])
+
 # OBX_bytes_array* (OBX_box* box);
 obx_box_get_all = c_fn('obx_box_get_all', OBX_bytes_array_p, [OBX_box_p])
 
@@ -650,24 +658,29 @@ def c_array_pointer(py_list: Union[List[Any], np.ndarray], c_type):
 # obx_err (OBX_box* box, obx_id id, const void* data, size_t size);
 obx_box_put = c_fn_rc('obx_box_put', [OBX_box_p, obx_id, ctypes.c_void_p, ctypes.c_size_t])
 
+# OBX_C_API obx_err obx_box_insert(OBX_box* box, obx_id id, const void* data, size_t size);
+obx_box_insert = c_fn_rc('obx_box_insert', [OBX_box_p, obx_id, ctypes.c_void_p, ctypes.c_size_t])
+
+# OBX_C_API obx_err obx_box_update(OBX_box* box, obx_id id, const void* data, size_t size);
+obx_box_update = c_fn_rc('obx_box_update', [OBX_box_p, obx_id, ctypes.c_void_p, ctypes.c_size_t])
+
 # obx_err (OBX_box* box, const OBX_bytes_array* objects, const obx_id* ids, OBXPutMode mode);
-obx_box_put_many = c_fn_rc('obx_box_put_many', [
-    OBX_box_p, OBX_bytes_array_p, ctypes.POINTER(obx_id), OBXPutMode])
+obx_box_put_many = c_fn_rc('obx_box_put_many', [OBX_box_p, OBX_bytes_array_p, ctypes.POINTER(obx_id), OBXPutMode])
 
 # obx_err (OBX_box* box, obx_id id);
 obx_box_remove = c_fn_nocheck('obx_box_remove', obx_err, [OBX_box_p, obx_id])
 
-# obx_err (OBX_box* box, uint64_t* out_count);
-obx_box_remove_all = c_fn_rc('obx_box_remove_all', [
-    OBX_box_p, ctypes.POINTER(ctypes.c_uint64)])
+# OBX_C_API obx_err obx_box_remove_many(OBX_box* box, const OBX_id_array* ids, uint64_t* out_count);
+obx_box_remove_many = c_fn_rc('obx_box_remove_many', [OBX_box_p, OBX_id_array_p, ctypes.POINTER(ctypes.c_uint64)])
+
+# OBX_C_API obx_err obx_box_remove_all(OBX_box* box, uint64_t* out_count);
+obx_box_remove_all = c_fn_rc('obx_box_remove_all', [OBX_box_p, ctypes.POINTER(ctypes.c_uint64)])
 
-# obx_err (OBX_box* box, bool* out_is_empty);
-obx_box_is_empty = c_fn_rc('obx_box_is_empty', [
-    OBX_box_p, ctypes.POINTER(ctypes.c_bool)])
+# OBX_C_API obx_err obx_box_is_empty(OBX_box* box, bool* out_is_empty);
+obx_box_is_empty = c_fn_rc('obx_box_is_empty', [OBX_box_p, ctypes.POINTER(ctypes.c_bool)])
 
-# obx_err obx_box_count(OBX_box* box, uint64_t limit, uint64_t* out_count);
-obx_box_count = c_fn_rc('obx_box_count', [
-    OBX_box_p, ctypes.c_uint64, ctypes.POINTER(ctypes.c_uint64)])
+# OBX_C_API obx_err obx_box_count(OBX_box* box, uint64_t limit, uint64_t* out_count);
+obx_box_count = c_fn_rc('obx_box_count', [OBX_box_p, ctypes.c_uint64, ctypes.POINTER(ctypes.c_uint64)])
 
 # OBX_query_builder* obx_query_builder(OBX_store* store, obx_schema_id entity_id);
 obx_query_builder = c_fn('obx_query_builder', OBX_query_builder_p, [OBX_store_p, obx_schema_id])

tests/test_box.py

@@ -1,12 +1,14 @@
 import pytest
-import objectbox
-from tests.model import TestEntity, TestEntityDatetime, TestEntityFlex
-from tests.common import *
 import numpy as np
 from datetime import datetime, timezone
 import time
 from math import floor
 
+import objectbox
+from objectbox.exceptions import *
+from tests.common import *
+from tests.model import TestEntity, TestEntityDatetime, TestEntityFlex
+
 
 def test_box_basics(test_store):
     box = test_store.box(TestEntity)
@@ -280,3 +282,83 @@ def test_flex_values(test_store):
     obj_id = box.put(TestEntityFlex(flex=dict_))
     read_obj = box.get(obj_id)
     assert read_obj.flex == dict_
+
+
+def test_contains(test_store):
+    box = test_store.box(TestEntity)
+
+    box.put([TestEntity(str=f"Object {i}") for i in range(1, 4)])
+    assert box.count() == 3
+
+    assert box.contains(1)
+    assert box.contains(2)
+    assert box.contains(3)
+    assert not box.contains(4)
+    assert not box.contains(3248)
+
+    with pytest.raises(IllegalArgumentError, match="Illegal ID value: 0"):
+        box.contains(0)
+
+
+def test_update(test_store):
+    box = test_store.box(TestEntity)
+
+    box.put([TestEntity(str=f"Object {i}") for i in range(1, 4)])
+    assert box.count() == 3
+
+    with test_store.write_tx():
+        for obj in box.get_all():
+            obj.str += " (updated)"
+            box.update(obj)
+
+    assert box.get(1).str == "Object 1 (updated)"
+    assert box.get(2).str == "Object 2 (updated)"
+    assert box.get(3).str == "Object 3 (updated)"
+    assert box.count() == 3
+
+    with pytest.raises(ValueError, match="without an ID"):
+        box.update(TestEntity(str="New object"))
+
+    obj = box.get(1)
+    box.remove(1)
+    with pytest.raises(IdNotFoundError, match="Update failed, given ID doesn't exist: 1"):
+        box.update(obj)
+    assert not box.contains(1)  # Failed update must not re-create the object
+
+
+def test_get_many(test_store):
+    box = test_store.box(TestEntity)
+
+    box.put([TestEntity(str=f"Object {i}") for i in range(1, 6)])
+    assert box.count() == 5
+
+    objects = box.get_many([1, 3, 4])
+    assert len(objects) == 3
+    assert objects[0].str == "Object 1"
+    assert objects[1].str == "Object 3"
+    assert objects[2].str == "Object 4"
+
+    objects = box.get_many([5, 2])
+    assert len(objects) == 2
+    assert objects[0].str == "Object 5"
+    assert objects[1].str == "Object 2"
+
+    objects = box.get_many([5, 5, 2])
+    assert len(objects) == 3
+    assert objects[0].str == "Object 5"
+    assert objects[1].str == "Object 5"
+    assert objects[2].str == "Object 2"
+
+    objects = box.get_many([2])
+    assert len(objects) == 1
+    assert objects[0].str == "Object 2"
+
+    objects = box.get_many([])
+    assert len(objects) == 0
+
+    objects = box.get_many([1, 789, 2, 10])
+    assert len(objects) == 4
+    assert objects[0].str == "Object 1"
+    assert objects[1] is None
+    assert objects[2].str == "Object 2"
+    assert objects[3] is None