Merge branch '39-logic-query-condition' into 'dev'

Resolve "Logical aggregation of QueryCondition's (and/or)" #39

Closes #39

See merge request objectbox/objectbox-python!27

Author: dan-obx

objectbox/condition.py

@@ -1,9 +1,64 @@
+from __future__ import annotations
+
 from enum import Enum
 from typing import *
 import numpy as np
 
+if TYPE_CHECKING:
+    from objectbox.c import obx_qb_cond
+    from objectbox.query_builder import QueryBuilder
+
+
+class QueryCondition:
+    def and_(self, other: QueryCondition) -> QueryCondition:
+        return LogicQueryCondition(self, other, LogicQueryConditionOp.AND)
+    __and__ = and_
+
+    def or_(self, other: QueryCondition) -> QueryCondition:
+        return LogicQueryCondition(self, other, LogicQueryConditionOp.OR)
+    __or__ = or_
+
+    def apply(self, qb: QueryBuilder) -> obx_qb_cond:
+        """ Applies the QueryCondition to the supplied QueryBuilder.
+
+        :return:
+            The C handle for the applied condition.
+        """
+        raise NotImplementedError
+
+
+class LogicQueryConditionOp(Enum):
+    AND = 1
+    OR = 2
+
+
+class LogicQueryCondition(QueryCondition):
+    """ A QueryCondition describing a logical operation between two inner QueryCondition's (e.g. AND/OR). """
 
-class _QueryConditionOp(Enum):
+    def __init__(self, cond1: QueryCondition, cond2: QueryCondition, op: LogicQueryConditionOp):
+        self._cond1 = cond1
+        self._cond2 = cond2
+        self._op = op
+
+    def _apply_conditions(self, qb: QueryBuilder) -> List[obx_qb_cond]:
+        return [self._cond1.apply(qb), self._cond2.apply(qb)]
+
+    def _apply_and(self, qb: QueryBuilder) -> obx_qb_cond:
+        return qb.all(self._apply_conditions(qb))
+
+    def _apply_or(self, qb: QueryBuilder) -> obx_qb_cond:
+        return qb.any(self._apply_conditions(qb))
+
+    def apply(self, qb: QueryBuilder) -> obx_qb_cond:
+        if self._op == LogicQueryConditionOp.AND:
+            return self._apply_and(qb)
+        elif self._op == LogicQueryConditionOp.OR:
+            return self._apply_or(qb)
+        else:
+            raise Exception(f"Unknown LogicQueryCondition op: {self._op.name}")
+
+
+class PropertyQueryConditionOp(Enum):
     EQ = 1
     NOT_EQ = 2
     CONTAINS = 3
@@ -18,130 +73,137 @@ class _QueryConditionOp(Enum):
     CONTAINS_KEY_VALUE = 12
 
 
-class QueryCondition:
-    def __init__(self, property_id: int, op: _QueryConditionOp, args: Dict[str, Any]):
-        if op not in self._get_op_map():
-            raise Exception(f"Invalid query condition op with ID: {op}")
+class PropertyQueryCondition(QueryCondition):
+    """ A QueryCondition describing an operation to be applied on a property (e.g. name == "John", age == 24) """
+
+    _OP_MAP: Dict[PropertyQueryConditionOp, str] = {
+        PropertyQueryConditionOp.EQ: "_apply_eq",
+        PropertyQueryConditionOp.NOT_EQ: "_apply_not_eq",
+        PropertyQueryConditionOp.CONTAINS: "_apply_contains",
+        PropertyQueryConditionOp.STARTS_WITH: "_apply_starts_with",
+        PropertyQueryConditionOp.ENDS_WITH: "_apply_ends_with",
+        PropertyQueryConditionOp.GT: "_apply_gt",
+        PropertyQueryConditionOp.GTE: "_apply_gte",
+        PropertyQueryConditionOp.LT: "_apply_lt",
+        PropertyQueryConditionOp.LTE: "_apply_lte",
+        PropertyQueryConditionOp.BETWEEN: "_apply_between",
+        PropertyQueryConditionOp.NEAREST_NEIGHBOR: "_apply_nearest_neighbor",
+        PropertyQueryConditionOp.CONTAINS_KEY_VALUE: "_contains_key_value"
+        # ... new property query conditions here ... :)
+    }
+
+    def __init__(self, property_id: int, op: PropertyQueryConditionOp, args: Dict[str, Any]):
+        if op not in self._OP_MAP:
+            raise Exception(f"Invalid PropertyQueryConditionOp: {op}")
+        op_func_name = self._OP_MAP[op]
+        if not hasattr(self, op_func_name):
+            raise Exception(f"Missing PropertyQueryCondition op function: {op_func_name} (op: {op})")
+        op_func = getattr(self, op_func_name)
 
         self._property_id = property_id
         self._op = op
