query: add some set_parameter_* for HNSW objectbox#24

set_parameter_string
set_parameter_int
set_parameter_vector_f32

Author: loryruta

objectbox/c.py

@@ -18,6 +18,7 @@
 import platform
 from objectbox.version import Version
 from typing import *
+import numpy as np
 
 # This file contains C-API bindings based on lib/objectbox.h, linking to the 'objectbox' shared library.
 # The bindings are implementing using ctypes, see https://docs.python.org/dev/library/ctypes.html for introduction.
@@ -329,13 +330,20 @@ def c_voidp_as_bytes(voidp, size):
     return memoryview(ctypes.cast(voidp, ctypes.POINTER(ctypes.c_ubyte * size))[0]).tobytes()
 
 
-def py_list_to_c_array(py_list: List[Any], c_type):
-    """ Converts the given python list into a C array. """
-    return (c_type * len(py_list))(*py_list)
+def py_list_to_c_array(py_list: Union[List[Any], np.ndarray], c_type):
+    """ Converts the given python list or ndarray into a C array. """
+    if isinstance(py_list, np.ndarray):
+        if py_list.ndim != 1:
+            raise Exception(f"ndarray is expected to be 1-dimensional. Input shape: {py_list.shape}")
+        return py_list.ctypes.data_as(ctypes.POINTER(c_type))
+    elif isinstance(py_list, list):
+        return (c_type * len(py_list))(*py_list)
+    else:
+        raise Exception(f"Unsupported Python list type: {type(py_list)}")
 
 
-def py_list_to_c_pointer(py_list: List[Any], c_type):
-    """ Converts the given python list into a C array and returns a pointer type. """
+def py_list_to_c_pointer(py_list: Union[List[Any], np.ndarray], c_type):
+    """ Converts the given python list or ndarray into a C array, and returns a pointer type. """
     return ctypes.cast(py_list_to_c_array(py_list, c_type), ctypes.POINTER(c_type))
 
 
@@ -676,8 +684,16 @@ def py_list_to_c_pointer(py_list: List[Any], c_type):
 # OBX_C_API obx_err obx_qb_param_alias(OBX_query_builder* builder, const char* alias);
 obx_qb_param_alias = c_fn_rc('obx_qb_param_alias', [OBX_query_builder_p, ctypes.c_char_p])
 
+# OBX_C_API obx_err obx_query_param_string(OBX_query* query, obx_schema_id entity_id, obx_schema_id property_id, const char* value);
+obx_query_param_string = c_fn_rc('obx_query_param_string', [OBX_query_p, obx_schema_id, obx_schema_id, ctypes.c_char_p])
+
+# OBX_C_API obx_err obx_query_param_int(OBX_query* query, obx_schema_id entity_id, obx_schema_id property_id, int64_t value);
+obx_query_param_int = c_fn_rc('obx_query_param_int', [OBX_query_p, obx_schema_id, obx_schema_id, ctypes.c_int64])
+
 # OBX_C_API obx_err obx_query_param_vector_float32(OBX_query* query, obx_schema_id entity_id, obx_schema_id property_id, const float* value, size_t element_count);
-# TODO
+obx_query_param_vector_float32 = c_fn_rc('obx_query_param_vector_float32',
+                                         [OBX_query_p, obx_schema_id, obx_schema_id, ctypes.POINTER(ctypes.c_float),
+                                          ctypes.c_size_t])
 
 # OBX_C_API obx_err obx_query_param_alias_vector_float32(OBX_query* query, const char* alias, const float* value, size_t element_count);
 # TODO

objectbox/model/entity.py

@@ -103,6 +103,17 @@ def get_property(self, name: str):
                 return prop
         raise Exception(f"Property \"{name}\" not found in Entity: \"{self.name}\"")
 
