Merge branch '36-flex-key-equals-value-cond' into 'dev'

Resolve "Bubble up flex "key equals value" condition" #36

Closes #36

See merge request objectbox/objectbox-python!25

Author: dan-obx

objectbox/condition.py

@@ -15,6 +15,7 @@ class _QueryConditionOp(Enum):
     LTE = 9
     BETWEEN = 10
     NEAREST_NEIGHBOR = 11
+    CONTAINS_KEY_VALUE = 12
 
 
 class QueryCondition:
@@ -43,7 +44,8 @@ def _get_op_map(self):
             _QueryConditionOp.LT: self._apply_lt,
             _QueryConditionOp.LTE: self._apply_lte,
             _QueryConditionOp.BETWEEN: self._apply_between,
-            _QueryConditionOp.NEAREST_NEIGHBOR: self._apply_nearest_neighbor
+            _QueryConditionOp.NEAREST_NEIGHBOR: self._apply_nearest_neighbor,
+            _QueryConditionOp.CONTAINS_KEY_VALUE: self._contains_key_value
             # ... new query condition here ... :)
         }
 
@@ -57,9 +59,6 @@ def _apply_eq(self, qb: 'QueryBuilder'):
         else:
             raise Exception(f"Unsupported type for 'EQ': {type(value)}")
 
-        if self._alias is not None:
-            qb.alias(self._alias)
-
     def _apply_not_eq(self, qb: 'QueryBuilder'):
         value = self._args['value']
         case_sensitive = self._args['case_sensitive']
@@ -70,9 +69,6 @@ def _apply_not_eq(self, qb: 'QueryBuilder'):
         else:
             raise Exception(f"Unsupported type for 'NOT_EQ': {type(value)}")
 
-        if self._alias is not None:
-            qb.alias(self._alias)
-
     def _apply_contains(self, qb: 'QueryBuilder'):
         value = self._args['value']
         case_sensitive = self._args['case_sensitive']
@@ -81,9 +77,6 @@ def _apply_contains(self, qb: 'QueryBuilder'):
         else:
             raise Exception(f"Unsupported type for 'CONTAINS': {type(value)}")
 
-        if self._alias is not None:
-            qb.alias(self._alias)
-
     def _apply_starts_with(self, qb: 'QueryBuilder'):
         value = self._args['value']
         case_sensitive = self._args['case_sensitive']
@@ -92,9 +85,6 @@ def _apply_starts_with(self, qb: 'QueryBuilder'):
         else:
             raise Exception(f"Unsupported type for 'STARTS_WITH': {type(value)}")
 
-        if self._alias is not None:
-            qb.alias(self._alias)
-
     def _apply_ends_with(self, qb: 'QueryBuilder'):
         value = self._args['value']
         case_sensitive = self._args['case_sensitive']
@@ -103,9 +93,6 @@ def _apply_ends_with(self, qb: 'QueryBuilder'):
         else:
             raise Exception(f"Unsupported type for 'ENDS_WITH': {type(value)}")
 
-        if self._alias is not None:
-            qb.alias(self._alias)
-
     def _apply_gt(self, qb: 'QueryBuilder'):
         value = self._args['value']
         case_sensitive = self._args['case_sensitive']
@@ -116,9 +103,6 @@ def _apply_gt(self, qb: 'QueryBuilder'):
         else:
             raise Exception(f"Unsupported type for 'GT': {type(value)}")
 
-        if self._alias is not None:
-            qb.alias(self._alias)
-
     def _apply_gte(self, qb: 'QueryBuilder'):
         value = self._args['value']
         case_sensitive = self._args['case_sensitive']
@@ -129,9 +113,6 @@ def _apply_gte(self, qb: 'QueryBuilder'):
         else:
             raise Exception(f"Unsupported type for 'GTE': {type(value)}")
 
-        if self._alias is not None:
-            qb.alias(self._alias)
-
     def _apply_lt(self, qb: 'QueryCondition'):
         value = self._args['value']
         case_sensitive = self._args['case_sensitive']
@@ -142,9 +123,6 @@ def _apply_lt(self, qb: 'QueryCondition'):
         else:
             raise Exception("Unsupported type for 'LT': " + str(type(value)))
 