+        self._op_func = op_func
         self._args = args
         self._alias = None
 
     def alias(self, value: str):
+        """ Sets an alias for this condition that can later be used with Query's set_parameter_* methods. """
         self._alias = value
         return self
 
-    def _get_op_map(self):
-        return {
-            _QueryConditionOp.EQ: self._apply_eq,
-            _QueryConditionOp.NOT_EQ: self._apply_not_eq,
-            _QueryConditionOp.CONTAINS: self._apply_contains,
-            _QueryConditionOp.STARTS_WITH: self._apply_starts_with,
-            _QueryConditionOp.ENDS_WITH: self._apply_ends_with,
-            _QueryConditionOp.GT: self._apply_gt,
-            _QueryConditionOp.GTE: self._apply_gte,
-            _QueryConditionOp.LT: self._apply_lt,
-            _QueryConditionOp.LTE: self._apply_lte,
-            _QueryConditionOp.BETWEEN: self._apply_between,
-            _QueryConditionOp.NEAREST_NEIGHBOR: self._apply_nearest_neighbor,
-            _QueryConditionOp.CONTAINS_KEY_VALUE: self._contains_key_value
-            # ... new query condition here ... :)
-        }
-
-    def _apply_eq(self, qb: 'QueryBuilder'):
+    def _apply_eq(self, qb: QueryBuilder) -> obx_qb_cond:
         value = self._args['value']
         case_sensitive = self._args['case_sensitive']
         if isinstance(value, str):
-            qb.equals_string(self._property_id, value, case_sensitive)
+            return qb.equals_string(self._property_id, value, case_sensitive)
         elif isinstance(value, int):
-            qb.equals_int(self._property_id, value)
+            return qb.equals_int(self._property_id, value)
         else:
             raise Exception(f"Unsupported type for 'EQ': {type(value)}")
 
-    def _apply_not_eq(self, qb: 'QueryBuilder'):
+    def _apply_not_eq(self, qb: QueryBuilder) -> obx_qb_cond:
         value = self._args['value']
         case_sensitive = self._args['case_sensitive']
         if isinstance(value, str):
-            qb.not_equals_string(self._property_id, value, case_sensitive)
+            return qb.not_equals_string(self._property_id, value, case_sensitive)
         elif isinstance(value, int):
-            qb.not_equals_int(self._property_id, value)
+            return qb.not_equals_int(self._property_id, value)
         else:
             raise Exception(f"Unsupported type for 'NOT_EQ': {type(value)}")
 
-    def _apply_contains(self, qb: 'QueryBuilder'):
+    def _apply_contains(self, qb: QueryBuilder) -> obx_qb_cond:
         value = self._args['value']
         case_sensitive = self._args['case_sensitive']
         if isinstance(value, str):
-            qb.contains_string(self._property_id, value, case_sensitive)
+            return qb.contains_string(self._property_id, value, case_sensitive)
         else:
             raise Exception(f"Unsupported type for 'CONTAINS': {type(value)}")
 
-    def _apply_starts_with(self, qb: 'QueryBuilder'):
+    def _apply_starts_with(self, qb: QueryBuilder) -> obx_qb_cond:
         value = self._args['value']
         case_sensitive = self._args['case_sensitive']
         if isinstance(value, str):
