query/condition: support for float scalar values #29

Author: dan-obx

objectbox/condition.py

@@ -162,6 +162,8 @@ def _apply_gt(self, qb: QueryBuilder) -> obx_qb_cond:
             return qb.greater_than_string(self._property_id, value, case_sensitive)
         elif isinstance(value, int):
             return qb.greater_than_int(self._property_id, value)
+        elif isinstance(value, float):
+            return qb.greater_than_double(self._property_id, value)
         else:
             raise Exception(f"Unsupported type for 'GT': {type(value)}")
 
@@ -172,6 +174,8 @@ def _apply_gte(self, qb: QueryBuilder) -> obx_qb_cond:
             return qb.greater_or_equal_string(self._property_id, value, case_sensitive)
         elif isinstance(value, int):
             return qb.greater_or_equal_int(self._property_id, value)
+        elif isinstance(value, float):
+            return qb.greater_or_equal_double(self._property_id, value)
         else:
             raise Exception(f"Unsupported type for 'GTE': {type(value)}")
 
@@ -182,6 +186,8 @@ def _apply_lt(self, qb: QueryBuilder) -> obx_qb_cond:
             return qb.less_than_string(self._property_id, value, case_sensitive)
         elif isinstance(value, int):
             return qb.less_than_int(self._property_id, value)
+        elif isinstance(value, float):
+            return qb.less_than_double(self._property_id, value)
         else:
             raise Exception("Unsupported type for 'LT': " + str(type(value)))
 
@@ -192,14 +198,18 @@ def _apply_lte(self, qb: QueryBuilder) -> obx_qb_cond:
             return qb.less_or_equal_string(self._property_id, value, case_sensitive)
         elif isinstance(value, int):
             return qb.less_or_equal_int(self._property_id, value)
+        elif isinstance(value, float):
+            return qb.less_or_equal_double(self._property_id, value)
         else:
             raise Exception(f"Unsupported type for 'LTE': {type(value)}")
 
     def _apply_between(self, qb: QueryBuilder) -> obx_qb_cond:
         a = self._args['a']
         b = self._args['b']
-        if isinstance(a, int):
+        if isinstance(a, int) and isinstance(b, int):
             return qb.between_2ints(self._property_id, a, b)
+        elif isinstance(a, float) or isinstance(b, float):
+            return qb.between_2doubles(self._property_id, a, b)
         else:
             raise Exception(f"Unsupported type for 'BETWEEN': {type(a)}")
 

objectbox/query_builder.py

@@ -88,26 +88,51 @@ def greater_than_int(self, prop: Union[int, str, Property], value: int) -> obx_q
         prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_greater_than_int(self._c_builder, prop_id, value)
         return cond
+    
+    def greater_than_double(self, prop: Union[int, str, Property], value: float) -> obx_qb_cond:
+        prop_id = self._entity.get_property_id(prop)
+        cond = obx_qb_greater_than_double(self._c_builder, prop_id, value)
+        return cond
 
     def greater_or_equal_int(self, prop: Union[int, str, Property], value: int) -> obx_qb_cond:
         prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_greater_or_equal_int(self._c_builder, prop_id, value)
         return cond
+    
+    def greater_or_equal_double(self, prop: Union[int, str, Property], value: float) -> obx_qb_cond:
+        prop_id = self._entity.get_property_id(prop)
+        cond = obx_qb_greater_or_equal_double(self._c_builder, prop_id, value)
+        return cond
 
     def less_than_int(self, prop: Union[int, str, Property], value: int) -> obx_qb_cond:
         prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_less_than_int(self._c_builder, prop_id, value)
         return cond
+    
+    def less_than_double(self, prop: Union[int, str, Property], value: float) -> obx_qb_cond:
+        prop_id = self._entity.get_property_id(prop)
+        cond = obx_qb_less_than_double(self._c_builder, prop_id, value)
+        return cond
 
     def less_or_equal_int(self, prop: Union[int, str, Property], value: int) -> obx_qb_cond:
         prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_less_or_equal_int(self._c_builder, prop_id, value)
         return cond
+    
+    def less_or_equal_double(self, prop: Union[int, str, Property], value: float) -> obx_qb_cond:
+        prop_id = self._entity.get_property_id(prop)
+        cond = obx_qb_less_or_equal_double(self._c_builder, prop_id, value)
+        return cond
 
     def between_2ints(self, prop: Union[int, str, Property], value_a: int, value_b: int) -> obx_qb_cond:
         prop_id = self._entity.get_property_id(prop)
         cond = obx_qb_between_2ints(self._c_builder, prop_id, value_a, value_b)
         return cond
+    
+    def between_2doubles(self, prop: Union[int, str, Property], value_a: float, value_b: float) -> obx_qb_cond:
+        prop_id = self._entity.get_property_id(prop)
+        cond = obx_qb_between_2doubles(self._c_builder, prop_id, value_a, value_b)
+        return cond
 
     def nearest_neighbors_f32(self,
                               prop: Union[int, str, Property],

tests/test_query.py

@@ -216,6 +216,29 @@ def test_float_scalars():
         assert query.count() == 2
         assert query.find()[0].id == id1
         assert query.find()[1].id == id2
+    
+    # Test float scalar values 
+    for p in props:
+        prop = TestEntity.get_property(p)
+        query = box_test_entity.query(prop.greater_or_equal(11.0)).build()
+        assert query.count() == 2
+        assert query.find()[0].id == id1
+        assert query.find()[1].id == id2
+        query = box_test_entity.query(prop.greater_than(12.0)).build()
+        assert query.count() == 1
+        assert query.find()[0].id == id2
+        query = box_test_entity.query(prop.less_than(45.0)).build()
+        assert query.count() == 1
+        assert query.find()[0].id == id1
+        query = box_test_entity.query(prop.less_or_equal(45.0)).build()
+        assert query.count() == 2
+        assert query.find()[0].id == id1
+        assert query.find()[1].id == id2
+        query = box_test_entity.query(prop.between(10.0,50.0)).build()
+        assert query.count() == 2
+        assert query.find()[0].id == id1
+        assert query.find()[1].id == id2
+
 
 def test_flex_contains_key_value():
     store = create_test_store()