query_condition: add LogicQueryCondition, rename QueryCondition to PropertyQueryCondition #39

Author: loryruta

objectbox/condition.py

@@ -1,9 +1,62 @@
+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)
+
+    def or_(self, other: QueryCondition) -> QueryCondition:
+        return LogicQueryCondition(self, other, LogicQueryConditionOp.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,8 +71,10 @@ class _QueryConditionOp(Enum):
     CONTAINS_KEY_VALUE = 12
 
 
-class QueryCondition:
-    def __init__(self, property_id: int, op: _QueryConditionOp, args: Dict[str, Any]):
+class PropertyQueryCondition(QueryCondition):
+    """ A QueryCondition describing an operation to be applied on a property (e.g. name == "John", age == 24) """
+
+    def __init__(self, property_id: int, op: PropertyQueryConditionOp, args: Dict[str, Any]):
         if op not in self._get_op_map():
             raise Exception(f"Invalid query condition op with ID: {op}")
 
@@ -29,119 +84,120 @@ def __init__(self, property_id: int, op: _QueryConditionOp, args: Dict[str, Any]
         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 ... :)
+            PropertyQueryConditionOp.EQ: self._apply_eq,
+            PropertyQueryConditionOp.NOT_EQ: self._apply_not_eq,
+            PropertyQueryConditionOp.CONTAINS: self._apply_contains,
+            PropertyQueryConditionOp.STARTS_WITH: self._apply_starts_with,
+            PropertyQueryConditionOp.ENDS_WITH: self._apply_ends_with,
+            PropertyQueryConditionOp.GT: self._apply_gt,
+            PropertyQueryConditionOp.GTE: self._apply_gte,
+            PropertyQueryConditionOp.LT: self._apply_lt,
+            PropertyQueryConditionOp.LTE: self._apply_lte,
+            PropertyQueryConditionOp.BETWEEN: self._apply_between,
+            PropertyQueryConditionOp.NEAREST_NEIGHBOR: self._apply_nearest_neighbor,
+            PropertyQueryConditionOp.CONTAINS_KEY_VALUE: self._contains_key_value
+            # ... new property 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 +208,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._get_op_map()[self._op](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)