diff --git a/drift/test/generated/custom_tables.g.dart b/drift/test/generated/custom_tables.g.dart index a116dc90..f8bbe29f 100644 --- a/drift/test/generated/custom_tables.g.dart +++ b/drift/test/generated/custom_tables.g.dart @@ -1657,6 +1657,7 @@ class MyView extends ViewInfo implements HasResultSet { abstract class _$CustomTablesDb extends GeneratedDatabase { _$CustomTablesDb(QueryExecutor e) : super(e); + _$CustomTablesDbManager get managers => _$CustomTablesDbManager(this); late final NoIds noIds = NoIds(this); late final WithDefaults withDefaults = WithDefaults(this); late final WithConstraints withConstraints = WithConstraints(this); @@ -1970,6 +1971,522 @@ abstract class _$CustomTablesDb extends GeneratedDatabase { const DriftDatabaseOptions(storeDateTimeAsText: true); } +class $WithDefaultsFilterComposer + extends FilterComposer<_$CustomTablesDb, WithDefaults> { + $WithDefaultsFilterComposer(super.db, super.table); + ColumnFilters get a => ColumnFilters($table.a); + ColumnFilters get b => ColumnFilters($table.b); +} + +class $WithDefaultsOrderingComposer + extends OrderingComposer<_$CustomTablesDb, WithDefaults> { + $WithDefaultsOrderingComposer(super.db, super.table); + ColumnOrderings get a => ColumnOrderings($table.a); + ColumnOrderings get b => ColumnOrderings($table.b); +} + +class $WithDefaultsProcessedTableManager extends ProcessedTableManager< + _$CustomTablesDb, + WithDefaults, + WithDefault, + $WithDefaultsFilterComposer, + $WithDefaultsOrderingComposer, + $WithDefaultsProcessedTableManager, + $WithDefaultsInsertCompanionBuilder, + $WithDefaultsUpdateCompanionBuilder> { + const $WithDefaultsProcessedTableManager(super.$state); +} + +typedef $WithDefaultsInsertCompanionBuilder = WithDefaultsCompanion Function({ + Value a, + Value b, + Value rowid, +}); +typedef $WithDefaultsUpdateCompanionBuilder = WithDefaultsCompanion Function({ + Value a, + Value b, + Value rowid, +}); + +class $WithDefaultsTableManager extends RootTableManager< + _$CustomTablesDb, + WithDefaults, + WithDefault, + $WithDefaultsFilterComposer, + $WithDefaultsOrderingComposer, + $WithDefaultsProcessedTableManager, + $WithDefaultsInsertCompanionBuilder, + $WithDefaultsUpdateCompanionBuilder> { + $WithDefaultsTableManager(_$CustomTablesDb db, WithDefaults table) + : super(TableManagerState( + db: db, + table: table, + filteringComposer: $WithDefaultsFilterComposer(db, table), + orderingComposer: $WithDefaultsOrderingComposer(db, table), + getChildManagerBuilder: (p0) => + $WithDefaultsProcessedTableManager(p0), + getUpdateCompanionBuilder: ({ + Value a = const Value.absent(), + Value b = const Value.absent(), + Value rowid = const Value.absent(), + }) => + WithDefaultsCompanion( + a: a, + b: b, + rowid: rowid, + ), + getInsertCompanionBuilder: ({ + Value a = const Value.absent(), + Value b = const Value.absent(), + Value rowid = const Value.absent(), + }) => + WithDefaultsCompanion.insert( + a: a, + b: b, + rowid: rowid, + ))); +} + +class $WithConstraintsFilterComposer + extends FilterComposer<_$CustomTablesDb, WithConstraints> { + $WithConstraintsFilterComposer(super.db, super.table); + ColumnFilters get a => ColumnFilters($table.a); + ColumnFilters get b => ColumnFilters($table.b); + ColumnFilters get c => ColumnFilters($table.c); +} + +class $WithConstraintsOrderingComposer + extends OrderingComposer<_$CustomTablesDb, WithConstraints> { + $WithConstraintsOrderingComposer(super.db, super.table); + ColumnOrderings get a => ColumnOrderings($table.a); + ColumnOrderings get b => ColumnOrderings($table.b); + ColumnOrderings get c => ColumnOrderings($table.c); +} + +class $WithConstraintsProcessedTableManager extends ProcessedTableManager< + _$CustomTablesDb, + WithConstraints, + WithConstraint, + $WithConstraintsFilterComposer, + $WithConstraintsOrderingComposer, + $WithConstraintsProcessedTableManager, + $WithConstraintsInsertCompanionBuilder, + $WithConstraintsUpdateCompanionBuilder> { + const $WithConstraintsProcessedTableManager(super.$state); +} + +typedef $WithConstraintsInsertCompanionBuilder = WithConstraintsCompanion + Function({ + Value a, + required int b, + Value c, + Value rowid, +}); +typedef $WithConstraintsUpdateCompanionBuilder = WithConstraintsCompanion + Function({ + Value a, + Value b, + Value c, + Value rowid, +}); + +class $WithConstraintsTableManager extends RootTableManager< + _$CustomTablesDb, + WithConstraints, + WithConstraint, + $WithConstraintsFilterComposer, + $WithConstraintsOrderingComposer, + $WithConstraintsProcessedTableManager, + $WithConstraintsInsertCompanionBuilder, + $WithConstraintsUpdateCompanionBuilder> { + $WithConstraintsTableManager(_$CustomTablesDb db, WithConstraints table) + : super(TableManagerState( + db: db, + table: table, + filteringComposer: $WithConstraintsFilterComposer(db, table), + orderingComposer: $WithConstraintsOrderingComposer(db, table), + getChildManagerBuilder: (p0) => + $WithConstraintsProcessedTableManager(p0), + getUpdateCompanionBuilder: ({ + Value a = const Value.absent(), + Value b = const Value.absent(), + Value c = const Value.absent(), + Value rowid = const Value.absent(), + }) => + WithConstraintsCompanion( + a: a, + b: b, + c: c, + rowid: rowid, + ), + getInsertCompanionBuilder: ({ + Value a = const Value.absent(), + required int b, + Value c = const Value.absent(), + Value rowid = const Value.absent(), + }) => + WithConstraintsCompanion.insert( + a: a, + b: b, + c: c, + rowid: rowid, + ))); +} + +class $ConfigTableFilterComposer + extends FilterComposer<_$CustomTablesDb, ConfigTable> { + $ConfigTableFilterComposer(super.db, super.table); + ColumnFilters get configKey => ColumnFilters($table.configKey); + ColumnFilters get configValue => ColumnFilters($table.configValue); + ColumnFilters get syncStateValue => ColumnFilters($table.syncState); + ColumnWithTypeConverterFilters get syncState => + ColumnWithTypeConverterFilters($table.syncState); + ColumnFilters get syncStateImplicitValue => + ColumnFilters($table.syncStateImplicit); + ColumnWithTypeConverterFilters get syncStateImplicit => + ColumnWithTypeConverterFilters($table.syncStateImplicit); +} + +class $ConfigTableOrderingComposer + extends OrderingComposer<_$CustomTablesDb, ConfigTable> { + $ConfigTableOrderingComposer(super.db, super.table); + ColumnOrderings get configKey => ColumnOrderings($table.configKey); + ColumnOrderings get configValue => ColumnOrderings($table.configValue); + ColumnOrderings get syncState => ColumnOrderings($table.syncState); + ColumnOrderings get syncStateImplicit => + ColumnOrderings($table.syncStateImplicit); +} + +class $ConfigTableProcessedTableManager extends ProcessedTableManager< + _$CustomTablesDb, + ConfigTable, + Config, + $ConfigTableFilterComposer, + $ConfigTableOrderingComposer, + $ConfigTableProcessedTableManager, + $ConfigTableInsertCompanionBuilder, + $ConfigTableUpdateCompanionBuilder> { + const $ConfigTableProcessedTableManager(super.$state); +} + +typedef $ConfigTableInsertCompanionBuilder = ConfigCompanion Function({ + required String configKey, + Value configValue, + Value syncState, + Value syncStateImplicit, + Value rowid, +}); +typedef $ConfigTableUpdateCompanionBuilder = ConfigCompanion Function({ + Value configKey, + Value configValue, + Value syncState, + Value syncStateImplicit, + Value rowid, +}); + +class $ConfigTableTableManager extends RootTableManager< + _$CustomTablesDb, + ConfigTable, + Config, + $ConfigTableFilterComposer, + $ConfigTableOrderingComposer, + $ConfigTableProcessedTableManager, + $ConfigTableInsertCompanionBuilder, + $ConfigTableUpdateCompanionBuilder> { + $ConfigTableTableManager(_$CustomTablesDb db, ConfigTable table) + : super(TableManagerState( + db: db, + table: table, + filteringComposer: $ConfigTableFilterComposer(db, table), + orderingComposer: $ConfigTableOrderingComposer(db, table), + getChildManagerBuilder: (p0) => + $ConfigTableProcessedTableManager(p0), + getUpdateCompanionBuilder: ({ + Value configKey = const Value.absent(), + Value configValue = const Value.absent(), + Value syncState = const Value.absent(), + Value syncStateImplicit = const Value.absent(), + Value rowid = const Value.absent(), + }) => + ConfigCompanion( + configKey: configKey, + configValue: configValue, + syncState: syncState, + syncStateImplicit: syncStateImplicit, + rowid: rowid, + ), + getInsertCompanionBuilder: ({ + required String configKey, + Value configValue = const Value.absent(), + Value syncState = const Value.absent(), + Value syncStateImplicit = const Value.absent(), + Value rowid = const Value.absent(), + }) => + ConfigCompanion.insert( + configKey: configKey, + configValue: configValue, + syncState: syncState, + syncStateImplicit: syncStateImplicit, + rowid: rowid, + ))); +} + +class $MytableFilterComposer extends FilterComposer<_$CustomTablesDb, Mytable> { + $MytableFilterComposer(super.db, super.table); + ColumnFilters get someid => ColumnFilters($table.someid); + ColumnFilters get sometext => ColumnFilters($table.sometext); + ColumnFilters get isInserting => ColumnFilters($table.isInserting); + ColumnFilters get somedate => ColumnFilters($table.somedate); +} + +class $MytableOrderingComposer + extends OrderingComposer<_$CustomTablesDb, Mytable> { + $MytableOrderingComposer(super.db, super.table); + ColumnOrderings get someid => ColumnOrderings($table.someid); + ColumnOrderings get sometext => ColumnOrderings($table.sometext); + ColumnOrderings get isInserting => ColumnOrderings($table.isInserting); + ColumnOrderings get somedate => ColumnOrderings($table.somedate); +} + +class $MytableProcessedTableManager extends ProcessedTableManager< + _$CustomTablesDb, + Mytable, + MytableData, + $MytableFilterComposer, + $MytableOrderingComposer, + $MytableProcessedTableManager, + $MytableInsertCompanionBuilder, + $MytableUpdateCompanionBuilder> { + const $MytableProcessedTableManager(super.$state); +} + +typedef $MytableInsertCompanionBuilder = MytableCompanion Function({ + Value someid, + Value sometext, + Value isInserting, + Value somedate, +}); +typedef $MytableUpdateCompanionBuilder = MytableCompanion Function({ + Value someid, + Value sometext, + Value isInserting, + Value somedate, +}); + +class $MytableTableManager extends RootTableManager< + _$CustomTablesDb, + Mytable, + MytableData, + $MytableFilterComposer, + $MytableOrderingComposer, + $MytableProcessedTableManager, + $MytableInsertCompanionBuilder, + $MytableUpdateCompanionBuilder> { + $MytableTableManager(_$CustomTablesDb db, Mytable table) + : super(TableManagerState( + db: db, + table: table, + filteringComposer: $MytableFilterComposer(db, table), + orderingComposer: $MytableOrderingComposer(db, table), + getChildManagerBuilder: (p0) => $MytableProcessedTableManager(p0), + getUpdateCompanionBuilder: ({ + Value someid = const Value.absent(), + Value sometext = const Value.absent(), + Value isInserting = const Value.absent(), + Value somedate = const Value.absent(), + }) => + MytableCompanion( + someid: someid, + sometext: sometext, + isInserting: isInserting, + somedate: somedate, + ), + getInsertCompanionBuilder: ({ + Value someid = const Value.absent(), + Value sometext = const Value.absent(), + Value isInserting = const Value.absent(), + Value somedate = const Value.absent(), + }) => + MytableCompanion.insert( + someid: someid, + sometext: sometext, + isInserting: isInserting, + somedate: somedate, + ))); +} + +class $EmailFilterComposer extends FilterComposer<_$CustomTablesDb, Email> { + $EmailFilterComposer(super.db, super.table); + ColumnFilters get sender => ColumnFilters($table.sender); + ColumnFilters get title => ColumnFilters($table.title); + ColumnFilters get body => ColumnFilters($table.body); +} + +class $EmailOrderingComposer extends OrderingComposer<_$CustomTablesDb, Email> { + $EmailOrderingComposer(super.db, super.table); + ColumnOrderings get sender => ColumnOrderings($table.sender); + ColumnOrderings get title => ColumnOrderings($table.title); + ColumnOrderings get body => ColumnOrderings($table.body); +} + +class $EmailProcessedTableManager extends ProcessedTableManager< + _$CustomTablesDb, + Email, + EMail, + $EmailFilterComposer, + $EmailOrderingComposer, + $EmailProcessedTableManager, + $EmailInsertCompanionBuilder, + $EmailUpdateCompanionBuilder> { + const $EmailProcessedTableManager(super.$state); +} + +typedef $EmailInsertCompanionBuilder = EmailCompanion Function({ + required String sender, + required String title, + required String body, + Value rowid, +}); +typedef $EmailUpdateCompanionBuilder = EmailCompanion Function({ + Value sender, + Value title, + Value body, + Value rowid, +}); + +class $EmailTableManager extends RootTableManager< + _$CustomTablesDb, + Email, + EMail, + $EmailFilterComposer, + $EmailOrderingComposer, + $EmailProcessedTableManager, + $EmailInsertCompanionBuilder, + $EmailUpdateCompanionBuilder> { + $EmailTableManager(_$CustomTablesDb db, Email table) + : super(TableManagerState( + db: db, + table: table, + filteringComposer: $EmailFilterComposer(db, table), + orderingComposer: $EmailOrderingComposer(db, table), + getChildManagerBuilder: (p0) => $EmailProcessedTableManager(p0), + getUpdateCompanionBuilder: ({ + Value sender = const Value.absent(), + Value title = const Value.absent(), + Value body = const Value.absent(), + Value rowid = const Value.absent(), + }) => + EmailCompanion( + sender: sender, + title: title, + body: body, + rowid: rowid, + ), + getInsertCompanionBuilder: ({ + required String sender, + required String title, + required String body, + Value rowid = const Value.absent(), + }) => + EmailCompanion.insert( + sender: sender, + title: title, + body: body, + rowid: rowid, + ))); +} + +class $WeirdTableFilterComposer + extends FilterComposer<_$CustomTablesDb, WeirdTable> { + $WeirdTableFilterComposer(super.db, super.table); + ColumnFilters get sqlClass => ColumnFilters($table.sqlClass); + ColumnFilters get textColumn => ColumnFilters($table.textColumn); +} + +class $WeirdTableOrderingComposer + extends OrderingComposer<_$CustomTablesDb, WeirdTable> { + $WeirdTableOrderingComposer(super.db, super.table); + ColumnOrderings get sqlClass => ColumnOrderings($table.sqlClass); + ColumnOrderings get textColumn => ColumnOrderings($table.textColumn); +} + +class $WeirdTableProcessedTableManager extends ProcessedTableManager< + _$CustomTablesDb, + WeirdTable, + WeirdData, + $WeirdTableFilterComposer, + $WeirdTableOrderingComposer, + $WeirdTableProcessedTableManager, + $WeirdTableInsertCompanionBuilder, + $WeirdTableUpdateCompanionBuilder> { + const $WeirdTableProcessedTableManager(super.$state); +} + +typedef $WeirdTableInsertCompanionBuilder = WeirdTableCompanion Function({ + required int sqlClass, + required String textColumn, + Value rowid, +}); +typedef $WeirdTableUpdateCompanionBuilder = WeirdTableCompanion Function({ + Value sqlClass, + Value textColumn, + Value rowid, +}); + +class $WeirdTableTableManager extends RootTableManager< + _$CustomTablesDb, + WeirdTable, + WeirdData, + $WeirdTableFilterComposer, + $WeirdTableOrderingComposer, + $WeirdTableProcessedTableManager, + $WeirdTableInsertCompanionBuilder, + $WeirdTableUpdateCompanionBuilder> { + $WeirdTableTableManager(_$CustomTablesDb db, WeirdTable table) + : super(TableManagerState( + db: db, + table: table, + filteringComposer: $WeirdTableFilterComposer(db, table), + orderingComposer: $WeirdTableOrderingComposer(db, table), + getChildManagerBuilder: (p0) => + $WeirdTableProcessedTableManager(p0), + getUpdateCompanionBuilder: ({ + Value sqlClass = const Value.absent(), + Value textColumn = const Value.absent(), + Value rowid = const Value.absent(), + }) => + WeirdTableCompanion( + sqlClass: sqlClass, + textColumn: textColumn, + rowid: rowid, + ), + getInsertCompanionBuilder: ({ + required int sqlClass, + required String textColumn, + Value rowid = const Value.absent(), + }) => + WeirdTableCompanion.insert( + sqlClass: sqlClass, + textColumn: textColumn, + rowid: rowid, + ))); +} + +class _$CustomTablesDbManager { + final _$CustomTablesDb _db; + _$CustomTablesDbManager(this._db); + $WithDefaultsTableManager get withDefaults => + $WithDefaultsTableManager(_db, _db.withDefaults); + $WithConstraintsTableManager get withConstraints => + $WithConstraintsTableManager(_db, _db.withConstraints); + $ConfigTableTableManager get config => + $ConfigTableTableManager(_db, _db.config); + $MytableTableManager get mytable => $MytableTableManager(_db, _db.mytable); + $EmailTableManager get email => $EmailTableManager(_db, _db.email); + $WeirdTableTableManager get weirdTable => + $WeirdTableTableManager(_db, _db.weirdTable); +} + typedef ReadMultiple$clause = OrderBy Function(ConfigTable config); typedef ReadDynamic$predicate = Expression Function(ConfigTable config); typedef TypeConverterVar$pred = Expression Function(ConfigTable config); diff --git a/drift/test/generated/todos.g.dart b/drift/test/generated/todos.g.dart index 4685760b..2849a4c6 100644 --- a/drift/test/generated/todos.g.dart +++ b/drift/test/generated/todos.g.dart @@ -1864,6 +1864,7 @@ class $TodoWithCategoryViewView abstract class _$TodoDb extends GeneratedDatabase { _$TodoDb(QueryExecutor e) : super(e); + _$TodoDbManager get managers => _$TodoDbManager(this); late final $CategoriesTable categories = $CategoriesTable(this); late final $TodosTableTable todosTable = $TodosTableTable(this); late final $UsersTable users = $UsersTable(this); @@ -1962,6 +1963,570 @@ abstract class _$TodoDb extends GeneratedDatabase { ]; } +class $$CategoriesTableFilterComposer + extends FilterComposer<_$TodoDb, $CategoriesTable> { + $$CategoriesTableFilterComposer(super.db, super.table); + ColumnFilters get idValue => ColumnFilters($table.id); + ColumnWithTypeConverterFilters get id => + ColumnWithTypeConverterFilters($table.id); + ColumnFilters get description => ColumnFilters($table.description); + ColumnFilters get priorityValue => ColumnFilters($table.priority); + ColumnWithTypeConverterFilters get priority => + ColumnWithTypeConverterFilters($table.priority); + ColumnFilters get descriptionInUpperCase => + ColumnFilters($table.descriptionInUpperCase); + ComposableFilter todosTableRefs( + ComposableFilter Function($$TodosTableTableFilterComposer f) f) { + return $composeWithJoins( + $db: $db, + $table: $table, + referencedTable: $db.todosTable, + getCurrentColumn: (f) => f.id, + getReferencedColumn: (f) => f.category, + getReferencedComposer: (db, table) => + $$TodosTableTableFilterComposer(db, table), + builder: f); + } +} + +class $$CategoriesTableOrderingComposer + extends OrderingComposer<_$TodoDb, $CategoriesTable> { + $$CategoriesTableOrderingComposer(super.db, super.table); + ColumnOrderings get id => ColumnOrderings($table.id); + ColumnOrderings get description => ColumnOrderings($table.description); + ColumnOrderings get priority => ColumnOrderings($table.priority); + ColumnOrderings get descriptionInUpperCase => + ColumnOrderings($table.descriptionInUpperCase); +} + +class $$CategoriesTableProcessedTableManager extends ProcessedTableManager< + _$TodoDb, + $CategoriesTable, + Category, + $$CategoriesTableFilterComposer, + $$CategoriesTableOrderingComposer, + $$CategoriesTableProcessedTableManager, + $$CategoriesTableInsertCompanionBuilder, + $$CategoriesTableUpdateCompanionBuilder> { + const $$CategoriesTableProcessedTableManager(super.$state); +} + +typedef $$CategoriesTableInsertCompanionBuilder = CategoriesCompanion Function({ + Value id, + required String description, + Value priority, +}); +typedef $$CategoriesTableUpdateCompanionBuilder = CategoriesCompanion Function({ + Value id, + Value description, + Value priority, +}); + +class $$CategoriesTableTableManager extends RootTableManager< + _$TodoDb, + $CategoriesTable, + Category, + $$CategoriesTableFilterComposer, + $$CategoriesTableOrderingComposer, + $$CategoriesTableProcessedTableManager, + $$CategoriesTableInsertCompanionBuilder, + $$CategoriesTableUpdateCompanionBuilder> { + $$CategoriesTableTableManager(_$TodoDb db, $CategoriesTable table) + : super(TableManagerState( + db: db, + table: table, + filteringComposer: $$CategoriesTableFilterComposer(db, table), + orderingComposer: $$CategoriesTableOrderingComposer(db, table), + getChildManagerBuilder: (p0) => + $$CategoriesTableProcessedTableManager(p0), + getUpdateCompanionBuilder: ({ + Value id = const Value.absent(), + Value description = const Value.absent(), + Value priority = const Value.absent(), + }) => + CategoriesCompanion( + id: id, + description: description, + priority: priority, + ), + getInsertCompanionBuilder: ({ + Value id = const Value.absent(), + required String description, + Value priority = const Value.absent(), + }) => + CategoriesCompanion.insert( + id: id, + description: description, + priority: priority, + ))); +} + +class $$TodosTableTableFilterComposer + extends FilterComposer<_$TodoDb, $TodosTableTable> { + $$TodosTableTableFilterComposer(super.db, super.table); + ColumnFilters get idValue => ColumnFilters($table.id); + ColumnWithTypeConverterFilters get id => + ColumnWithTypeConverterFilters($table.id); + ColumnFilters get title => ColumnFilters($table.title); + ColumnFilters get content => ColumnFilters($table.content); + ColumnFilters get targetDate => ColumnFilters($table.targetDate); + ColumnFilters get categoryId => ColumnFilters($table.category); + ComposableFilter category( + ComposableFilter Function($$CategoriesTableFilterComposer f) f) { + return $composeWithJoins( + $db: $db, + $table: $table, + referencedTable: $db.categories, + getCurrentColumn: (f) => f.category, + getReferencedColumn: (f) => f.id, + getReferencedComposer: (db, table) => + $$CategoriesTableFilterComposer(db, table), + builder: f); + } + + ColumnFilters get statusValue => ColumnFilters($table.status); + ColumnWithTypeConverterFilters get status => + ColumnWithTypeConverterFilters($table.status); +} + +class $$TodosTableTableOrderingComposer + extends OrderingComposer<_$TodoDb, $TodosTableTable> { + $$TodosTableTableOrderingComposer(super.db, super.table); + ColumnOrderings get id => ColumnOrderings($table.id); + ColumnOrderings get title => ColumnOrderings($table.title); + ColumnOrderings get content => ColumnOrderings($table.content); + ColumnOrderings get targetDate => ColumnOrderings($table.targetDate); + ColumnOrderings get categoryId => ColumnOrderings($table.category); + ComposableOrdering category( + ComposableOrdering Function($$CategoriesTableOrderingComposer o) o) { + return $composeWithJoins( + $db: $db, + $table: $table, + referencedTable: $db.categories, + getCurrentColumn: (f) => f.category, + getReferencedColumn: (f) => f.id, + getReferencedComposer: (db, table) => + $$CategoriesTableOrderingComposer(db, table), + builder: o); + } + + ColumnOrderings get status => ColumnOrderings($table.status); +} + +class $$TodosTableTableProcessedTableManager extends ProcessedTableManager< + _$TodoDb, + $TodosTableTable, + TodoEntry, + $$TodosTableTableFilterComposer, + $$TodosTableTableOrderingComposer, + $$TodosTableTableProcessedTableManager, + $$TodosTableTableInsertCompanionBuilder, + $$TodosTableTableUpdateCompanionBuilder> { + const $$TodosTableTableProcessedTableManager(super.$state); +} + +typedef $$TodosTableTableInsertCompanionBuilder = TodosTableCompanion Function({ + Value id, + Value title, + required String content, + Value targetDate, + Value category, + Value status, +}); +typedef $$TodosTableTableUpdateCompanionBuilder = TodosTableCompanion Function({ + Value id, + Value title, + Value content, + Value targetDate, + Value category, + Value status, +}); + +class $$TodosTableTableTableManager extends RootTableManager< + _$TodoDb, + $TodosTableTable, + TodoEntry, + $$TodosTableTableFilterComposer, + $$TodosTableTableOrderingComposer, + $$TodosTableTableProcessedTableManager, + $$TodosTableTableInsertCompanionBuilder, + $$TodosTableTableUpdateCompanionBuilder> { + $$TodosTableTableTableManager(_$TodoDb db, $TodosTableTable table) + : super(TableManagerState( + db: db, + table: table, + filteringComposer: $$TodosTableTableFilterComposer(db, table), + orderingComposer: $$TodosTableTableOrderingComposer(db, table), + getChildManagerBuilder: (p0) => + $$TodosTableTableProcessedTableManager(p0), + getUpdateCompanionBuilder: ({ + Value id = const Value.absent(), + Value title = const Value.absent(), + Value content = const Value.absent(), + Value targetDate = const Value.absent(), + Value category = const Value.absent(), + Value status = const Value.absent(), + }) => + TodosTableCompanion( + id: id, + title: title, + content: content, + targetDate: targetDate, + category: category, + status: status, + ), + getInsertCompanionBuilder: ({ + Value id = const Value.absent(), + Value title = const Value.absent(), + required String content, + Value targetDate = const Value.absent(), + Value category = const Value.absent(), + Value status = const Value.absent(), + }) => + TodosTableCompanion.insert( + id: id, + title: title, + content: content, + targetDate: targetDate, + category: category, + status: status, + ))); +} + +class $$UsersTableFilterComposer extends FilterComposer<_$TodoDb, $UsersTable> { + $$UsersTableFilterComposer(super.db, super.table); + ColumnFilters get idValue => ColumnFilters($table.id); + ColumnWithTypeConverterFilters get id => + ColumnWithTypeConverterFilters($table.id); + ColumnFilters get name => ColumnFilters($table.name); + ColumnFilters get isAwesome => ColumnFilters($table.isAwesome); + ColumnFilters get profilePicture => + ColumnFilters($table.profilePicture); + ColumnFilters get creationTime => + ColumnFilters($table.creationTime); +} + +class $$UsersTableOrderingComposer + extends OrderingComposer<_$TodoDb, $UsersTable> { + $$UsersTableOrderingComposer(super.db, super.table); + ColumnOrderings get id => ColumnOrderings($table.id); + ColumnOrderings get name => ColumnOrderings($table.name); + ColumnOrderings get isAwesome => ColumnOrderings($table.isAwesome); + ColumnOrderings get profilePicture => ColumnOrderings($table.profilePicture); + ColumnOrderings get creationTime => ColumnOrderings($table.creationTime); +} + +class $$UsersTableProcessedTableManager extends ProcessedTableManager< + _$TodoDb, + $UsersTable, + User, + $$UsersTableFilterComposer, + $$UsersTableOrderingComposer, + $$UsersTableProcessedTableManager, + $$UsersTableInsertCompanionBuilder, + $$UsersTableUpdateCompanionBuilder> { + const $$UsersTableProcessedTableManager(super.$state); +} + +typedef $$UsersTableInsertCompanionBuilder = UsersCompanion Function({ + Value id, + required String name, + Value isAwesome, + required Uint8List profilePicture, + Value creationTime, +}); +typedef $$UsersTableUpdateCompanionBuilder = UsersCompanion Function({ + Value id, + Value name, + Value isAwesome, + Value profilePicture, + Value creationTime, +}); + +class $$UsersTableTableManager extends RootTableManager< + _$TodoDb, + $UsersTable, + User, + $$UsersTableFilterComposer, + $$UsersTableOrderingComposer, + $$UsersTableProcessedTableManager, + $$UsersTableInsertCompanionBuilder, + $$UsersTableUpdateCompanionBuilder> { + $$UsersTableTableManager(_$TodoDb db, $UsersTable table) + : super(TableManagerState( + db: db, + table: table, + filteringComposer: $$UsersTableFilterComposer(db, table), + orderingComposer: $$UsersTableOrderingComposer(db, table), + getChildManagerBuilder: (p0) => + $$UsersTableProcessedTableManager(p0), + getUpdateCompanionBuilder: ({ + Value id = const Value.absent(), + Value name = const Value.absent(), + Value isAwesome = const Value.absent(), + Value profilePicture = const Value.absent(), + Value creationTime = const Value.absent(), + }) => + UsersCompanion( + id: id, + name: name, + isAwesome: isAwesome, + profilePicture: profilePicture, + creationTime: creationTime, + ), + getInsertCompanionBuilder: ({ + Value id = const Value.absent(), + required String name, + Value isAwesome = const Value.absent(), + required Uint8List profilePicture, + Value creationTime = const Value.absent(), + }) => + UsersCompanion.insert( + id: id, + name: name, + isAwesome: isAwesome, + profilePicture: profilePicture, + creationTime: creationTime, + ))); +} + +class $$SharedTodosTableFilterComposer + extends FilterComposer<_$TodoDb, $SharedTodosTable> { + $$SharedTodosTableFilterComposer(super.db, super.table); + ColumnFilters get todo => ColumnFilters($table.todo); + ColumnFilters get user => ColumnFilters($table.user); +} + +class $$SharedTodosTableOrderingComposer + extends OrderingComposer<_$TodoDb, $SharedTodosTable> { + $$SharedTodosTableOrderingComposer(super.db, super.table); + ColumnOrderings get todo => ColumnOrderings($table.todo); + ColumnOrderings get user => ColumnOrderings($table.user); +} + +class $$SharedTodosTableProcessedTableManager extends ProcessedTableManager< + _$TodoDb, + $SharedTodosTable, + SharedTodo, + $$SharedTodosTableFilterComposer, + $$SharedTodosTableOrderingComposer, + $$SharedTodosTableProcessedTableManager, + $$SharedTodosTableInsertCompanionBuilder, + $$SharedTodosTableUpdateCompanionBuilder> { + const $$SharedTodosTableProcessedTableManager(super.$state); +} + +typedef $$SharedTodosTableInsertCompanionBuilder = SharedTodosCompanion + Function({ + required int todo, + required int user, + Value rowid, +}); +typedef $$SharedTodosTableUpdateCompanionBuilder = SharedTodosCompanion + Function({ + Value todo, + Value user, + Value rowid, +}); + +class $$SharedTodosTableTableManager extends RootTableManager< + _$TodoDb, + $SharedTodosTable, + SharedTodo, + $$SharedTodosTableFilterComposer, + $$SharedTodosTableOrderingComposer, + $$SharedTodosTableProcessedTableManager, + $$SharedTodosTableInsertCompanionBuilder, + $$SharedTodosTableUpdateCompanionBuilder> { + $$SharedTodosTableTableManager(_$TodoDb db, $SharedTodosTable table) + : super(TableManagerState( + db: db, + table: table, + filteringComposer: $$SharedTodosTableFilterComposer(db, table), + orderingComposer: $$SharedTodosTableOrderingComposer(db, table), + getChildManagerBuilder: (p0) => + $$SharedTodosTableProcessedTableManager(p0), + getUpdateCompanionBuilder: ({ + Value todo = const Value.absent(), + Value user = const Value.absent(), + Value rowid = const Value.absent(), + }) => + SharedTodosCompanion( + todo: todo, + user: user, + rowid: rowid, + ), + getInsertCompanionBuilder: ({ + required int todo, + required int user, + Value rowid = const Value.absent(), + }) => + SharedTodosCompanion.insert( + todo: todo, + user: user, + rowid: rowid, + ))); +} + +class $$PureDefaultsTableFilterComposer + extends FilterComposer<_$TodoDb, $PureDefaultsTable> { + $$PureDefaultsTableFilterComposer(super.db, super.table); + ColumnFilters get txtValue => ColumnFilters($table.txt); + ColumnWithTypeConverterFilters get txt => + ColumnWithTypeConverterFilters($table.txt); +} + +class $$PureDefaultsTableOrderingComposer + extends OrderingComposer<_$TodoDb, $PureDefaultsTable> { + $$PureDefaultsTableOrderingComposer(super.db, super.table); + ColumnOrderings get txt => ColumnOrderings($table.txt); +} + +class $$PureDefaultsTableProcessedTableManager extends ProcessedTableManager< + _$TodoDb, + $PureDefaultsTable, + PureDefault, + $$PureDefaultsTableFilterComposer, + $$PureDefaultsTableOrderingComposer, + $$PureDefaultsTableProcessedTableManager, + $$PureDefaultsTableInsertCompanionBuilder, + $$PureDefaultsTableUpdateCompanionBuilder> { + const $$PureDefaultsTableProcessedTableManager(super.$state); +} + +typedef $$PureDefaultsTableInsertCompanionBuilder = PureDefaultsCompanion + Function({ + Value txt, + Value rowid, +}); +typedef $$PureDefaultsTableUpdateCompanionBuilder = PureDefaultsCompanion + Function({ + Value txt, + Value rowid, +}); + +class $$PureDefaultsTableTableManager extends RootTableManager< + _$TodoDb, + $PureDefaultsTable, + PureDefault, + $$PureDefaultsTableFilterComposer, + $$PureDefaultsTableOrderingComposer, + $$PureDefaultsTableProcessedTableManager, + $$PureDefaultsTableInsertCompanionBuilder, + $$PureDefaultsTableUpdateCompanionBuilder> { + $$PureDefaultsTableTableManager(_$TodoDb db, $PureDefaultsTable table) + : super(TableManagerState( + db: db, + table: table, + filteringComposer: $$PureDefaultsTableFilterComposer(db, table), + orderingComposer: $$PureDefaultsTableOrderingComposer(db, table), + getChildManagerBuilder: (p0) => + $$PureDefaultsTableProcessedTableManager(p0), + getUpdateCompanionBuilder: ({ + Value txt = const Value.absent(), + Value rowid = const Value.absent(), + }) => + PureDefaultsCompanion( + txt: txt, + rowid: rowid, + ), + getInsertCompanionBuilder: ({ + Value txt = const Value.absent(), + Value rowid = const Value.absent(), + }) => + PureDefaultsCompanion.insert( + txt: txt, + rowid: rowid, + ))); +} + +class $$WithCustomTypeTableFilterComposer + extends FilterComposer<_$TodoDb, $WithCustomTypeTable> { + $$WithCustomTypeTableFilterComposer(super.db, super.table); + ColumnFilters get id => ColumnFilters($table.id); +} + +class $$WithCustomTypeTableOrderingComposer + extends OrderingComposer<_$TodoDb, $WithCustomTypeTable> { + $$WithCustomTypeTableOrderingComposer(super.db, super.table); + ColumnOrderings get id => ColumnOrderings($table.id); +} + +class $$WithCustomTypeTableProcessedTableManager extends ProcessedTableManager< + _$TodoDb, + $WithCustomTypeTable, + WithCustomTypeData, + $$WithCustomTypeTableFilterComposer, + $$WithCustomTypeTableOrderingComposer, + $$WithCustomTypeTableProcessedTableManager, + $$WithCustomTypeTableInsertCompanionBuilder, + $$WithCustomTypeTableUpdateCompanionBuilder> { + const $$WithCustomTypeTableProcessedTableManager(super.$state); +} + +typedef $$WithCustomTypeTableInsertCompanionBuilder = WithCustomTypeCompanion + Function({ + required UuidValue id, + Value rowid, +}); +typedef $$WithCustomTypeTableUpdateCompanionBuilder = WithCustomTypeCompanion + Function({ + Value id, + Value rowid, +}); + +class $$WithCustomTypeTableTableManager extends RootTableManager< + _$TodoDb, + $WithCustomTypeTable, + WithCustomTypeData, + $$WithCustomTypeTableFilterComposer, + $$WithCustomTypeTableOrderingComposer, + $$WithCustomTypeTableProcessedTableManager, + $$WithCustomTypeTableInsertCompanionBuilder, + $$WithCustomTypeTableUpdateCompanionBuilder> { + $$WithCustomTypeTableTableManager(_$TodoDb db, $WithCustomTypeTable table) + : super(TableManagerState( + db: db, + table: table, + filteringComposer: $$WithCustomTypeTableFilterComposer(db, table), + orderingComposer: $$WithCustomTypeTableOrderingComposer(db, table), + getChildManagerBuilder: (p0) => + $$WithCustomTypeTableProcessedTableManager(p0), + getUpdateCompanionBuilder: ({ + Value id = const Value.absent(), + Value rowid = const Value.absent(), + }) => + WithCustomTypeCompanion( + id: id, + rowid: rowid, + ), + getInsertCompanionBuilder: ({ + required UuidValue id, + Value rowid = const Value.absent(), + }) => + WithCustomTypeCompanion.insert( + id: id, + rowid: rowid, + ))); +} + +class _$TodoDbManager { + final _$TodoDb _db; + _$TodoDbManager(this._db); + $$CategoriesTableTableManager get categories => + $$CategoriesTableTableManager(_db, _db.categories); + $$TodosTableTableTableManager get todosTable => + $$TodosTableTableTableManager(_db, _db.todosTable); + $$UsersTableTableManager get users => + $$UsersTableTableManager(_db, _db.users); + $$SharedTodosTableTableManager get sharedTodos => + $$SharedTodosTableTableManager(_db, _db.sharedTodos); + $$PureDefaultsTableTableManager get pureDefaults => + $$PureDefaultsTableTableManager(_db, _db.pureDefaults); + $$WithCustomTypeTableTableManager get withCustomType => + $$WithCustomTypeTableTableManager(_db, _db.withCustomType); +} + class AllTodosWithCategoryResult extends CustomResultSet { final RowId id; final String? title; diff --git a/drift/test/integration_tests/regress_2166_test.g.dart b/drift/test/integration_tests/regress_2166_test.g.dart index 6f16c66d..516af6da 100644 --- a/drift/test/integration_tests/regress_2166_test.g.dart +++ b/drift/test/integration_tests/regress_2166_test.g.dart @@ -184,6 +184,7 @@ class _SomeTableCompanion extends UpdateCompanion<_SomeTableData> { abstract class _$_SomeDb extends GeneratedDatabase { _$_SomeDb(QueryExecutor e) : super(e); + _$_SomeDbManager get managers => _$_SomeDbManager(this); late final $_SomeTableTable someTable = $_SomeTableTable(this); @override Iterable> get allTables => @@ -191,3 +192,80 @@ abstract class _$_SomeDb extends GeneratedDatabase { @override List get allSchemaEntities => [someTable]; } + +class $$_SomeTableTableFilterComposer + extends FilterComposer<_$_SomeDb, $_SomeTableTable> { + $$_SomeTableTableFilterComposer(super.db, super.table); + ColumnFilters get id => ColumnFilters($table.id); + ColumnFilters get name => ColumnFilters($table.name); +} + +class $$_SomeTableTableOrderingComposer + extends OrderingComposer<_$_SomeDb, $_SomeTableTable> { + $$_SomeTableTableOrderingComposer(super.db, super.table); + ColumnOrderings get id => ColumnOrderings($table.id); + ColumnOrderings get name => ColumnOrderings($table.name); +} + +class $$_SomeTableTableProcessedTableManager extends ProcessedTableManager< + _$_SomeDb, + $_SomeTableTable, + _SomeTableData, + $$_SomeTableTableFilterComposer, + $$_SomeTableTableOrderingComposer, + $$_SomeTableTableProcessedTableManager, + $$_SomeTableTableInsertCompanionBuilder, + $$_SomeTableTableUpdateCompanionBuilder> { + const $$_SomeTableTableProcessedTableManager(super.$state); +} + +typedef $$_SomeTableTableInsertCompanionBuilder = _SomeTableCompanion Function({ + Value id, + Value name, +}); +typedef $$_SomeTableTableUpdateCompanionBuilder = _SomeTableCompanion Function({ + Value id, + Value name, +}); + +class $$_SomeTableTableTableManager extends RootTableManager< + _$_SomeDb, + $_SomeTableTable, + _SomeTableData, + $$_SomeTableTableFilterComposer, + $$_SomeTableTableOrderingComposer, + $$_SomeTableTableProcessedTableManager, + $$_SomeTableTableInsertCompanionBuilder, + $$_SomeTableTableUpdateCompanionBuilder> { + $$_SomeTableTableTableManager(_$_SomeDb db, $_SomeTableTable table) + : super(TableManagerState( + db: db, + table: table, + filteringComposer: $$_SomeTableTableFilterComposer(db, table), + orderingComposer: $$_SomeTableTableOrderingComposer(db, table), + getChildManagerBuilder: (p0) => + $$_SomeTableTableProcessedTableManager(p0), + getUpdateCompanionBuilder: ({ + Value id = const Value.absent(), + Value name = const Value.absent(), + }) => + _SomeTableCompanion( + id: id, + name: name, + ), + getInsertCompanionBuilder: ({ + Value id = const Value.absent(), + Value name = const Value.absent(), + }) => + _SomeTableCompanion.insert( + id: id, + name: name, + ))); +} + +class _$_SomeDbManager { + final _$_SomeDb _db; + _$_SomeDbManager(this._db); + $$_SomeTableTableTableManager get someTable => + $$_SomeTableTableTableManager(_db, _db.someTable); +} diff --git a/drift/test/test_utils/test_utils.mocks.dart b/drift/test/test_utils/test_utils.mocks.dart index 03d207d3..0d052c05 100644 --- a/drift/test/test_utils/test_utils.mocks.dart +++ b/drift/test/test_utils/test_utils.mocks.dart @@ -1,4 +1,4 @@ -// Mocks generated by Mockito 5.4.3 from annotations +// Mocks generated by Mockito 5.4.4 from annotations // in drift/test/test_utils/test_utils.dart. // Do not manually edit this file. diff --git a/drift_dev/lib/src/writer/manager_writer.dart b/drift_dev/lib/src/writer/manager_writer.dart index fb689fb4..0eae5d0c 100644 --- a/drift_dev/lib/src/writer/manager_writer.dart +++ b/drift_dev/lib/src/writer/manager_writer.dart @@ -1,6 +1,7 @@ // ignore_for_file: public_member_api_docs, sort_constructors_first import 'package:drift_dev/src/analysis/results/results.dart'; import 'package:drift_dev/src/writer/modules.dart'; +import 'package:drift_dev/src/writer/tables/update_companion_writer.dart'; import 'package:drift_dev/src/writer/writer.dart'; abstract class _FilterWriter { @@ -330,6 +331,7 @@ class _TableWriter { /// Use [isUpdate] to determine if the builder is for an update or insert companion (String, String) _companionBuilder(String typedefName, {required bool isUpdate}) { + ; final companionClassName = scope.dartCode(scope.companionType(table)); final companionBuilderTypeDef = @@ -344,7 +346,7 @@ class _TableWriter { companionBuilderBody = StringBuffer('=> $companionClassName.insert('); } - for (final column in table.columns) { + for (final column in UpdateCompanionWriter(table, scope).columns) { final value = scope.drift('Value'); final param = column.nameInDart; final typeName = scope.dartCode(scope.dartType(column)); @@ -595,6 +597,9 @@ class ManagerWriter { void write() { final leaf = _scope.leaf(); + // Remove tables that use custom row classes + _addedTables.removeWhere((t) => t.existingRowClass != null); + // Write the manager class for each table final tableWriters = <_TableWriter>[]; for (var table in _addedTables) { diff --git a/drift_dev/lib/src/writer/tables/table_writer.dart b/drift_dev/lib/src/writer/tables/table_writer.dart index 2ea4b6c4..a1a213fb 100644 --- a/drift_dev/lib/src/writer/tables/table_writer.dart +++ b/drift_dev/lib/src/writer/tables/table_writer.dart @@ -45,7 +45,6 @@ abstract class TableOrViewWriter { final typeName = emitter.dartCode(emitter.writer.converterType(converter)); final code = emitter.dartCode(converter.expression); - buffer.write('static $typeName ${converter.fieldName} = $code;'); // Generate wrappers for non-nullable type converters that are applied to