properties: Added Bytes + support for bytes conditions #29

Author: dan-obx

objectbox/condition.py

@@ -118,6 +118,8 @@ def _apply_eq(self, qb: QueryBuilder) -> obx_qb_cond:
             return qb.equals_string(self._property_id, value, case_sensitive)
         elif isinstance(value, int):
             return qb.equals_int(self._property_id, value)
+        elif isinstance(value, bytes):
+            return qb.equals_bytes(self._property_id, value)
         else:
             raise Exception(f"Unsupported type for 'EQ': {type(value)}")
 
@@ -164,6 +166,8 @@ def _apply_gt(self, qb: QueryBuilder) -> obx_qb_cond:
             return qb.greater_than_int(self._property_id, value)
         elif isinstance(value, float):
             return qb.greater_than_double(self._property_id, value)
+        elif isinstance(value, bytes):
+            return qb.greater_than_bytes(self._property_id, value)
         else:
             raise Exception(f"Unsupported type for 'GT': {type(value)}")
 
@@ -176,6 +180,8 @@ def _apply_gte(self, qb: QueryBuilder) -> obx_qb_cond:
             return qb.greater_or_equal_int(self._property_id, value)
         elif isinstance(value, float):
             return qb.greater_or_equal_double(self._property_id, value)
+        elif isinstance(value, bytes):
+            return qb.greater_or_equal_bytes(self._property_id, value)
         else:
             raise Exception(f"Unsupported type for 'GTE': {type(value)}")
 
@@ -188,6 +194,8 @@ def _apply_lt(self, qb: QueryBuilder) -> obx_qb_cond:
             return qb.less_than_int(self._property_id, value)
         elif isinstance(value, float):
             return qb.less_than_double(self._property_id, value)
+        elif isinstance(value, bytes):
+            return qb.less_than_bytes(self._property_id, value)
         else:
             raise Exception("Unsupported type for 'LT': " + str(type(value)))
 
@@ -200,6 +208,8 @@ def _apply_lte(self, qb: QueryBuilder) -> obx_qb_cond:
             return qb.less_or_equal_int(self._property_id, value)
         elif isinstance(value, float):
             return qb.less_or_equal_double(self._property_id, value)
+        elif isinstance(value, bytes):
+            return qb.less_or_equal_bytes(self._property_id, value)
         else:
             raise Exception(f"Unsupported type for 'LTE': {type(value)}")
 

objectbox/model/__init__.py

@@ -55,4 +55,5 @@
     'Int64List',
     'Float32List',
     'Float64List',
+    'Bytes',
 ]

objectbox/model/properties.py

@@ -311,6 +311,31 @@ class DateNano(_IntProperty):
     def __init__(self, py_type = datetime, id : int = 0, uid : int = 0, **kwargs):
         super(DateNano, self).__init__(py_type, type=PropertyType.dateNano, id=id, uid=uid, **kwargs)
 
+# Bytes Property
+class Bytes(_NumericProperty):
+    def __init__(self, id: int = 0, uid : int = 0, **kwargs):
+        super(Bytes, self).__init__(bytes, type=PropertyType.byteVector, id=id, uid=uid, **kwargs)
+    
+    def equals(self, value) -> PropertyQueryCondition:
+        args = {'value': value}
+        return PropertyQueryCondition(self._id, PropertyQueryConditionOp.EQ, args)
+    
+    def greater_than(self, value) -> PropertyQueryCondition:
+        args = {'value': value}
+        return PropertyQueryCondition(self._id, PropertyQueryConditionOp.GT, args)
+
+    def greater_or_equal(self, value) -> PropertyQueryCondition:
+        args = {'value': value}
+        return PropertyQueryCondition(self._id, PropertyQueryConditionOp.GTE, args)
+
+    def less_than(self, value) -> PropertyQueryCondition:
+        args = {'value': value}
+        return PropertyQueryCondition(self._id, PropertyQueryConditionOp.LT, args)
+
+    def less_or_equal(self, value) -> PropertyQueryCondition:
+        args = {'value': value}
+        return PropertyQueryCondition(self._id, PropertyQueryConditionOp.LTE, args)
+
 # Flex Property
 class Flex(Property):
     def __init__(self, id : int = 0, uid : int = 0, **kwargs):

objectbox/query_builder.py