+    def get_property_id(self, prop: Union[int, str, Property]) -> int:
+        """ A convenient way to get the property ID regardless having its ID, name or Property. """
+        if isinstance(prop, int):
+            return prop  # We already have it!
+        elif isinstance(prop, str):
+            return self.get_property(prop)._id
+        elif isinstance(prop, Property):
+            return prop._id
+        else:
+            raise Exception(f"Unsupported Property type: {type(prop)}")
+
     def get_value(self, object, prop: Property):
         # in case value is not overwritten on the object, it's the Property object itself (= as defined in the Class)
         val = getattr(object, prop._name)

objectbox/query.py

@@ -19,6 +19,7 @@ class Query:
     def __init__(self, c_query, box: 'Box'):
         self._c_query = c_query
         self._box = box
+        self._entity = self._box._entity
         self._ob = box._ob
 
     def find(self) -> list:
@@ -96,8 +97,31 @@ def remove(self) -> int:
         obx_query_remove(self._c_query, ctypes.byref(count))
         return int(count.value)
 
-    def offset(self, offset: int):
-        return obx_query_offset(self._c_query, offset)
+    def offset(self, offset: int) -> 'Query':
+        obx_query_offset(self._c_query, offset)
+        return self
 
-    def limit(self, limit: int):
-        return obx_query_limit(self._c_query, limit)
+    def limit(self, limit: int) -> 'Query':
+        obx_query_limit(self._c_query, limit)
+        return self
+
+    def set_parameter_string(self, prop: Union[int, str, 'Property'], value: str) -> 'Query':
+        prop_id = self._entity.get_property_id(prop)
+        obx_query_param_string(self._c_query, self._entity.id, prop_id, c_str(value))
+        return self
+
+    def set_parameter_int(self, prop: Union[int, str, 'Property'], value: int) -> 'Query':
+        prop_id = self._entity.get_property_id(prop)
+        obx_query_param_int(self._c_query, self._entity.id, prop_id, value)
+        return self
+
+    def set_parameter_vector_f32(self,
+                                 prop: Union[int, str, 'Property'],
+                                 value: Union[List[float], np.ndarray]) -> 'Query':
+        if isinstance(value, np.ndarray) and value.dtype != np.float32:
+            raise Exception(f"value dtype is expected to be np.float32, got: {value.dtype}")
+        prop_id = self._entity.get_property_id(prop)
+        c_value = py_list_to_c_array(value, ctypes.c_float)
+        num_el = len(value)
+        obx_query_param_vector_float32(self._c_query, self._entity.id, prop_id, c_value, num_el)
+        return self

objectbox/query_builder.py

@@ -14,13 +14,6 @@ def __init__(self, ob: ObjectBox, box: 'Box'):
         self._entity = box._entity
         self._c_builder = obx_query_builder(ob._c_store, box._entity.id)
 
-    def _get_property_id(self, prop: Union[int, str, Property]) -> int:
-        if type(prop) is int:
-            return prop
-        elif type(prop) is str:
-            prop = self._entity.get_property(prop)
-        return prop._id
-
     def close(self) -> int:
         return obx_qb_close(self._c_builder)
 
@@ -31,101 +24,97 @@ def error_message(self) -> str:
         return obx_qb_error_message(self._c_builder)
 
     def equals_string(self, prop: Union[int, str, Property], value: str, case_sensitive: bool = True) -> obx_qb_cond:
-        prop_id = self._get_property_id(prop)
+        prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_equals_string(self._c_builder, prop_id, c_str(value), case_sensitive)
         return cond
 
     def not_equals_string(self, prop: Union[int, str, Property], value: str,
                           case_sensitive: bool = True) -> obx_qb_cond:
-        prop_id = self._get_property_id(prop)
+        prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_not_equals_string(self._c_builder, prop_id, c_str(value), case_sensitive)
         return cond
 
     def contains_string(self, prop: Union[int, str, Property], value: str, case_sensitive: bool = True) -> obx_qb_cond:
