Queries: add conditions for Date and DateNano properties #94

Add a new condition class for each one, with methods explicitly named to
ensure it is clear how values are passed to the database. This does not
break existing user code as both condition classes inherit from the
previously used QueryIntegerProperty class.

Author: greenrobot-team

generator/lib/src/code_chunks.dart

@@ -677,9 +677,13 @@ class CodeChunks {
         case OBXPropertyType.Char:
         case OBXPropertyType.Int:
         case OBXPropertyType.Long:
+          fieldType = 'Integer';
+          break;
         case OBXPropertyType.Date:
+          fieldType = 'Date';
+          break;
         case OBXPropertyType.DateNano:
-          fieldType = 'Integer';
+          fieldType = 'DateNano';
           break;
         case OBXPropertyType.Relation:
           fieldType = 'Relation';

objectbox/CHANGELOG.md

@@ -18,6 +18,14 @@
   This is different from the existing `maxDBSizeInKB` property in that it is possible to remove data
   after reaching the limit and continue to use the database. See the `Store` documentation for more
   details.
+* For `DateTime` properties new convenience query conditions are generated that accept `DateTime`
+  and auto-convert to milliseconds (or nanoseconds for `@Property(type: PropertyType.dateNano)`) [#287](https://github.com/objectbox/objectbox-dart/issues/287)
+  ```dart
+  // For example instead of:
+  Order_.date.between(DateTime(2024, 1).millisecondsSinceEpoch, DateTime(2024, 2).millisecondsSinceEpoch)
+  // You can now just write:
+  Order_.date.betweenMilliseconds(DateTime(2024, 1), DateTime(2024, 2))
+  ```
 
 ## 2.4.0 (2023-12-13)
 

objectbox/lib/objectbox.dart

@@ -28,6 +28,8 @@ export 'src/query.dart'
         QueryStringProperty,
         QueryByteVectorProperty,
         QueryIntegerProperty,
+        QueryDateProperty,
+        QueryDateNanoProperty,
         QueryIntegerVectorProperty,
         QueryDoubleProperty,
         QueryDoubleVectorProperty,

objectbox/lib/src/native/query/query.dart

@@ -180,6 +180,113 @@ class QueryIntegerProperty<EntityT> extends QueryProperty<EntityT, int> {
       _opList(list, _ConditionOp.notOneOf, alias);
 }
 
+/// This wraps [QueryIntegerProperty] for [DateTime] properties to avoid
+/// having to manually convert to [DateTime.millisecondsSinceEpoch] when
+/// creating query conditions.
+class QueryDateProperty<EntityT> extends QueryIntegerProperty<EntityT> {
+  QueryDateProperty(super.model);
+
+  int _convert(DateTime value) => value.millisecondsSinceEpoch;
+
+  /// Like [equals], but converts to [DateTime.millisecondsSinceEpoch] for you.
+  Condition<EntityT> equalsMilliseconds(DateTime value, {String? alias}) =>
+      equals(_convert(value), alias: alias);
+
+  /// Like [notEquals], but converts to [DateTime.millisecondsSinceEpoch] for you.
+  Condition<EntityT> notEqualsMilliseconds(DateTime value, {String? alias}) =>
+      notEquals(_convert(value), alias: alias);
+
+  /// Like [greaterThan], but converts to [DateTime.millisecondsSinceEpoch] for you.
+  Condition<EntityT> greaterThanMilliseconds(DateTime value, {String? alias}) =>
+      greaterThan(_convert(value), alias: alias);
+
+  /// Like [greaterOrEqual], but converts to [DateTime.millisecondsSinceEpoch] for you.
+  Condition<EntityT> greaterOrEqualMilliseconds(DateTime value,
+          {String? alias}) =>
+      greaterOrEqual(_convert(value), alias: alias);
+
+  /// Like [lessThan], but converts to [DateTime.millisecondsSinceEpoch] for you.
+  Condition<EntityT> lessThanMilliseconds(DateTime value, {String? alias}) =>
+      lessThan(_convert(value), alias: alias);
+
+  /// Like [lessOrEqual], but converts to [DateTime.millisecondsSinceEpoch] for you.
+  Condition<EntityT> lessOrEqualMilliseconds(DateTime value, {String? alias}) =>
+      lessOrEqual(_convert(value), alias: alias);
+
+  /// Like [between], but converts to [DateTime.millisecondsSinceEpoch] for you.
+  Condition<EntityT> betweenMilliseconds(DateTime value1, DateTime value2,
+          {String? alias}) =>
+      between(_convert(value1), _convert(value2), alias: alias);
+
+  /// Like [oneOf], but converts to [DateTime.millisecondsSinceEpoch] for you.
+  Condition<EntityT> oneOfMilliseconds(List<DateTime> values,
+          {String? alias}) =>
+      oneOf(values.map(_convert).toList(), alias: alias);
+
+  /// Like [notOneOf], but converts to [DateTime.millisecondsSinceEpoch] for you.
+  Condition<EntityT> notOneOfMilliseconds(List<DateTime> values,
+          {String? alias}) =>
+      notOneOf(values.map(_convert).toList(), alias: alias);
+}
+
+/// This wraps [QueryIntegerProperty] for [DateTime] properties annotated with
+/// `@Property(type: PropertyType.dateNano)` to avoid having to manually convert
+/// to nanoseconds ([DateTime.microsecondsSinceEpoch] `* 1000`) when creating
+/// query conditions.
+class QueryDateNanoProperty<EntityT> extends QueryIntegerProperty<EntityT> {
+  QueryDateNanoProperty(super.model);
+
+  int _convert(DateTime value) => value.microsecondsSinceEpoch * 1000;
+
+  /// Like [equals], but converts to nanoseconds
+  /// ([DateTime.microsecondsSinceEpoch] `* 1000`) for you.
+  Condition<EntityT> equalsNanoseconds(DateTime value, {String? alias}) =>
+      equals(_convert(value), alias: alias);
+
+  /// Like [notEquals], but converts to nanoseconds
+  /// ([DateTime.microsecondsSinceEpoch] `* 1000`) for you.
+  Condition<EntityT> notEqualsNanoseconds(DateTime value, {String? alias}) =>
+      notEquals(_convert(value), alias: alias);
+
+  /// Like [greaterThan], but converts to nanoseconds
+  /// ([DateTime.microsecondsSinceEpoch] `* 1000`) for you.
+  Condition<EntityT> greaterThanNanoseconds(DateTime value, {String? alias}) =>
+      greaterThan(_convert(value), alias: alias);
+
+  /// Like [greaterOrEqual], but converts to nanoseconds
+  /// ([DateTime.microsecondsSinceEpoch] `* 1000`) for you.
+  Condition<EntityT> greaterOrEqualNanoseconds(DateTime value,
+          {String? alias}) =>
+      greaterOrEqual(_convert(value), alias: alias);
+
+  /// Like [lessThan], but converts to nanoseconds
+  /// ([DateTime.microsecondsSinceEpoch] `* 1000`) for you.
+  Condition<EntityT> lessThanNanoseconds(DateTime value, {String? alias}) =>
+      lessThan(_convert(value), alias: alias);
+
+  /// Like [lessOrEqual], but converts to nanoseconds
+  /// ([DateTime.microsecondsSinceEpoch] `* 1000`) for you.
+  Condition<EntityT> lessOrEqualNanoseconds(DateTime value, {String? alias}) =>
+      lessOrEqual(_convert(value), alias: alias);
+
+  /// Like [between], but converts to nanoseconds
+  /// ([DateTime.microsecondsSinceEpoch] `* 1000`) for you.
+  Condition<EntityT> betweenNanoseconds(DateTime value1, DateTime value2,
+          {String? alias}) =>
+      between(_convert(value1), _convert(value2), alias: alias);
+
+  /// Like [oneOf], but converts to nanoseconds
+  /// ([DateTime.microsecondsSinceEpoch] `* 1000`) for you.
+  Condition<EntityT> oneOfNanoseconds(List<DateTime> values, {String? alias}) =>
+      oneOf(values.map(_convert).toList(), alias: alias);
+
+  /// Like [notOneOf], but converts to nanoseconds
+  /// ([DateTime.microsecondsSinceEpoch] `* 1000`) for you.
+  Condition<EntityT> notOneOfNanoseconds(List<DateTime> values,
+          {String? alias}) =>
+      notOneOf(values.map(_convert).toList(), alias: alias);
+}
+
 /// For integer vectors (excluding [QueryByteVectorProperty]) greater, less and
 /// equal are supported on elements of the vector (e.g. "has element greater").
 class QueryIntegerVectorProperty<EntityT> extends QueryProperty<EntityT, int> {

objectbox_test/test/entity.dart

@@ -88,7 +88,9 @@ class TestEntity {
       this.tByteList,
       this.tInt8List,
       this.tUint8List,
-      this.ignore});
+      this.ignore,
+      this.tDate,
+      this.tDateNano});
 
   TestEntity.filled({
     this.id = 1,

objectbox_test/test/query_test.dart

@@ -195,6 +195,34 @@ void main() {
     expect(box.query(TestEntity_.tInt.between(3, 7)).build().count(), 3);
   });
 
+  test('date and date nano convenience conditions', () {
+    const count = 6;
+    final dates = [for (var i = 1; i <= count; i++) DateTime.utc(2000, 1, i)];
+    box.putMany([for (var d in dates) TestEntity(tDate: d, tDateNano: d)]);
+
+    queryAndAssert(QueryBuilder<TestEntity> builder) {
+      final items = builder.build().find();
+      expect(items.length, 3);
+      expect(items[0].tDate!.day, 3);
+      expect(items[1].tDate!.day, 4);
+      expect(items[2].tDate!.day, 5);
+    }
+
+    final from = dates[2];
+    final to = dates[4];
+
+    // With the existing QueryIntegerProperty (now a super type)
+    queryAndAssert(box.query(TestEntity_.tDate
+        .between(from.millisecondsSinceEpoch, to.millisecondsSinceEpoch)));
+    queryAndAssert(box.query(TestEntity_.tDateNano.between(
+        from.microsecondsSinceEpoch * 1000, to.microsecondsSinceEpoch * 1000)));
+    // With the new QueryDateProperty
+    queryAndAssert(box.query(TestEntity_.tDate.betweenMilliseconds(from, to)));
+    // With the new QueryDateNanoProperty
+    queryAndAssert(
+        box.query(TestEntity_.tDateNano.betweenNanoseconds(from, to)));
+  });
+
   test('.count matches of `greater` and `less`', () {
     box.putMany(<TestEntity>[
       TestEntity(tLong: 1336, tString: 'mord'),