Queries: minimal support for str and int properties #17

c.py: rename fn() and add a separate method for functions returning obx_err

Author: ivahnenkoAnna

objectbox/box.py

@@ -15,6 +15,8 @@
 
 from objectbox.model.entity import _Entity
 from objectbox.objectbox import ObjectBox
+from objectbox.query_builder import QueryBuilder
+from objectbox.condition import QueryCondition
 from objectbox.c import *
 
 
@@ -147,3 +149,7 @@ def remove_all(self) -> int:
         count = ctypes.c_uint64()
         obx_box_remove_all(self._c_box, ctypes.byref(count))
         return int(count.value)
+    
+    def query(self, condition: QueryCondition) -> QueryBuilder:
+        qb = QueryBuilder(self._ob, self, self._entity, condition)
+        return qb

objectbox/c.py

@@ -0,0 +1,95 @@
+from enum import Enum
+
+class _ConditionOp(Enum):
+    eq = 1
+    notEq = 2
+    contains = 3
+    startsWith = 4
+    endsWith = 5
+    gt = 6
+    greaterOrEq = 7
+    lt = 8
+    lessOrEq = 9
+    between = 10
+
+
+class QueryCondition:
+    def __init__(self, property_id: int, op: _ConditionOp, value, value_b = None, case_sensitive: bool = True):
+        self._property_id = property_id
+        self._op = op
+        self._value = value
+        self._value_b = value_b
+        self._case_sensitive = case_sensitive
+
+    def apply(self, builder: 'QueryBuilder'):
+        if self._op == _ConditionOp.eq:
+            if isinstance(self._value, str):
+                builder.equals_string(self._property_id, self._value, self._case_sensitive)
+            elif isinstance(self._value, int):
+                builder.equals_int(self._property_id, self._value)
+            else:
+                raise Exception("Unsupported type for 'eq': " + str(type(self._value)))
+        
+        elif self._op == _ConditionOp.notEq:
+            if isinstance(self._value, str):
+                builder.not_equals_string(self._property_id, self._value, self._case_sensitive)
+            elif isinstance(self._value, int):
+                builder.not_equals_int(self._property_id, self._value)
+            else:
+                raise Exception("Unsupported type for 'notEq': " + str(type(self._value)))
+        
+        elif self._op == _ConditionOp.contains:
+            if isinstance(self._value, str):
+                builder.contains_string(self._property_id, self._value, self._case_sensitive)
+            else:
+                raise Exception("Unsupported type for 'contains': " + str(type(self._value)))
+        
+        elif self._op == _ConditionOp.startsWith:
+            if isinstance(self._value, str):
+                builder.starts_with_string(self._property_id, self._value, self._case_sensitive)
+            else:
+                raise Exception("Unsupported type for 'startsWith': " + str(type(self._value)))
+        
+        elif self._op == _ConditionOp.endsWith:
+            if isinstance(self._value, str):
+                builder.ends_with_string(self._property_id, self._value, self._case_sensitive)
+            else:
+                raise Exception("Unsupported type for 'endsWith': " + str(type(self._value)))
+        
+        elif self._op == _ConditionOp.gt:
+            if isinstance(self._value, str):
+                builder.greater_than_string(self._property_id, self._value, self._case_sensitive)
+            elif isinstance(self._value, int):
+                builder.greater_than_int(self._property_id, self._value)
+            else:
+                raise Exception("Unsupported type for 'gt': " + str(type(self._value)))
+        
+        elif self._op == _ConditionOp.greaterOrEq:
+            if isinstance(self._value, str):
+                builder.greater_or_equal_string(self._property_id, self._value, self._case_sensitive)
+            elif isinstance(self._value, int):
+                builder.greater_or_equal_int(self._property_id, self._value)
+            else:
+                raise Exception("Unsupported type for 'greaterOrEq': " + str(type(self._value)))
+        
+        elif self._op == _ConditionOp.lt:
+            if isinstance(self._value, str):
+                builder.less_than_string(self._property_id, self._value, self._case_sensitive)
+            elif isinstance(self._value, int):
+                builder.less_than_int(self._property_id, self._value)
+            else:
+                raise Exception("Unsupported type for 'lt': " + str(type(self._value)))
+        
+        elif self._op == _ConditionOp.lessOrEq:
+            if isinstance(self._value, str):
+                builder.less_or_equal_string(self._property_id, self._value, self._case_sensitive)
+            elif isinstance(self._value, int):
+                builder.less_or_equal_int(self._property_id, self._value)
+            else:
+                raise Exception("Unsupported type for 'lessOrEq': " + str(type(self._value)))
+            
+        elif self._op == _ConditionOp.between:
+            if isinstance(self._value, int):
+                builder.between_2ints(self._property_id, self._value, self._value_b)
+            else:
+                raise Exception("Unsupported type for 'between': " + str(type(self._value)))

