From 4b3dd99a0a43e10914542d8ec7e908600e5c6af2 Mon Sep 17 00:00:00 2001 From: Moshe Dicker Date: Mon, 1 Apr 2024 20:08:41 -0400 Subject: [PATCH] sd --- drift/lib/src/runtime/manager/manager.dart | 115 ++++++++++----------- 1 file changed, 57 insertions(+), 58 deletions(-) diff --git a/drift/lib/src/runtime/manager/manager.dart b/drift/lib/src/runtime/manager/manager.dart index cf4aabc7..1ab06612 100644 --- a/drift/lib/src/runtime/manager/manager.dart +++ b/drift/lib/src/runtime/manager/manager.dart @@ -29,7 +29,9 @@ class TableManagerState< T extends Table, DT extends DataClass, FS extends FilterComposer, - OS extends OrderingComposer> { + OS extends OrderingComposer, + C extends ProcessedTableManager, + CH extends C Function(TableManagerState)> { /// The database that the query will be exeCCted on final DB db; @@ -66,6 +68,9 @@ class TableManagerState< /// which will be applied to the statement when its eventually created final OS orderingComposer; + /// This function is used internaly to return a new instance of the child manager + final CH _getChildManagerBuilder; + /// Defines a class which holds the state for a table manager /// It contains the database instance, the table instance, and any filters/orderings that will be applied to the query /// This is held in a seperate class than the [BaseTableManager] so that the state can be passed down from the root manager to the lower level managers @@ -74,16 +79,17 @@ class TableManagerState< required this.table, required this.filteringComposer, required this.orderingComposer, + required CH getChildManagerBuilder, this.filter, this.distinct, this.limit, this.offset, this.orderingBuilders = const {}, this.joinBuilders = const {}, - }); + }) : _getChildManagerBuilder = getChildManagerBuilder; /// Copy this state with the given values - TableManagerState copyWith({ + TableManagerState copyWith({ bool? distinct, int? limit, int? offset, @@ -96,6 +102,7 @@ class TableManagerState< table: table, filteringComposer: filteringComposer, orderingComposer: orderingComposer, + getChildManagerBuilder: _getChildManagerBuilder, filter: filter ?? this.filter, joinBuilders: joinBuilders ?? this.joinBuilders, orderingBuilders: orderingBuilders ?? this.orderingBuilders, @@ -221,55 +228,51 @@ class TableManagerState< @internal abstract class BaseTableManager< DB extends GeneratedDatabase, - T extends TableInfo, + T extends Table, DT extends DataClass, FS extends FilterComposer, OS extends OrderingComposer, - C extends ProcessedTableManager> { + C extends ProcessedTableManager, + CH extends C Function(TableManagerState)> { /// The state for this manager - final TableManagerState state; - final C Function(TableManagerState, - BaseTableManager) getChildManager; + final TableManagerState state; /// Create a new [BaseTableManager] instance - const BaseTableManager(this.state, this.getChildManager); + BaseTableManager(this.state); Future delete() => state.buildDeleteStatement().go(); C orderBy(ComposableOrdering Function(OS o) o) { final orderings = o(state.orderingComposer); - return getChildManager( - state.copyWith( - orderingBuilders: - orderings.orderingBuilders.union(state.orderingBuilders), - joinBuilders: state.joinBuilders.union(orderings.joinBuilders)), - this); + return state._getChildManagerBuilder(state.copyWith( + orderingBuilders: + state.orderingBuilders.union(orderings.orderingBuilders), + joinBuilders: state.joinBuilders.union(orderings.joinBuilders))); } C filter(ComposableFilter Function(FS f) f) { final filter = f(state.filteringComposer); - return getChildManager( - state.copyWith( - filter: state.filter == null - ? filter.expression - : filter.expression & state.filter!, - joinBuilders: state.joinBuilders.union(filter.joinBuilders)), - this); + return state._getChildManagerBuilder(state.copyWith( + filter: state.filter == null + ? filter.expression + : filter.expression & state.filter!, + joinBuilders: state.joinBuilders.union(filter.joinBuilders))); } } abstract class ProcessedTableManager< DB extends GeneratedDatabase, - T extends TableInfo, + T extends Table, D extends DataClass, FS extends FilterComposer, OS extends OrderingComposer, - C extends ProcessedTableManager> - extends BaseTableManager + C extends ProcessedTableManager, + CH extends C Function(TableManagerState)> + extends BaseTableManager implements MultiSelectable, SingleSelectable, SingleOrNullSelectable { - const ProcessedTableManager(super.state, super.getChildManager); + ProcessedTableManager(super.state); @override Future getSingle() => state.buildSelectStatement().getSingle(); @@ -291,43 +294,39 @@ abstract class ProcessedTableManager< /// A table manager with top level function for creating, reading, updating, and deleting items abstract class RootTableManager< - DB extends GeneratedDatabase, - T extends TableInfo, - D extends DataClass, - FS extends FilterComposer, - OS extends OrderingComposer, - C extends ProcessedTableManager, - CI extends Function> extends BaseTableManager { - final CI _createInsertable; - - RootTableManager(super.state, super.getChildManager, - {required CI createInsertable}) - : _createInsertable = createInsertable; + DB extends GeneratedDatabase, + T extends Table, + D extends DataClass, + FS extends FilterComposer, + OS extends OrderingComposer, + C extends ProcessedTableManager, + CH extends C Function(TableManagerState)> + extends BaseTableManager { + RootTableManager(super.state); C all() { - return getChildManager(state, this); + return state._getChildManagerBuilder(state); } - Future create(Insertable Function(CI o) f, - {InsertMode? mode, UpsertClause? onConflict}) { - return state.db - .into(state.table) - .insert(f(_createInsertable), mode: mode, onConflict: onConflict); - } + // Future create(Insertable Function(CI o) f, + // {InsertMode? mode, UpsertClause? onConflict}) { + // return state.db.into(state.table) + // .insert(f(_createInsertable), mode: mode, onConflict: onConflict); + // } - Future createReturning(Insertable Function(CI o) f, - {InsertMode? mode, UpsertClause? onConflict}) { - return state.db.into(state.table).insertReturning(f(_createInsertable), - mode: mode, onConflict: onConflict) as Future; - } + // Future createReturning(Insertable Function(CI o) f, + // {InsertMode? mode, UpsertClause? onConflict}) { + // return state.db.into(state.table).insertReturning(f(_createInsertable), + // mode: mode, onConflict: onConflict) as Future; + // } - Future bulkCreate(Iterable> Function(CI o) f, - {InsertMode? mode, UpsertClause? onConflict}) { - return state.db.batch((b) => b.insertAll(state.table, f(_createInsertable), - mode: mode, onConflict: onConflict)); - } + // Future bulkCreate(Iterable> Function(CI o) f, + // {InsertMode? mode, UpsertClause? onConflict}) { + // return state.db.batch((b) => b.insertAll(state.table, f(_createInsertable), + // mode: mode, onConflict: onConflict)); + // } - Future replace(Insertable entry) { - return state.db.update(state.table).replace(entry); - } + // Future replace(Insertable entry) { + // return state.db.update(state.table).replace(entry); + // } }