-        prop_id = self._get_property_id(prop)
+        prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_contains_string(self._c_builder, prop_id, c_str(value), case_sensitive)
         return cond
 
     def starts_with_string(self, prop: Union[int, str, Property], value: str,
                            case_sensitive: bool = True) -> obx_qb_cond:
-        prop_id = self._get_property_id(prop)
+        prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_starts_with_string(self._c_builder, prop_id, c_str(value), case_sensitive)
         return cond
 
     def ends_with_string(self, prop: Union[int, str, Property], value: str, case_sensitive: bool = True) -> obx_qb_cond:
-        prop_id = self._get_property_id(prop)
+        prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_ends_with_string(self._c_builder, prop_id, c_str(value), case_sensitive)
         return cond
 
     def greater_than_string(self, prop: Union[int, str, Property], value: str,
                             case_sensitive: bool = True) -> obx_qb_cond:
-        prop_id = self._get_property_id(prop)
+        prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_greater_than_string(self._c_builder, prop_id, c_str(value), case_sensitive)
         return cond
 
     def greater_or_equal_string(self, prop: Union[int, str, Property], value: str,
                                 case_sensitive: bool = True) -> obx_qb_cond:
-        prop_id = self._get_property_id(prop)
+        prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_greater_or_equal_string(self._c_builder, prop_id, c_str(value), case_sensitive)
         return cond
 
     def less_than_string(self, prop: Union[int, str, Property], value: str, case_sensitive: bool = True) -> obx_qb_cond:
-        prop_id = self._get_property_id(prop)
+        prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_less_than_string(self._c_builder, prop_id, c_str(value), case_sensitive)
         return cond
 
     def less_or_equal_string(self, prop: Union[int, str, Property], value: str,
                              case_sensitive: bool = True) -> obx_qb_cond:
-        prop_id = self._get_property_id(prop)
+        prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_less_or_equal_string(self._c_builder, prop_id, c_str(value), case_sensitive)
         return cond
 
     def equals_int(self, prop: Union[int, str, Property], value: int) -> obx_qb_cond:
-        prop_id = self._get_property_id(prop)
+        prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_equals_int(self._c_builder, prop_id, value)
         return cond
 
     def not_equals_int(self, prop: Union[int, str, Property], value: int) -> obx_qb_cond:
-        prop_id = self._get_property_id(prop)
+        prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_not_equals_int(self._c_builder, prop_id, value)
         return cond
 
     def greater_than_int(self, prop: Union[int, str, Property], value: int) -> obx_qb_cond:
-        prop_id = self._get_property_id(prop)
+        prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_greater_than_int(self._c_builder, prop_id, value)
         return cond
 
     def greater_or_equal_int(self, prop: Union[int, str, Property], value: int) -> obx_qb_cond:
-        prop_id = self._get_property_id(prop)
+        prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_greater_or_equal_int(self._c_builder, prop_id, value)
         return cond
 
     def less_than_int(self, prop: Union[int, str, Property], value: int) -> obx_qb_cond:
-        prop_id = self._get_property_id(prop)
+        prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_less_than_int(self._c_builder, prop_id, value)
         return cond
 
     def less_or_equal_int(self, prop: Union[int, str, Property], value: int) -> obx_qb_cond:
-        prop_id = self._get_property_id(prop)
+        prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_less_or_equal_int(self._c_builder, prop_id, value)
         return cond
 
     def between_2ints(self, prop: Union[int, str, Property], value_a: int, value_b: int) -> obx_qb_cond:
-        prop_id = self._get_property_id(prop)
+        prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_between_2ints(self._c_builder, prop_id, value_a, value_b)
         return cond
 
     def nearest_neighbors_f32(self, prop: Union[int, str, Property], query_vector: Union[np.ndarray, List[float]],
                               element_count: int):