-        if self._alias is not None:
-            qb.alias(self._alias)
-
     def _apply_lte(self, qb: 'QueryBuilder'):
         value = self._args['value']
         case_sensitive = self._args['case_sensitive']
@@ -155,9 +133,6 @@ def _apply_lte(self, qb: 'QueryBuilder'):
         else:
             raise Exception(f"Unsupported type for 'LTE': {type(value)}")
 
-        if self._alias is not None:
-            qb.alias(self._alias)
-
     def _apply_between(self, qb: 'QueryBuilder'):
         a = self._args['a']
         b = self._args['b']
@@ -166,9 +141,6 @@ def _apply_between(self, qb: 'QueryBuilder'):
         else:
             raise Exception(f"Unsupported type for 'BETWEEN': {type(a)}")
 
-        if self._alias is not None:
-            qb.alias(self._alias)
-
     def _apply_nearest_neighbor(self, qb: 'QueryBuilder'):
         query_vector = self._args['query_vector']
         element_count = self._args['element_count']
@@ -184,8 +156,15 @@ def _apply_nearest_neighbor(self, qb: 'QueryBuilder'):
         else:
             raise Exception(f"Unsupported type for 'NEAREST_NEIGHBOR': {type(query_vector)}")
 
-        if self._alias is not None:
-            qb.alias(self._alias)
+    def _contains_key_value(self, qb: 'QueryBuilder'):
+        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)
+
+        if self._alias is not None:
+            qb.alias(self._alias)

objectbox/model/properties.py

@@ -200,10 +200,14 @@ def between(self, a, b) -> QueryCondition:
         args = {'a': a, 'b': b}
         return QueryCondition(self._id, _QueryConditionOp.BETWEEN, args)
 
-    def nearest_neighbor(self, query_vector, element_count: int):
+    def nearest_neighbor(self, query_vector, element_count: int) -> QueryCondition:
         args = {'query_vector': query_vector, 'element_count': element_count}
         return QueryCondition(self._id, _QueryConditionOp.NEAREST_NEIGHBOR, args)
 
+    def contains_key_value(self, key: str, value: str, case_sensitive: bool = True) -> QueryCondition:
+        args = {'key': key, 'value': value, 'case_sensitive': case_sensitive}
+        return QueryCondition(self._id, _QueryConditionOp.CONTAINS_KEY_VALUE, args)
+
 
 # ID property (primary key)
 class Id(Property):

objectbox/query_builder.py