objectbox/condition.py

@@ -14,6 +14,7 @@
 
 from enum import IntEnum
 
+from objectbox.condition import QueryCondition, _ConditionOp
 from objectbox.c import *
 import flatbuffers.number_types
 import numpy as np
@@ -127,6 +128,39 @@ def __set_flags(self):
         if self._is_id:
             self._flags = OBXPropertyFlags_ID
 
+    def op(self, op: _ConditionOp, value, case_sensitive: bool = True) -> QueryCondition:
+        return QueryCondition(self._id, op, value, case_sensitive)
+
+    def equals(self, value, case_sensitive: bool = True) -> QueryCondition:
+        return self.op(_ConditionOp.eq, value, case_sensitive)
+        
+    def not_equals(self, value, case_sensitive: bool = True) -> QueryCondition:
+        return self.op(_ConditionOp.notEq, value, case_sensitive)
+    
+    def contains(self, value: str, case_sensitive: bool = True) -> QueryCondition:
+        return self.op(_ConditionOp.contains, value, case_sensitive)
+    
+    def starts_with(self, value: str, case_sensitive: bool = True) -> QueryCondition:
+        return self.op(_ConditionOp.startsWith, value, case_sensitive)
+    
+    def ends_with(self, value: str, case_sensitive: bool = True) -> QueryCondition:
+        return self.op(_ConditionOp.endsWith, value, case_sensitive)
+    
+    def greater_than(self, value, case_sensitive: bool = True) -> QueryCondition:
+        return self.op(_ConditionOp.gt, value, case_sensitive)
+    
+    def greater_or_equal(self, value, case_sensitive: bool = True) -> QueryCondition:
+        return self.op(_ConditionOp.greaterOrEq, value, case_sensitive)
+    
+    def less_than(self, value, case_sensitive: bool = True) -> QueryCondition:
+        return self.op(_ConditionOp.lt, value, case_sensitive)
+    
+    def less_or_equal(self, value, case_sensitive: bool = True) -> QueryCondition:
+        return self.op(_ConditionOp.lessOrEq, value, case_sensitive)
+    
+    def between(self, value_a, value_b) -> QueryCondition:
+        return QueryCondition(self._id, _ConditionOp.between, value_a, value_b)
+    
 
 # ID property (primary key)
 class Id(Property):

objectbox/model/properties.py

@@ -0,0 +1,58 @@
+# Copyright 2019-2023 ObjectBox Ltd. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from objectbox.c import *
+
+
+class Query:
+    def __init__(self, c_query, box: 'Box'):
+        self._c_query = c_query
+        self._box = box
+        self._ob = box._ob
+
+    def find(self) -> list:
+        with self._ob.read_tx():
+            # OBX_bytes_array*
+            c_bytes_array_p = obx_query_find(self._c_query)
+
+            try:
+                # OBX_bytes_array
+                c_bytes_array = c_bytes_array_p.contents
+
+                result = list()
+                for i in range(c_bytes_array.count):
+                    # OBX_bytes
+                    c_bytes = c_bytes_array.data[i]
+                    data = c_voidp_as_bytes(c_bytes.data, c_bytes.size)
+                    result.append(self._box._entity.unmarshal(data))
+
+                return result
+            finally:
+                obx_bytes_array_free(c_bytes_array_p)
+
+    def count(self) -> int:
+        count = ctypes.c_uint64()
+        obx_query_count(self._c_query, ctypes.byref(count))
+        return int(count.value)
+    
+    def remove(self) -> int:
+        count = ctypes.c_uint64()
+        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 limit(self, limit: int):
+        return obx_query_limit(self._c_query, limit)

