Stuff

drift/lib/drift.dart

@@ -26,7 +26,6 @@ export 'src/runtime/manager/manager.dart'
         ComposerState,
         HasJoinBuilders,
         Composer,
-        AliasedComposerBuilder,
         BaseTableManager;
 export 'src/utils/lazy_database.dart';
 

drift/lib/src/runtime/manager/filter.dart

@@ -16,7 +16,7 @@ class ColumnFilters<T extends Object> {
   ColumnFilters(this.column);
 
   /// Column that this [ColumnFilters] wraps
-  GeneratedColumn<T> column;
+  Expression<T> column;
 
   /// Create a filter that checks if the column is null.
   ComposableFilter isNull() => ComposableFilter.simple(column.isNull());
@@ -28,9 +28,21 @@ class ColumnFilters<T extends Object> {
   ComposableFilter equals(T value) =>
       ComposableFilter.simple(column.equals(value));
 
+  /// Create a filter that checks if the column is in a list of values.
+
+  ComposableFilter isIn(List<T> values) =>
+      ComposableFilter.simple(column.isIn(values));
+
+  /// Create a filter that checks if the column is not in a list of values.
+  ComposableFilter isNotIn(List<T> values) =>
+      ComposableFilter.simple(column.isNotIn(values));
+
   /// Shortcut for [equals]
   ComposableFilter call(T value) =>
       ComposableFilter.simple(column.equals(value));
+
+  /// Nested column for filtering on the count of a column
+  ColumnFilters<int> get count => ColumnFilters(column.count());
 }
 
 /// Built in filters for int/double columns
@@ -58,6 +70,21 @@ extension NumFilters<T extends num> on ColumnFilters<T> {
   /// Create a filter to check if the column is not between two values
   ComposableFilter isNotBetween(T lower, T higher) =>
       isBetween(lower, higher)._reversed();
+
+  /// Nested column for filtering on the average of a column
+  ColumnFilters<double> get avg => ColumnFilters(column.avg());
+
+  /// Nested column for filtering on the max item of a column
+  ColumnFilters<T> get max => ColumnFilters(column.max());
+
+  /// Nested column for filtering on the min item of a column
+  ColumnFilters<T> get min => ColumnFilters(column.min());
+
+  /// Nested column for filtering on the sum of a column
+  ColumnFilters<T> get sum => ColumnFilters(column.sum());
+
+  /// Nested column for filtering on the total of a column
+  ColumnFilters<double> get total => ColumnFilters(column.total());
 }
 
 /// Built in filters for BigInt columns
@@ -85,6 +112,21 @@ extension BigIntFilters<T extends BigInt> on ColumnFilters<T> {
   /// Create a filter to check if the column is not between two values
   ComposableFilter isNotBetween(T lower, T higher) =>
       isBetween(lower, higher)._reversed();
+
+  /// Nested column for filtering on the average of a column
+  ColumnFilters<double> get avg => ColumnFilters(column.avg());
+
+  /// Nested column for filtering on the max item of a column
+  ColumnFilters<T> get max => ColumnFilters(column.max());
+
+  /// Nested column for filtering on the min item of a column
+  ColumnFilters<T> get min => ColumnFilters(column.min());
+
+  /// Nested column for filtering on the sum of a column
+  ColumnFilters<BigInt> get sum => ColumnFilters(column.sum());
+
+  /// Nested column for filtering on the total of a column
+  ColumnFilters<double> get total => ColumnFilters(column.total());
 }
 
 /// Built in filters for String columns
@@ -138,22 +180,6 @@ class ColumnWithTypeConverterFilters<CUSTOM, T extends Object> {
       ComposableFilter.simple(column.equalsValue(value));
 }
 
-// extension CustomFilters<CUSTOM, T extends Object,
-//         C extends GeneratedColumnWithTypeConverter<CUSTOM, T>>
-//     on ColumnFilters<T, C> {
-//   /// Create a filter that checks if the column equals the columns custom type
-//   ComposableFilter equals(CUSTOM value) =>
-//       ComposableFilter.simple(column.equalsValue(value));
-
-//   /// Create a filter that checks if the column equals the value of the columns custom type
-//   ComposableFilter equalsValue(T value) =>
-//       ComposableFilter.simple(column.equals(value));
-
-//   /// Shortcut for [equals]
-//   ComposableFilter call(CUSTOM value) =>
-//       ComposableFilter.simple(column.equalsValue(value));
-// }
-
 /// Defines a class that can be used to compose filters for a column
 class ComposableFilter implements HasJoinBuilders {
   @override

drift/lib/src/runtime/manager/manager.dart

@@ -149,30 +149,29 @@ class TableManagerState<
     }
   }
 