@@ -117,6 +117,18 @@ def nearest_neighbors_f32(self, prop: Union[int, str, Property], query_vector: U
         cond = obx_qb_nearest_neighbors_f32(self._c_builder, prop_id, c_query_vector, element_count)
         return cond
 
+    def contains_key_value(self, prop: Union[int, str, Property], key: str, value: str,
+                           case_sensitive: bool = True) -> obx_qb_cond:
+        """ Checks whether the given Flex property, interpreted as a dictionary and indexed at key, has a value
+        corresponding to the given value.
+
+        :param case_sensitive:
+            If false, ignore case when matching value
+        """
+        prop_id = self._entity.get_property_id(prop)
+        cond = obx_qb_contains_key_value_string(self._c_builder, prop_id, c_str(key), c_str(value), case_sensitive)
+        return cond
+
     def any(self, conditions: List[obx_qb_cond]) -> obx_qb_cond:
         c_conditions = c_array(conditions, obx_qb_cond)
         cond = obx_qb_any(self._c_builder, c_conditions, len(conditions))

tests/common.py

@@ -31,7 +31,7 @@ def load_empty_test_datetime(name: str = "") -> objectbox.ObjectBox:
 
 def load_empty_test_flex(name: str = "") -> objectbox.ObjectBox:
     model = objectbox.Model()
-    model.entity(TestEntityFlex, last_property_id=IdUid(3, 3003))
+    model.entity(TestEntityFlex, last_property_id=IdUid(2, 3002))
     model.last_entity_id = IdUid(3, 3)
 
     db_name = test_dir if len(name) == 0 else test_dir + "/" + name
@@ -51,7 +51,7 @@ def create_test_objectbox(db_name: Optional[str] = None, clear_db: bool = True)
     model = objectbox.Model()
     model.entity(TestEntity, last_property_id=IdUid(27, 1027))
     model.entity(TestEntityDatetime, last_property_id=IdUid(4, 2004))
-    model.entity(TestEntityFlex, last_property_id=IdUid(3, 3003))
+    model.entity(TestEntityFlex, last_property_id=IdUid(2, 3002))
     model.entity(VectorEntity, last_property_id=IdUid(3, 4003))
     model.last_entity_id = IdUid(4, 4)
     model.last_index_id = IdUid(3, 40001)

tests/model.py

@@ -50,8 +50,7 @@ class TestEntityDatetime:
 @Entity(id=3, uid=3)
 class TestEntityFlex:
     id = Id(id=1, uid=3001)
-    flex_dict = Property(Dict[str, Any], type=PropertyType.flex, id=2, uid=3002)
-    flex_int = Property(int, type=PropertyType.flex, id=3, uid=3003)
+    flex = Property(Any, type=PropertyType.flex, id=2, uid=3002)
 
 
 @Entity(id=4, uid=4)

tests/test_box.py

@@ -77,7 +77,7 @@ def test_box_basics():
 
     # remove
     box.remove(object)
-    
+
     # remove should return success  
     success = box.remove(1)
     assert success == True
@@ -229,22 +229,33 @@ def test_put_get(object: TestEntity, box: objectbox.Box, property):
     ob.close()
 
 
-def test_flex_dict():
-    ob = load_empty_test_flex()
-    box = objectbox.Box(ob, TestEntityFlex)
-    object = TestEntityFlex()
+def test_flex_values():
+    ob = create_test_objectbox()
 
-    # Put an empty object
-    id = box.put(object)
-    assert id == object.id
-    read = box.get(object.id)
-    assert read.flex_dict == None
-    assert read.flex_int == None
+    box = objectbox.Box(ob, TestEntityFlex)
 
-    object.flex_dict = {"a": 1, "b": 2}
-    object.flex_int = 25
-    id = box.put(object)
-    assert id == object.id
-    read = box.get(object.id)
-    assert read.flex_dict == object.flex_dict
-    assert read.flex_int == object.flex_int
+    # Test empty object
+    obj_id = box.put(TestEntityFlex())
+    read_obj = box.get(obj_id)
+    assert read_obj.flex is None
+
+    # Test int
+    obj_id = box.put(TestEntityFlex(flex=23))
+    read_obj = box.get(obj_id)
+    assert read_obj.flex == 23
+
+    # Test string
+    obj_id = box.put(TestEntityFlex(flex="hello"))
+    read_obj = box.get(obj_id)
+    assert read_obj.flex == "hello"
+
+    # Test mixed list
+    obj_id = box.put(TestEntityFlex(flex=[4, 5, 1, "foo", 23, "bar"]))
+    read_obj = box.get(obj_id)
+    assert read_obj.flex == [4, 5, 1, "foo", 23, "bar"]
+
+    # Test dictionary
+    dict_ = {"a": 1, "b": {"list": [1, 2, 3], "int": 5}}
+    obj_id = box.put(TestEntityFlex(flex=dict_))
+    read_obj = box.get(obj_id)
+    assert read_obj.flex == dict_

tests/test_query.py

@@ -107,6 +107,54 @@ def test_basics():
     ob.close()
 
 
+def test_flex_contains_key_value():
+    ob = create_test_objectbox()
+
+    box = objectbox.Box(ob, TestEntityFlex)
+    box.put(TestEntityFlex(flex={"k1": "String", "k2": 2, "k3": "string"}))
+    box.put(TestEntityFlex(flex={"k1": "strinG", "k2": 3, "k3": 10, "k4": [1, "foo", 3]}))
+    box.put(TestEntityFlex(flex={"k1": "buzz", "k2": 3, "k3": [2, 3], "k4": {"k1": "a", "k2": "inner text"}}))
+    box.put(TestEntityFlex(flex={"n1": "string", "n2": -7, "n3": [-10, 10], "n4": [4, 4, 4]}))
+    box.put(TestEntityFlex(flex={"n1": "Apple", "n2": 3, "n3": [2, 3, 5], "n4": {"n1": [1, 2, "bar"]}}))
+
+    assert box.count() == 5
+
+    # Search case-sensitive = False
+    flex: Property = TestEntityFlex.get_property("flex")
+    query = box.query(flex.contains_key_value("k1", "string", False)).build()
+    results = query.find()
+    assert len(results) == 2
+    assert results[0].flex["k1"] == "String"
+    assert results[0].flex["k2"] == 2
+    assert results[0].flex["k3"] == "string"
+    assert results[1].flex["k1"] == "strinG"
+    assert results[1].flex["k2"] == 3
+    assert results[1].flex["k3"] == 10
+    assert results[1].flex["k4"] == [1, "foo", 3]
+
+    # Search case-sensitive = True
+    flex: Property = TestEntityFlex.get_property("flex")
+    query = box.query(flex.contains_key_value("n1", "string", True)).build()
+    results = query.find()
+    assert len(results) == 1
+    assert results[0].flex["n1"] == "string"
+    assert results[0].flex["n2"] == -7
+    assert results[0].flex["n3"] == [-10, 10]
+    assert results[0].flex["n4"] == [4, 4, 4]
+
+    # TODO Search using nested key (not supported yet)
+
+    # No match (key)
+    flex: Property = TestEntityFlex.get_property("flex")
+    query = box.query(flex.contains_key_value("missing key", "string", True)).build()
+    assert len(query.find()) == 0
+
+    # No match (value)
+    flex: Property = TestEntityFlex.get_property("flex")
+    query = box.query(flex.contains_key_value("k1", "missing value", True)).build()
+    assert len(query.find()) == 0
+
+
 def test_offset_limit():
     ob = load_empty_test_objectbox()
 
@@ -265,20 +313,23 @@ def test_set_parameter_alias():
     box_vector.put(VectorEntity(name="Object 4", vector=[4, 4]))
     box_vector.put(VectorEntity(name="Object 5", vector=[5, 5]))
 
-    str_prop: Property = TestEntity.properties[1]
-    qb = box.query(str_prop.equals("Foo").alias("foo_filter"))
+    str_prop: Property = TestEntity.get_property("str")
+    int32_prop: Property = TestEntity.get_property("int32")
+    int64_prop: Property = TestEntity.get_property("int64")
 
+    # Test set parameter alias on string
+    qb = box.query(str_prop.equals("Foo").alias("foo_filter"))
     query = qb.build()
+
     assert query.find()[0].str == "Foo"
     assert query.count() == 1
 
     query.set_parameter_alias_string("foo_filter", "FooBar")
-
     assert query.find()[0].str == "FooBar"
     assert query.count() == 1
 
-    int_prop: Property = TestEntity.properties[3]
-    qb = box.query(int_prop.greater_than(5).alias("greater_than_filter"))
+    # Test set parameter alias on int64
+    qb = box.query(int64_prop.greater_than(5).alias("greater_than_filter"))
 
     query = qb.build()
     assert query.count() == 1
@@ -288,6 +339,21 @@ def test_set_parameter_alias():
 
     assert query.count() == 2
 
+    # Test set parameter alias on string/int32
+    qb = box.query(str_prop.equals("Foo").alias("str condition"))
+    int32_prop.greater_than(700).alias("int32 condition").apply(qb)
+    query = qb.build()
+
+    assert query.count() == 1
+    assert query.find()[0].str == "Foo"
+
+    query.set_parameter_alias_string("str condition", "FooBar")  # FooBar int32 isn't higher than 700 (49)
+    assert query.count() == 0
+
+    query.set_parameter_alias_int("int32 condition", 40)
+    assert query.find()[0].str == "FooBar"
+
+    # Test set parameter alias on vector
     vector_prop: Property = VectorEntity.get_property("vector")
 
     query = box_vector.query(vector_prop.nearest_neighbor([3.4, 3.4], 3).alias("nearest_neighbour_filter")).build()