Arithmetic operators for sql expressions in Dart

moor/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## unreleased
 
+- New extension methods to simplify the Dart api!
+  - Use `&`, `or` and `.not()` to combine boolean expressions
+  - Arithmetic: New `+`, `-`, `*` and `/` operators for int and double sql expressions
+  - New `+` operator for string concatenation
 - Fix crash when `customStatement` is the first operation used on a database ([#199](https://github.com/simolus3/moor/issues/199))
 - Allow transactions inside a `beforeOpen` callback
 - New `batch` method on generated databases to execute multiple queries in a single batch

moor/lib/moor.dart

@@ -15,7 +15,8 @@ export 'package:moor/src/runtime/executor/transactions.dart';
 export 'package:moor/src/runtime/data_verification.dart';
 export 'package:moor/src/runtime/data_class.dart';
 export 'package:moor/src/runtime/database.dart';
-export 'package:moor/src/runtime/types/sql_types.dart';
+export 'package:moor/src/runtime/types/sql_types.dart'
+    hide ComparableType, Monoid, FullArithmetic;
 export 'package:moor/src/runtime/exceptions.dart';
 export 'package:moor/src/utils/expand_variables.dart';
 export 'package:moor/src/utils/hash.dart';

moor/lib/src/runtime/database.dart

@@ -347,8 +347,6 @@ mixin QueryEngine on DatabaseConnectionUser {
   ///     might be different than that of the "global" database instance.
   ///  2. Nested transactions are not supported. Creating another transaction
   ///     inside a transaction returns the parent transaction.
-  @protected
-  @visibleForTesting
   Future<T> transaction<T>(Future<T> Function() action) async {
     final resolved = _resolvedEngine;
     if (resolved is Transaction) {

moor/lib/src/runtime/query_builder/expressions/algebra.dart

@@ -0,0 +1,45 @@
+part of '../query_builder.dart';
+
+/// Defines the `+` operator on sql expressions that support it.
+extension MonoidExpr<DT, ST extends Monoid<DT>> on Expression<DT, ST> {
+  /// Performs an addition (`this` + [other]) in sql.
+  Expression<DT, ST> operator +(Expression<DT, ST> other) {
+    assert(other is! Expression<String, StringType>,
+        'Used Monoid extension but should have resolved to String extension');
+
+    return _BaseInfixOperator(this, '+', other);
+  }
+}
+
+/// Defines the `+` operator as a concatenation for string expressions.
+extension StringMonoidExpr on Expression<String, StringType> {
+  /// Performs a string concatenation in sql by appending [other] to `this`.
+  Expression<String, StringType> operator +(
+      Expression<String, StringType> other) {
+    return _BaseInfixOperator(this, '||', other);
+  }
+}
+
+/// Defines the `-`, `*` and `/` operators on sql expressions that support it.
+extension ArithmeticExpr<DT, ST extends FullArithmetic<DT>>
+    on Expression<DT, ST> {
+  /// Performs a subtraction (`this` - [other]) in sql.
+  Expression<DT, ST> operator -(Expression<DT, ST> other) {
+    return _BaseInfixOperator(this, '-', other);
+  }
+
+  /// Returns the negation of this value.
+  Expression<DT, ST> operator -() {
+    return _UnaryMinus(this);
+  }
+
+  /// Performs a multiplication (`this` * [other]) in sql.
+  Expression<DT, ST> operator *(Expression<DT, ST> other) {
+    return _BaseInfixOperator(this, '*', other);
+  }
+
+  /// Performs a division (`this` / [other]) in sql.
+  Expression<DT, ST> operator /(Expression<DT, ST> other) {
+    return _BaseInfixOperator(this, '/', other);
+  }
+}

moor/lib/src/runtime/query_builder/expressions/comparable.dart

@@ -1,7 +1,7 @@
 part of '../query_builder.dart';
 
 /// Defines extension functions to express comparisons in sql
-extension ComparableExpr<DT, ST extends SqlType<DT>, Comparable>
+extension ComparableExpr<DT, ST extends ComparableType<DT>>
     on Expression<DT, ST> {
   /// Returns an expression that is true if this expression is strictly bigger
   /// than the other expression.

moor/lib/src/runtime/query_builder/expressions/datetimes.dart

@@ -30,6 +30,8 @@ Expression<int, IntType> minute(Expression<DateTime, DateTimeType> date) =>
 Expression<int, IntType> second(Expression<DateTime, DateTimeType> date) =>
     _StrftimeSingleFieldExpression('%S', date);
 
+// todo: Add difference and unixSeconds method, also convert to extension
+
 /// A sql expression that evaluates to the current date represented as a unix
 /// timestamp. The hour, minute and second fields will be set to 0.
 const Expression<DateTime, DateTimeType> currentDate =
@@ -45,6 +47,10 @@ class _CustomDateTimeExpression
   const _CustomDateTimeExpression(String content) : super(content);
 }
 
+/// Provides expressions to extract information from date time values, or to
+/// calculate the difference between datetimes.
+extension DateTimeExpressions on Expression<DateTime, DateTimeType> {}
+
 /// Expression that extracts components out of a date time by using the builtin
 /// sqlite function "strftime" and casting the result to an integer.
 class _StrftimeSingleFieldExpression extends Expression<int, IntType> {

moor/lib/src/runtime/query_builder/expressions/expression.dart

@@ -62,6 +62,19 @@ abstract class _InfixOperator<D, T extends SqlType<D>>
   }
 }
 
+class _BaseInfixOperator<D, T extends SqlType<D>> extends _InfixOperator<D, T> {
+  @override
+  final Expression<D, T> left;
+
+  @override
+  final String operator;
+
+  @override
+  final Expression<D, T> right;
+
+  _BaseInfixOperator(this.left, this.operator, this.right);
+}
+
 /// Defines the possible comparison operators that can appear in a [_Comparison].
 enum _ComparisonOperator {
   /// '<' in sql
@@ -111,3 +124,15 @@ class _Comparison extends _InfixOperator<bool, BoolType> {
   /// Like [Comparison(left, op, right)], but uses [_ComparisonOperator.equal].
   _Comparison.equal(this.left, this.right) : op = _ComparisonOperator.equal;
 }
+
+class _UnaryMinus<DT, ST extends SqlType<DT>> extends Expression<DT, ST> {
+  final Expression<DT, ST> inner;
+
+  _UnaryMinus(this.inner);
+
+  @override
+  void writeInto(GenerationContext context) {
+    context.buffer.write('-');
+    inner.writeInto(context);
+  }
+}

moor/lib/src/runtime/query_builder/query_builder.dart

@@ -6,6 +6,7 @@ import 'package:meta/meta.dart';
 import 'package:moor/moor.dart' hide BooleanExpressionOperators;
 import 'package:moor/sqlite_keywords.dart';
 import 'package:moor/src/runtime/executor/stream_queries.dart';
+import 'package:moor/src/runtime/types/sql_types.dart';
 import 'package:moor/src/utils/single_transformer.dart';
 
 part 'components/join.dart';
@@ -13,6 +14,7 @@ part 'components/limit.dart';
 part 'components/order_by.dart';
 part 'components/where.dart';
 
+part 'expressions/algebra.dart';
 part 'expressions/bools.dart';
 part 'expressions/comparable.dart';
 part 'expressions/custom.dart';

moor/lib/src/runtime/types/sql_types.dart

@@ -25,7 +25,15 @@ abstract class SqlType<T> {
 
 /// A marker interface for [SqlType]s that can be compared using the comparison
 /// operators in sql.
-abstract class ComparableType {}
+abstract class ComparableType<T> extends SqlType<T> {}
+
+/// A marker interface for [SqlType]s that have a `+` operator.
+abstract class Monoid<T> extends SqlType<T> {}
+
+/// A marker interface for [SqlType]s that support all basic arithmetic
+/// operators (`+`, `-`, `*` and `/`) while also being a [ComparableType]
+abstract class FullArithmetic<T> extends Monoid<T>
+    implements ComparableType<T> {}
 
 /// A mapper for boolean values in sql. Booleans are represented as integers,
 /// where 0 means false and any other value means true.
@@ -58,7 +66,7 @@ class BoolType extends SqlType<bool> {
 }
 
 /// Mapper for string values in sql.
-class StringType extends SqlType<String> {
+class StringType extends SqlType<String> implements Monoid<String> {
   /// Constant constructor used by the type system
   const StringType();
 
@@ -81,7 +89,7 @@ class StringType extends SqlType<String> {
 }
 
 /// Maps [int] values from and to sql
-class IntType extends SqlType<int> implements ComparableType {
+class IntType extends SqlType<int> implements FullArithmetic<int> {
   /// Constant constructor used by the type system
   const IntType();
 
@@ -98,7 +106,8 @@ class IntType extends SqlType<int> implements ComparableType {
 }
 
 /// Maps [DateTime] values from and to sql
-class DateTimeType extends SqlType<DateTime> implements ComparableType {
+class DateTimeType extends SqlType<DateTime>
+    implements ComparableType<DateTime> {
   /// Constant constructor used by the type system
   const DateTimeType();
 
@@ -127,7 +136,7 @@ class DateTimeType extends SqlType<DateTime> implements ComparableType {
 }
 
 /// Maps [Uint8List] values from and to sql
-class BlobType extends SqlType<Uint8List> implements ComparableType {
+class BlobType extends SqlType<Uint8List> {
   /// Constant constructor used by the type system
   const BlobType();
 
@@ -146,7 +155,7 @@ class BlobType extends SqlType<Uint8List> implements ComparableType {
 }
 
 /// Maps [double] values from and to sql
-class RealType extends SqlType<double> implements ComparableType {
+class RealType extends SqlType<double> implements FullArithmetic<double> {
   /// Constant constructor used by the type system
   const RealType();
 

moor/test/expressions/algebra_test.dart

@@ -0,0 +1,26 @@
+import 'package:moor/moor.dart';
+import 'package:test/test.dart';
+
+import '../data/tables/todos.dart';
+
+void main() {
+  final i1 = GeneratedIntColumn('i1', 'tbl', true);
+  final i2 = GeneratedIntColumn('i2', 'tbl', true);
+  final s1 = GeneratedTextColumn('s1', 'tbl', true);
+  final s2 = GeneratedTextColumn('s2', 'tbl', true);
+
+  test('arithmetic test', () {
+    _expectSql(i1 + i2 * i1, '(i1) + ((i2) * (i1))');
+  });
+
+  test('string concatenation', () {
+    _expectSql(s1 + s2, '(s1) || (s2)');
+  });
+}
+
+void _expectSql(Expression e, String expected) {
+  final ctx = GenerationContext.fromDb(TodoDb(null));
+  e.writeInto(ctx);
+
+  expect(ctx.sql, expected);
+}