@@ -134,6 +134,31 @@ def between_2doubles(self, prop: Union[int, str, Property], value_a: float, valu
         cond = obx_qb_between_2doubles(self._c_builder, prop_id, value_a, value_b)
         return cond
 
+    def equals_bytes(self, prop: Union[int, str, Property], value: bytes) -> obx_qb_cond:
+        prop_id = self._entity.get_property_id(prop)
+        cond = obx_qb_equals_bytes(self._c_builder, prop_id, value, len(value))
+        return cond
+    
+    def greater_than_bytes(self, prop: Union[int, str, Property], value: bytes) -> obx_qb_cond:
+        prop_id = self._entity.get_property_id(prop)
+        cond = obx_qb_greater_than_bytes(self._c_builder, prop_id, value, len(value))
+        return cond
+    
+    def greater_or_equal_bytes(self, prop: Union[int, str, Property], value: bytes) -> obx_qb_cond:
+        prop_id = self._entity.get_property_id(prop)
+        cond = obx_qb_greater_or_equal_bytes(self._c_builder, prop_id, value, len(value))
+        return cond
+    
+    def less_than_bytes(self, prop: Union[int, str, Property], value: bytes) -> obx_qb_cond:
+        prop_id = self._entity.get_property_id(prop)
+        cond = obx_qb_less_than_bytes(self._c_builder, prop_id, value, len(value))
+        return cond
+    
+    def less_or_equal_bytes(self, prop: Union[int, str, Property], value: bytes) -> obx_qb_cond:
+        prop_id = self._entity.get_property_id(prop)
+        cond = obx_qb_less_or_equal_bytes(self._c_builder, prop_id, value, len(value))
+        return cond
+    
     def nearest_neighbors_f32(self,
                               prop: Union[int, str, Property],
                               query_vector: Union[np.ndarray, List[float]],

tests/common.py

@@ -14,7 +14,7 @@
 
 def create_default_model() -> objectbox.Model:
     model = objectbox.Model()
-    model.entity(TestEntity, last_property_id=IdUid(27, 1027))
+    model.entity(TestEntity, last_property_id=IdUid(28, 1028))
     model.last_entity_id = IdUid(2, 2)
     model.last_index_id = IdUid(2, 10002)
     return model
@@ -55,7 +55,7 @@ def create_test_store(db_name: Optional[str] = None, clear_db: bool = True) -> o
         shutil.rmtree(db_path)
 
     model = objectbox.Model()
-    model.entity(TestEntity, last_property_id=IdUid(27, 1027))
+    model.entity(TestEntity, last_property_id=IdUid(28, 1028))
     model.entity(TestEntityDatetime, last_property_id=IdUid(4, 2004))
     model.entity(TestEntityFlex, last_property_id=IdUid(2, 3002))
     model.entity(VectorEntity, last_property_id=IdUid(5, 4005))

tests/model.py

@@ -34,6 +34,7 @@ class TestEntity:
     date = Date(id=25, uid=1025)
     date_nano = DateNano(int, id=26, uid=1026)
     flex = Flex(id=27, uid=1027)
+    bytes = Bytes(id=28, uid=1028)
     transient = ""  # not "Property" so it's not stored
 
 

tests/test_query.py

@@ -586,3 +586,50 @@ def test_set_parameter_alias_advanced():
     query.set_parameter_alias_string("str_filter", "Zucchini")
     assert len(query.find_ids()) == 1  # Zucchini
 
+
+# Bytes query
+def test_bytes():
+    store = create_test_store()
+    box = store.box(TestEntity)
+   
+    bytes_prop: Property = TestEntity.get_property("bytes")
+    
+    
+    id1 = box.put(TestEntity(bytes=bytes([9])))
+    id2 = box.put(TestEntity(bytes=bytes([1,0])))
+    id3 = box.put(TestEntity(bytes=bytes([0,1])))
+    query = box.query(bytes_prop.greater_or_equal(bytes([0]))).build() 
+    assert query.count() == 3
+    query = box.query(bytes_prop.greater_or_equal(bytes([1]))).build() 
+    assert query.count() == 2
+    query = box.query(bytes_prop.greater_or_equal(bytes([9]))).build() 
+    assert query.count() == 1
+  
+    assert box.remove_all() == 3
+    id1 = box.put(TestEntity(bytes=bytes([1,2,3,4])))
+    id2 = box.put(TestEntity(bytes=bytes([5,6,7,8,9,10,11])))
+    query = box.query(bytes_prop.equals(bytes([1,2,3,4]))).build() 
+    assert query.count() == 1
+    assert query.find()[0].id == id1
+
+    query = box.query(bytes_prop.greater_than(bytes([1,2,3,4]))).build() 
+    assert query.count() == 1
+    assert query.find()[0].id == id2
+    
+    query = box.query(bytes_prop.greater_or_equal(bytes([1,2,3,4]))).build() 
+    assert query.count() == 2
+    
+    query = box.query(bytes_prop.greater_or_equal(bytes([0]))).build() 
+    assert query.count() == 2
+    
+    query = box.query(bytes_prop.less_than(bytes([5,6,7,8,9,10,11]))).build() 
+    assert query.count() == 1
+    assert query.find()[0].id == id1
+    
+    query = box.query(bytes_prop.less_or_equal(bytes([5,6,7,8,9,10,11]))).build() 
+    assert query.count() == 2
+    
+    # bytes does not support not equals
+    with pytest.raises(AttributeError):
+        bytes_prop.not_equals(bytes([])) 
+