objectbox/query.py

@@ -0,0 +1,95 @@
+from objectbox.model.entity import _Entity
+from objectbox.objectbox import ObjectBox
+from objectbox.query import Query
+from objectbox.c import *
+
+
+class QueryBuilder:
+    def __init__(self, ob: ObjectBox, box: 'Box', entity: '_Entity', condition: 'QueryCondition'):
+        if not isinstance(entity, _Entity):
+            raise Exception("Given type is not an Entity")
+        self._box = box
+        self._entity = entity
+        self._condition = condition
+        self._c_builder = obx_query_builder(ob._c_store, entity.id)
+
+    def close(self) -> int:
+        return obx_qb_close(self)
+
+    def error_code(self) -> int:
+        return obx_qb_error_code(self)
+    
+    def error_message(self) -> str:
+        return obx_qb_error_message(self)
+    
+    def equals_string(self, property_id: int, value: str, case_sensitive: bool):
+        obx_qb_equals_string(self._c_builder, property_id, c_str(value), case_sensitive)
+        return self
+    
+    def not_equals_string(self, property_id: int, value: str, case_sensitive: bool):
+        obx_qb_not_equals_string(self._c_builder, property_id, c_str(value), case_sensitive)
+        return self
+    
+    def contains_string(self, property_id: int, value: str, case_sensitive: bool):
+        obx_qb_contains_string(self._c_builder, property_id, c_str(value), case_sensitive)
+        return self
+    
+    def starts_with_string(self, property_id: int, value: str, case_sensitive: bool):
+        obx_qb_starts_with_string(self._c_builder, property_id, c_str(value), case_sensitive)
+        return self
+    
+    def ends_with_string(self, property_id: int, value: str, case_sensitive: bool):
+        obx_qb_ends_with_string(self._c_builder, property_id, c_str(value), case_sensitive)
+        return self
+    
+    def greater_than_string(self, property_id: int, value: str, case_sensitive: bool):
+        obx_qb_greater_than_string(self._c_builder, property_id, c_str(value), case_sensitive)
+        return self
+    
+    def greater_or_equal_string(self, property_id: int, value: str, case_sensitive: bool):
+        obx_qb_greater_or_equal_string(self._c_builder, property_id, c_str(value), case_sensitive)
+        return self
+    
+    def less_than_string(self, property_id: int, value: str, case_sensitive: bool):
+        obx_qb_less_than_string(self._c_builder, property_id, c_str(value), case_sensitive)
+        return self
+    
+    def less_or_equal_string(self, property_id: int, value: str, case_sensitive: bool):
+        obx_qb_less_or_equal_string(self._c_builder, property_id, c_str(value), case_sensitive)
+        return self
+    
+    def equals_int(self, property_id: int, value: int):
+        obx_qb_equals_int(self._c_builder, property_id, value)
+        return self
+    
+    def not_equals_int(self, property_id: int, value: int):
+        obx_qb_not_equals_int(self._c_builder, property_id, value)
+        return self
+    
+    def greater_than_int(self, property_id: int, value: int):
+        obx_qb_greater_than_int(self._c_builder, property_id, value)
+        return self
+    
+    def greater_or_equal_int(self, property_id: int, value: int):
+        obx_qb_greater_or_equal_int(self._c_builder, property_id, value)
+        return self
+    
+    def less_than_int(self, property_id: int, value: int):
+        obx_qb_less_than_int(self._c_builder, property_id, value)
+        return self
+    
+    def less_or_equal_int(self, property_id: int, value: int):
+        obx_qb_less_or_equal_int(self._c_builder, property_id, value)
+        return self
+    
+    def between_2ints(self, property_id: int, value_a: int, value_b: int):
+        obx_qb_between_2ints(self._c_builder, property_id, value_a, value_b)
+        return self
+    
+    def apply_condition(self):
+        self._condition.apply(self)
+    
+    def build(self) -> Query:
+        self.apply_condition()
+        c_query = obx_query(self._c_builder)
+        return Query(c_query, self._box)