-            qb.starts_with_string(self._property_id, value, case_sensitive)
+            return qb.starts_with_string(self._property_id, value, case_sensitive)
         else:
             raise Exception(f"Unsupported type for 'STARTS_WITH': {type(value)}")
 
-    def _apply_ends_with(self, qb: 'QueryBuilder'):
+    def _apply_ends_with(self, qb: QueryBuilder) -> obx_qb_cond:
         value = self._args['value']
         case_sensitive = self._args['case_sensitive']
         if isinstance(value, str):
-            qb.ends_with_string(self._property_id, value, case_sensitive)
+            return qb.ends_with_string(self._property_id, value, case_sensitive)
         else:
             raise Exception(f"Unsupported type for 'ENDS_WITH': {type(value)}")
 
-    def _apply_gt(self, qb: 'QueryBuilder'):
+    def _apply_gt(self, qb: QueryBuilder) -> obx_qb_cond:
         value = self._args['value']
         case_sensitive = self._args['case_sensitive']
         if isinstance(value, str):
-            qb.greater_than_string(self._property_id, value, case_sensitive)
+            return qb.greater_than_string(self._property_id, value, case_sensitive)
         elif isinstance(value, int):
-            qb.greater_than_int(self._property_id, value)
+            return qb.greater_than_int(self._property_id, value)
         else:
             raise Exception(f"Unsupported type for 'GT': {type(value)}")
 
-    def _apply_gte(self, qb: 'QueryBuilder'):
+    def _apply_gte(self, qb: QueryBuilder) -> obx_qb_cond:
         value = self._args['value']
         case_sensitive = self._args['case_sensitive']
         if isinstance(value, str):
-            qb.greater_or_equal_string(self._property_id, value, case_sensitive)
+            return qb.greater_or_equal_string(self._property_id, value, case_sensitive)
         elif isinstance(value, int):
-            qb.greater_or_equal_int(self._property_id, value)
+            return qb.greater_or_equal_int(self._property_id, value)
         else:
             raise Exception(f"Unsupported type for 'GTE': {type(value)}")
 
-    def _apply_lt(self, qb: 'QueryCondition'):
+    def _apply_lt(self, qb: QueryBuilder) -> obx_qb_cond:
         value = self._args['value']
         case_sensitive = self._args['case_sensitive']
         if isinstance(value, str):
-            qb.less_than_string(self._property_id, value, case_sensitive)
+            return qb.less_than_string(self._property_id, value, case_sensitive)
         elif isinstance(value, int):
-            qb.less_than_int(self._property_id, value)
+            return qb.less_than_int(self._property_id, value)
         else:
             raise Exception("Unsupported type for 'LT': " + str(type(value)))
 
-    def _apply_lte(self, qb: 'QueryBuilder'):
+    def _apply_lte(self, qb: QueryBuilder) -> obx_qb_cond:
         value = self._args['value']
         case_sensitive = self._args['case_sensitive']
         if isinstance(value, str):
-            qb.less_or_equal_string(self._property_id, value, case_sensitive)
+            return qb.less_or_equal_string(self._property_id, value, case_sensitive)
         elif isinstance(value, int):
-            qb.less_or_equal_int(self._property_id, value)
+            return qb.less_or_equal_int(self._property_id, value)
         else:
             raise Exception(f"Unsupported type for 'LTE': {type(value)}")
 
-    def _apply_between(self, qb: 'QueryBuilder'):
+    def _apply_between(self, qb: QueryBuilder) -> obx_qb_cond:
         a = self._args['a']
         b = self._args['b']
         if isinstance(a, int):
-            qb.between_2ints(self._property_id, a, b)
+            return qb.between_2ints(self._property_id, a, b)
         else:
             raise Exception(f"Unsupported type for 'BETWEEN': {type(a)}")
 
-    def _apply_nearest_neighbor(self, qb: 'QueryBuilder'):
+    def _apply_nearest_neighbor(self, qb: QueryBuilder) -> obx_qb_cond:
         query_vector = self._args['query_vector']
         element_count = self._args['element_count']
 