-  /// Build a delete statement based on the manager state
+  // Build a delete statement based on the manager state
   // DeleteStatement buildDeleteStatement() {
-  //   // Being that drift doesnt support joins on deletes, if there are any joins we will use 2 queries
+  //   // If there are any joins we will have to use a subquery to get the rowIds
   //   final DeleteStatement deleteStatement;
-  //   // Check if there are any joins
-  //   if (_joins.isEmpty) {
-  //     // If there are no joins, we can just use a single delete statement
+  //   if (joinBuilders.isEmpty) {
   //     deleteStatement = db.delete(_tableAsTableInfo);
-  //     if (filter?.expression != null) {
-  //       deleteStatement.where((_) => filter!.expression);
+  //     if (filter != null) {
+  //       deleteStatement.where((_) => filter!);
   //     }
   //   } else {
   //     // If there are joins, we need to use a subquery to get the rowIds
-  //     final selectOnlyRowIdStatement =
-  //         _buildJoinedStatement(onlyWithRowId: true);
+  //     final selectOnlyRowIdStatement = buildSelectStatement();
   //     deleteStatement = db.delete(_tableAsTableInfo)
-  //       ..where(
-  //           (_) => _tableAsTableInfo.rowId.isInQuery(selectOnlyRowIdStatement));
+  //       ..where((_) =>
+  //           _tableAsTableInfo.rowId.isInQuery(_buildJoinedSelectStatement()));
   //   }
   //   return deleteStatement;
   // }
 }
 
-/// Defines the base class for a table manager
+/// Base class for all table managers
+/// Most of this classes functionality is kept in a seperate [TableManagerState] class
+/// This is so that the state can be passed down to lower level managers
 @internal
 abstract class BaseTableManager<
     DB extends GeneratedDatabase,
@@ -187,18 +186,32 @@ abstract class BaseTableManager<
   const BaseTableManager(this.state);
 }
 
-/// Mixin that adds processed functions to a table manager
-/// Is used to act on a table manager that has filtering/ordering applied
+/// Mixin for adding select functionality to a table manager
 mixin ProcessedTableManagerMixin<
-    DB extends GeneratedDatabase,
-    T extends TableInfo,
-    D extends DataClass,
-    FS extends FilterComposer<DB, T>,
-    OS extends OrderingComposer<DB, T>> on BaseTableManager<DB, T, D, FS, OS> {
+        DB extends GeneratedDatabase,
+        T extends TableInfo,
+        D extends DataClass,
+        FS extends FilterComposer<DB, T>,
+        OS extends OrderingComposer<DB, T>>
+    on BaseTableManager<DB, T, D, FS, OS>
+    implements
+        MultiSelectable<D>,
+        SingleSelectable<D>,
+        SingleOrNullSelectable<D> {
+  @override
   Future<D> getSingle() => state.buildSelectStatement().getSingle();
+  @override
   Stream<D> watchSingle() => state.buildSelectStatement().watchSingle();
+  @override
   Future<List<D>> get() => state.buildSelectStatement().get();
+  @override
   Stream<List<D>> watch() => state.buildSelectStatement().watch();
+  @override
+  Future<D?> getSingleOrNull() =>
+      state.buildSelectStatement().getSingleOrNull();
+  @override
+  Stream<D?> watchSingleOrNull() =>
+      state.buildSelectStatement().watchSingleOrNull();
   // Future<int> delete() => state.buildDeleteStatement().go();
 }
 
@@ -225,6 +238,7 @@ class TableManagerWithFiltering<
         C extends ProcessedTableManager<DB, T, D, FS, OS>>
     extends BaseTableManager<DB, T, D, FS, OS>
     with ProcessedTableManagerMixin<DB, T, D, FS, OS> {
+  /// Callback for
   final C Function(TableManagerState<DB, T, D, FS, OS>) getChildManager;
   const TableManagerWithFiltering(super.state, {required this.getChildManager});
   C filter(ComposableFilter Function(FS f) f) {