-        if isinstance(query_vector, np.ndarray):
-            if query_vector.dtype != np.float32:
-                raise Exception(f"query_vector dtype must be float32")
-            query_vector_data = query_vector.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
-        else:  # List[float]
-            query_vector_data = py_list_to_c_array(query_vector, ctypes.c_float)
-
-        prop_id = self._get_property_id(prop)
-        cond = obx_qb_nearest_neighbors_f32(self._c_builder, prop_id, query_vector_data, element_count)
+        if isinstance(query_vector, np.ndarray) and query_vector.dtype != np.float32:
+            raise Exception(f"query_vector dtype is expected to be np.float32, got: {query_vector.dtype}")
+        prop_id = self._entity.get_property_id(prop)
+        c_query_vector = py_list_to_c_array(query_vector, ctypes.c_float)
+        cond = obx_qb_nearest_neighbors_f32(self._c_builder, prop_id, c_query_vector, element_count)
         return cond
 
     def any(self, conditions: List[obx_qb_cond]) -> obx_qb_cond:

tests/test_query.py

@@ -1,9 +1,11 @@
 import objectbox
+from objectbox import *
 from objectbox.model import *
 from objectbox.c import *
+from objectbox.query import *
 import pytest
 from tests.common import (load_empty_test_objectbox, create_test_objectbox, autocleanup)
-from tests.model import TestEntity
+from tests.model import *
 
 
 def test_basics():
@@ -224,3 +226,54 @@ def test_any_all():
     assert ids == [2, 3]
 
 
+def test_set_parameter():
+    db = create_test_objectbox()
+
+    box_test_entity = objectbox.Box(db, TestEntity)
+    box_test_entity.put(TestEntity(str="Foo", int64=2, int32=703, int8=101))
+    box_test_entity.put(TestEntity(str="FooBar", int64=10, int32=49, int8=45))
+    box_test_entity.put(TestEntity(str="Bar", int64=10, int32=226, int8=126))
+    box_test_entity.put(TestEntity(str="Foster", int64=2, int32=301, int8=42))
+    box_test_entity.put(TestEntity(str="Fox", int64=10, int32=157, int8=11))
+    box_test_entity.put(TestEntity(str="Barrakuda", int64=4, int32=386, int8=60))
+
+    box_vector_entity = objectbox.Box(db, VectorEntity)
+    box_vector_entity.put(VectorEntity(name="Object 1", vector=[1, 1]))
+    box_vector_entity.put(VectorEntity(name="Object 2", vector=[2, 2]))
+    box_vector_entity.put(VectorEntity(name="Object 3", vector=[3, 3]))
+    box_vector_entity.put(VectorEntity(name="Object 4", vector=[4, 4]))
+    box_vector_entity.put(VectorEntity(name="Object 5", vector=[5, 5]))
+
+    qb = box_test_entity.query()
+    qb.starts_with_string("str", "fo", case_sensitive=False)
+    qb.greater_than_int("int32", 150)
+    qb.greater_than_int("int64", 0)
+    query = qb.build()
+    assert query.find_ids() == [1, 4, 5]
+
+    # Test set_parameter_string
+    query.set_parameter_string("str", "bar")
+    assert query.find_ids() == [3, 6]
+
+    # Test set_parameter_int
+    query.set_parameter_int("int64", 8)
+    assert query.find_ids() == [3]
+
+    qb = box_vector_entity.query()
+    qb.nearest_neighbors_f32("vector", [3.4, 3.4], 3)
+    query = qb.build()
+    assert query.find_ids() == sorted([3, 4, 2])
+
+    # set_parameter_vector_f32
+    # set_parameter_int (NN count)
+    query.set_parameter_vector_f32("vector", [4.9, 4.9])
+    assert query.find_ids() == sorted([5, 4, 3])
+
+    query.set_parameter_vector_f32("vector", [0, 0])
+    assert query.find_ids() == sorted([1, 2, 3])
+
+    query.set_parameter_vector_f32("vector", [2.5, 2.1])
+    assert query.find_ids() == sorted([2, 3, 1])
+
+    query.set_parameter_int("vector", 2)
+    assert query.find_ids() == sorted([2, 3])