@@ -152,19 +214,18 @@ def _apply_nearest_neighbor(self, qb: 'QueryBuilder'):
         is_float_vector |= isinstance(query_vector, np.ndarray) and query_vector.dtype == np.float32
         is_float_vector |= isinstance(query_vector, list) and type(query_vector[0]) == float
         if is_float_vector:
-            qb.nearest_neighbors_f32(self._property_id, query_vector, element_count)
+            return qb.nearest_neighbors_f32(self._property_id, query_vector, element_count)
         else:
             raise Exception(f"Unsupported type for 'NEAREST_NEIGHBOR': {type(query_vector)}")
 
-    def _contains_key_value(self, qb: 'QueryBuilder'):
+    def _contains_key_value(self, qb: QueryBuilder) -> obx_qb_cond:
         key = self._args['key']
         value = self._args['value']
         case_sensitive = self._args['case_sensitive']
-        qb.contains_key_value(self._property_id, key, value, case_sensitive)
-
-    def apply(self, qb: 'QueryBuilder'):
-        """ Applies the stored condition to the supplied query builder. """
-        self._get_op_map()[self._op](qb)
+        return qb.contains_key_value(self._property_id, key, value, case_sensitive)
 
+    def apply(self, qb: QueryBuilder) -> obx_qb_cond:
+        c_cond = self._op_func(qb)
         if self._alias is not None:
             qb.alias(self._alias)
+        return c_cond

objectbox/model/properties.py

@@ -13,13 +13,14 @@
 # limitations under the License.
 
 from enum import IntEnum
-
-from objectbox.condition import QueryCondition, _QueryConditionOp
-from objectbox.c import *
 import flatbuffers.number_types
 import numpy as np
 from dataclasses import dataclass
 
+from objectbox.c import *
+from objectbox.condition import PropertyQueryCondition, PropertyQueryConditionOp
+
+
 class PropertyType(IntEnum):
     bool = OBXPropertyType_Bool
     byte = OBXPropertyType_Byte
@@ -182,53 +183,53 @@ def _set_flags(self):
             if isinstance(self._index, Index):  # Generic index
                 self._flags |= self._index.type
 
-    def equals(self, value, case_sensitive: bool = True) -> QueryCondition:
+    def equals(self, value, case_sensitive: bool = True) -> PropertyQueryCondition:
         args = {'value': value, 'case_sensitive': case_sensitive}
-        return QueryCondition(self._id, _QueryConditionOp.EQ, args)
+        return PropertyQueryCondition(self._id, PropertyQueryConditionOp.EQ, args)
 
-    def not_equals(self, value, case_sensitive: bool = True) -> QueryCondition:
+    def not_equals(self, value, case_sensitive: bool = True) -> PropertyQueryCondition:
         args = {'value': value, 'case_sensitive': case_sensitive}
-        return QueryCondition(self._id, _QueryConditionOp.NOT_EQ, args)
+        return PropertyQueryCondition(self._id, PropertyQueryConditionOp.NOT_EQ, args)
 
-    def contains(self, value: str, case_sensitive: bool = True) -> QueryCondition:
+    def contains(self, value: str, case_sensitive: bool = True) -> PropertyQueryCondition:
         args = {'value': value, 'case_sensitive': case_sensitive}
-        return QueryCondition(self._id, _QueryConditionOp.CONTAINS, args)
+        return PropertyQueryCondition(self._id, PropertyQueryConditionOp.CONTAINS, args)
 
-    def starts_with(self, value: str, case_sensitive: bool = True) -> QueryCondition:
+    def starts_with(self, value: str, case_sensitive: bool = True) -> PropertyQueryCondition:
         args = {'value': value, 'case_sensitive': case_sensitive}
-        return QueryCondition(self._id, _QueryConditionOp.STARTS_WITH, args)
+        return PropertyQueryCondition(self._id, PropertyQueryConditionOp.STARTS_WITH, args)
 
-    def ends_with(self, value: str, case_sensitive: bool = True) -> QueryCondition:
+    def ends_with(self, value: str, case_sensitive: bool = True) -> PropertyQueryCondition:
         args = {'value': value, 'case_sensitive': case_sensitive}
-        return QueryCondition(self._id, _QueryConditionOp.ENDS_WITH, args)
+        return PropertyQueryCondition(self._id, PropertyQueryConditionOp.ENDS_WITH, args)
 
-    def greater_than(self, value, case_sensitive: bool = True) -> QueryCondition:
+    def greater_than(self, value, case_sensitive: bool = True) -> PropertyQueryCondition:
         args = {'value': value, 'case_sensitive': case_sensitive}
-        return QueryCondition(self._id, _QueryConditionOp.GT, args)
+        return PropertyQueryCondition(self._id, PropertyQueryConditionOp.GT, args)
 
-    def greater_or_equal(self, value, case_sensitive: bool = True) -> QueryCondition:
+    def greater_or_equal(self, value, case_sensitive: bool = True) -> PropertyQueryCondition:
         args = {'value': value, 'case_sensitive': case_sensitive}
-        return QueryCondition(self._id, _QueryConditionOp.GTE, args)
+        return PropertyQueryCondition(self._id, PropertyQueryConditionOp.GTE, args)
 
-    def less_than(self, value, case_sensitive: bool = True) -> QueryCondition:
+    def less_than(self, value, case_sensitive: bool = True) -> PropertyQueryCondition:
         args = {'value': value, 'case_sensitive': case_sensitive}
-        return QueryCondition(self._id, _QueryConditionOp.LT, args)
+        return PropertyQueryCondition(self._id, PropertyQueryConditionOp.LT, args)
 
-    def less_or_equal(self, value, case_sensitive: bool = True) -> QueryCondition:
+    def less_or_equal(self, value, case_sensitive: bool = True) -> PropertyQueryCondition:
         args = {'value': value, 'case_sensitive': case_sensitive}
-        return QueryCondition(self._id, _QueryConditionOp.LTE, args)
+        return PropertyQueryCondition(self._id, PropertyQueryConditionOp.LTE, args)
 
-    def between(self, a, b) -> QueryCondition:
+    def between(self, a, b) -> PropertyQueryCondition:
         args = {'a': a, 'b': b}
-        return QueryCondition(self._id, _QueryConditionOp.BETWEEN, args)
+        return PropertyQueryCondition(self._id, PropertyQueryConditionOp.BETWEEN, args)
 
-    def nearest_neighbor(self, query_vector, element_count: int) -> QueryCondition:
+    def nearest_neighbor(self, query_vector, element_count: int) -> PropertyQueryCondition:
         args = {'query_vector': query_vector, 'element_count': element_count}
-        return QueryCondition(self._id, _QueryConditionOp.NEAREST_NEIGHBOR, args)
+        return PropertyQueryCondition(self._id, PropertyQueryConditionOp.NEAREST_NEIGHBOR, args)
 
-    def contains_key_value(self, key: str, value: str, case_sensitive: bool = True) -> QueryCondition:
+    def contains_key_value(self, key: str, value: str, case_sensitive: bool = True) -> PropertyQueryCondition:
         args = {'key': key, 'value': value, 'case_sensitive': case_sensitive}
-        return QueryCondition(self._id, _QueryConditionOp.CONTAINS_KEY_VALUE, args)
+        return PropertyQueryCondition(self._id, PropertyQueryConditionOp.CONTAINS_KEY_VALUE, args)
 
 
 # ID property (primary key)

objectbox/query.py

@@ -46,6 +46,8 @@ def find_ids(self) -> List[int]:
         c_id_array_p = obx_query_find_ids(self._c_query)
         try:
             c_id_array: OBX_id_array = c_id_array_p.contents
+            if c_id_array.count == 0:
+                return []
             ids = ctypes.cast(c_id_array.ids, ctypes.POINTER(obx_id * c_id_array.count))
             return list(ids.contents)
         finally: