1456 lines
44 KiB
Dart
1456 lines
44 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'database.dart';
|
|
|
|
// ignore_for_file: type=lint
|
|
class $UserTable extends User with TableInfo<$UserTable, UserData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$UserTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<String> id = GeneratedColumn<String>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _nameMeta = const VerificationMeta('name');
|
|
@override
|
|
late final GeneratedColumn<String> name = GeneratedColumn<String>(
|
|
'name',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, name];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'user';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<UserData> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_idMeta);
|
|
}
|
|
if (data.containsKey('name')) {
|
|
context.handle(
|
|
_nameMeta,
|
|
name.isAcceptableOrUnknown(data['name']!, _nameMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_nameMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
UserData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return UserData(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
name: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}name'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$UserTable createAlias(String alias) {
|
|
return $UserTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class UserData extends DataClass implements Insertable<UserData> {
|
|
final String id;
|
|
final String name;
|
|
const UserData({required this.id, required this.name});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<String>(id);
|
|
map['name'] = Variable<String>(name);
|
|
return map;
|
|
}
|
|
|
|
UserCompanion toCompanion(bool nullToAbsent) {
|
|
return UserCompanion(id: Value(id), name: Value(name));
|
|
}
|
|
|
|
factory UserData.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return UserData(
|
|
id: serializer.fromJson<String>(json['id']),
|
|
name: serializer.fromJson<String>(json['name']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<String>(id),
|
|
'name': serializer.toJson<String>(name),
|
|
};
|
|
}
|
|
|
|
UserData copyWith({String? id, String? name}) =>
|
|
UserData(id: id ?? this.id, name: name ?? this.name);
|
|
UserData copyWithCompanion(UserCompanion data) {
|
|
return UserData(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
name: data.name.present ? data.name.value : this.name,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('UserData(')
|
|
..write('id: $id, ')
|
|
..write('name: $name')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, name);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is UserData && other.id == this.id && other.name == this.name);
|
|
}
|
|
|
|
class UserCompanion extends UpdateCompanion<UserData> {
|
|
final Value<String> id;
|
|
final Value<String> name;
|
|
final Value<int> rowid;
|
|
const UserCompanion({
|
|
this.id = const Value.absent(),
|
|
this.name = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
UserCompanion.insert({
|
|
required String id,
|
|
required String name,
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id),
|
|
name = Value(name);
|
|
static Insertable<UserData> custom({
|
|
Expression<String>? id,
|
|
Expression<String>? name,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (name != null) 'name': name,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
UserCompanion copyWith({
|
|
Value<String>? id,
|
|
Value<String>? name,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return UserCompanion(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<String>(id.value);
|
|
}
|
|
if (name.present) {
|
|
map['name'] = Variable<String>(name.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('UserCompanion(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $GroupTable extends Group with TableInfo<$GroupTable, GroupData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$GroupTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<String> id = GeneratedColumn<String>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _nameMeta = const VerificationMeta('name');
|
|
@override
|
|
late final GeneratedColumn<String> name = GeneratedColumn<String>(
|
|
'name',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, name];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'group';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<GroupData> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_idMeta);
|
|
}
|
|
if (data.containsKey('name')) {
|
|
context.handle(
|
|
_nameMeta,
|
|
name.isAcceptableOrUnknown(data['name']!, _nameMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_nameMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
GroupData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return GroupData(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
name: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}name'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$GroupTable createAlias(String alias) {
|
|
return $GroupTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class GroupData extends DataClass implements Insertable<GroupData> {
|
|
final String id;
|
|
final String name;
|
|
const GroupData({required this.id, required this.name});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<String>(id);
|
|
map['name'] = Variable<String>(name);
|
|
return map;
|
|
}
|
|
|
|
GroupCompanion toCompanion(bool nullToAbsent) {
|
|
return GroupCompanion(id: Value(id), name: Value(name));
|
|
}
|
|
|
|
factory GroupData.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return GroupData(
|
|
id: serializer.fromJson<String>(json['id']),
|
|
name: serializer.fromJson<String>(json['name']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<String>(id),
|
|
'name': serializer.toJson<String>(name),
|
|
};
|
|
}
|
|
|
|
GroupData copyWith({String? id, String? name}) =>
|
|
GroupData(id: id ?? this.id, name: name ?? this.name);
|
|
GroupData copyWithCompanion(GroupCompanion data) {
|
|
return GroupData(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
name: data.name.present ? data.name.value : this.name,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('GroupData(')
|
|
..write('id: $id, ')
|
|
..write('name: $name')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, name);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is GroupData && other.id == this.id && other.name == this.name);
|
|
}
|
|
|
|
class GroupCompanion extends UpdateCompanion<GroupData> {
|
|
final Value<String> id;
|
|
final Value<String> name;
|
|
final Value<int> rowid;
|
|
const GroupCompanion({
|
|
this.id = const Value.absent(),
|
|
this.name = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
GroupCompanion.insert({
|
|
required String id,
|
|
required String name,
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id),
|
|
name = Value(name);
|
|
static Insertable<GroupData> custom({
|
|
Expression<String>? id,
|
|
Expression<String>? name,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (name != null) 'name': name,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
GroupCompanion copyWith({
|
|
Value<String>? id,
|
|
Value<String>? name,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return GroupCompanion(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<String>(id.value);
|
|
}
|
|
if (name.present) {
|
|
map['name'] = Variable<String>(name.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('GroupCompanion(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $UserGroupTable extends UserGroup
|
|
with TableInfo<$UserGroupTable, UserGroupData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$UserGroupTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _userIdMeta = const VerificationMeta('userId');
|
|
@override
|
|
late final GeneratedColumn<String> userId = GeneratedColumn<String>(
|
|
'user_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES user (id)',
|
|
),
|
|
);
|
|
static const VerificationMeta _groupIdMeta = const VerificationMeta(
|
|
'groupId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> groupId = GeneratedColumn<String>(
|
|
'group_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES "group" (id)',
|
|
),
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [userId, groupId];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'user_group';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<UserGroupData> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('user_id')) {
|
|
context.handle(
|
|
_userIdMeta,
|
|
userId.isAcceptableOrUnknown(data['user_id']!, _userIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_userIdMeta);
|
|
}
|
|
if (data.containsKey('group_id')) {
|
|
context.handle(
|
|
_groupIdMeta,
|
|
groupId.isAcceptableOrUnknown(data['group_id']!, _groupIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_groupIdMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {userId, groupId};
|
|
@override
|
|
UserGroupData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return UserGroupData(
|
|
userId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}user_id'],
|
|
)!,
|
|
groupId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}group_id'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$UserGroupTable createAlias(String alias) {
|
|
return $UserGroupTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class UserGroupData extends DataClass implements Insertable<UserGroupData> {
|
|
final String userId;
|
|
final String groupId;
|
|
const UserGroupData({required this.userId, required this.groupId});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['user_id'] = Variable<String>(userId);
|
|
map['group_id'] = Variable<String>(groupId);
|
|
return map;
|
|
}
|
|
|
|
UserGroupCompanion toCompanion(bool nullToAbsent) {
|
|
return UserGroupCompanion(userId: Value(userId), groupId: Value(groupId));
|
|
}
|
|
|
|
factory UserGroupData.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return UserGroupData(
|
|
userId: serializer.fromJson<String>(json['userId']),
|
|
groupId: serializer.fromJson<String>(json['groupId']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'userId': serializer.toJson<String>(userId),
|
|
'groupId': serializer.toJson<String>(groupId),
|
|
};
|
|
}
|
|
|
|
UserGroupData copyWith({String? userId, String? groupId}) => UserGroupData(
|
|
userId: userId ?? this.userId,
|
|
groupId: groupId ?? this.groupId,
|
|
);
|
|
UserGroupData copyWithCompanion(UserGroupCompanion data) {
|
|
return UserGroupData(
|
|
userId: data.userId.present ? data.userId.value : this.userId,
|
|
groupId: data.groupId.present ? data.groupId.value : this.groupId,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('UserGroupData(')
|
|
..write('userId: $userId, ')
|
|
..write('groupId: $groupId')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(userId, groupId);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is UserGroupData &&
|
|
other.userId == this.userId &&
|
|
other.groupId == this.groupId);
|
|
}
|
|
|
|
class UserGroupCompanion extends UpdateCompanion<UserGroupData> {
|
|
final Value<String> userId;
|
|
final Value<String> groupId;
|
|
final Value<int> rowid;
|
|
const UserGroupCompanion({
|
|
this.userId = const Value.absent(),
|
|
this.groupId = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
UserGroupCompanion.insert({
|
|
required String userId,
|
|
required String groupId,
|
|
this.rowid = const Value.absent(),
|
|
}) : userId = Value(userId),
|
|
groupId = Value(groupId);
|
|
static Insertable<UserGroupData> custom({
|
|
Expression<String>? userId,
|
|
Expression<String>? groupId,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (userId != null) 'user_id': userId,
|
|
if (groupId != null) 'group_id': groupId,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
UserGroupCompanion copyWith({
|
|
Value<String>? userId,
|
|
Value<String>? groupId,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return UserGroupCompanion(
|
|
userId: userId ?? this.userId,
|
|
groupId: groupId ?? this.groupId,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (userId.present) {
|
|
map['user_id'] = Variable<String>(userId.value);
|
|
}
|
|
if (groupId.present) {
|
|
map['group_id'] = Variable<String>(groupId.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('UserGroupCompanion(')
|
|
..write('userId: $userId, ')
|
|
..write('groupId: $groupId, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
abstract class _$AppDatabase extends GeneratedDatabase {
|
|
_$AppDatabase(QueryExecutor e) : super(e);
|
|
$AppDatabaseManager get managers => $AppDatabaseManager(this);
|
|
late final $UserTable user = $UserTable(this);
|
|
late final $GroupTable group = $GroupTable(this);
|
|
late final $UserGroupTable userGroup = $UserGroupTable(this);
|
|
@override
|
|
Iterable<TableInfo<Table, Object?>> get allTables =>
|
|
allSchemaEntities.whereType<TableInfo<Table, Object?>>();
|
|
@override
|
|
List<DatabaseSchemaEntity> get allSchemaEntities => [user, group, userGroup];
|
|
}
|
|
|
|
typedef $$UserTableCreateCompanionBuilder =
|
|
UserCompanion Function({
|
|
required String id,
|
|
required String name,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$UserTableUpdateCompanionBuilder =
|
|
UserCompanion Function({
|
|
Value<String> id,
|
|
Value<String> name,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$UserTableReferences
|
|
extends BaseReferences<_$AppDatabase, $UserTable, UserData> {
|
|
$$UserTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$UserGroupTable, List<UserGroupData>>
|
|
_userGroupRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.userGroup,
|
|
aliasName: $_aliasNameGenerator(db.user.id, db.userGroup.userId),
|
|
);
|
|
|
|
$$UserGroupTableProcessedTableManager get userGroupRefs {
|
|
final manager = $$UserGroupTableTableManager(
|
|
$_db,
|
|
$_db.userGroup,
|
|
).filter((f) => f.userId.id.sqlEquals($_itemColumn<String>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(_userGroupRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$UserTableFilterComposer extends Composer<_$AppDatabase, $UserTable> {
|
|
$$UserTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get name => $composableBuilder(
|
|
column: $table.name,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
Expression<bool> userGroupRefs(
|
|
Expression<bool> Function($$UserGroupTableFilterComposer f) f,
|
|
) {
|
|
final $$UserGroupTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.userGroup,
|
|
getReferencedColumn: (t) => t.userId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$UserGroupTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.userGroup,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$UserTableOrderingComposer extends Composer<_$AppDatabase, $UserTable> {
|
|
$$UserTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get name => $composableBuilder(
|
|
column: $table.name,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$UserTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $UserTable> {
|
|
$$UserTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get name =>
|
|
$composableBuilder(column: $table.name, builder: (column) => column);
|
|
|
|
Expression<T> userGroupRefs<T extends Object>(
|
|
Expression<T> Function($$UserGroupTableAnnotationComposer a) f,
|
|
) {
|
|
final $$UserGroupTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.userGroup,
|
|
getReferencedColumn: (t) => t.userId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$UserGroupTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.userGroup,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$UserTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$UserTable,
|
|
UserData,
|
|
$$UserTableFilterComposer,
|
|
$$UserTableOrderingComposer,
|
|
$$UserTableAnnotationComposer,
|
|
$$UserTableCreateCompanionBuilder,
|
|
$$UserTableUpdateCompanionBuilder,
|
|
(UserData, $$UserTableReferences),
|
|
UserData,
|
|
PrefetchHooks Function({bool userGroupRefs})
|
|
> {
|
|
$$UserTableTableManager(_$AppDatabase db, $UserTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$UserTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$UserTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$UserTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> id = const Value.absent(),
|
|
Value<String> name = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => UserCompanion(id: id, name: name, rowid: rowid),
|
|
createCompanionCallback:
|
|
({
|
|
required String id,
|
|
required String name,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => UserCompanion.insert(id: id, name: name, rowid: rowid),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) =>
|
|
(e.readTable(table), $$UserTableReferences(db, table, e)),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({userGroupRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [if (userGroupRefs) db.userGroup],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (userGroupRefs)
|
|
await $_getPrefetchedData<
|
|
UserData,
|
|
$UserTable,
|
|
UserGroupData
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$UserTableReferences
|
|
._userGroupRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$UserTableReferences(db, table, p0).userGroupRefs,
|
|
referencedItemsForCurrentItem: (item, referencedItems) =>
|
|
referencedItems.where((e) => e.userId == item.id),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$UserTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$UserTable,
|
|
UserData,
|
|
$$UserTableFilterComposer,
|
|
$$UserTableOrderingComposer,
|
|
$$UserTableAnnotationComposer,
|
|
$$UserTableCreateCompanionBuilder,
|
|
$$UserTableUpdateCompanionBuilder,
|
|
(UserData, $$UserTableReferences),
|
|
UserData,
|
|
PrefetchHooks Function({bool userGroupRefs})
|
|
>;
|
|
typedef $$GroupTableCreateCompanionBuilder =
|
|
GroupCompanion Function({
|
|
required String id,
|
|
required String name,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$GroupTableUpdateCompanionBuilder =
|
|
GroupCompanion Function({
|
|
Value<String> id,
|
|
Value<String> name,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$GroupTableReferences
|
|
extends BaseReferences<_$AppDatabase, $GroupTable, GroupData> {
|
|
$$GroupTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$UserGroupTable, List<UserGroupData>>
|
|
_userGroupRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.userGroup,
|
|
aliasName: $_aliasNameGenerator(db.group.id, db.userGroup.groupId),
|
|
);
|
|
|
|
$$UserGroupTableProcessedTableManager get userGroupRefs {
|
|
final manager = $$UserGroupTableTableManager(
|
|
$_db,
|
|
$_db.userGroup,
|
|
).filter((f) => f.groupId.id.sqlEquals($_itemColumn<String>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(_userGroupRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$GroupTableFilterComposer extends Composer<_$AppDatabase, $GroupTable> {
|
|
$$GroupTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get name => $composableBuilder(
|
|
column: $table.name,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
Expression<bool> userGroupRefs(
|
|
Expression<bool> Function($$UserGroupTableFilterComposer f) f,
|
|
) {
|
|
final $$UserGroupTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.userGroup,
|
|
getReferencedColumn: (t) => t.groupId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$UserGroupTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.userGroup,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$GroupTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $GroupTable> {
|
|
$$GroupTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get name => $composableBuilder(
|
|
column: $table.name,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$GroupTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $GroupTable> {
|
|
$$GroupTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get name =>
|
|
$composableBuilder(column: $table.name, builder: (column) => column);
|
|
|
|
Expression<T> userGroupRefs<T extends Object>(
|
|
Expression<T> Function($$UserGroupTableAnnotationComposer a) f,
|
|
) {
|
|
final $$UserGroupTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.userGroup,
|
|
getReferencedColumn: (t) => t.groupId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$UserGroupTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.userGroup,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$GroupTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$GroupTable,
|
|
GroupData,
|
|
$$GroupTableFilterComposer,
|
|
$$GroupTableOrderingComposer,
|
|
$$GroupTableAnnotationComposer,
|
|
$$GroupTableCreateCompanionBuilder,
|
|
$$GroupTableUpdateCompanionBuilder,
|
|
(GroupData, $$GroupTableReferences),
|
|
GroupData,
|
|
PrefetchHooks Function({bool userGroupRefs})
|
|
> {
|
|
$$GroupTableTableManager(_$AppDatabase db, $GroupTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$GroupTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$GroupTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$GroupTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> id = const Value.absent(),
|
|
Value<String> name = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => GroupCompanion(id: id, name: name, rowid: rowid),
|
|
createCompanionCallback:
|
|
({
|
|
required String id,
|
|
required String name,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => GroupCompanion.insert(id: id, name: name, rowid: rowid),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) =>
|
|
(e.readTable(table), $$GroupTableReferences(db, table, e)),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({userGroupRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [if (userGroupRefs) db.userGroup],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (userGroupRefs)
|
|
await $_getPrefetchedData<
|
|
GroupData,
|
|
$GroupTable,
|
|
UserGroupData
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$GroupTableReferences
|
|
._userGroupRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$GroupTableReferences(db, table, p0).userGroupRefs,
|
|
referencedItemsForCurrentItem: (item, referencedItems) =>
|
|
referencedItems.where((e) => e.groupId == item.id),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$GroupTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$GroupTable,
|
|
GroupData,
|
|
$$GroupTableFilterComposer,
|
|
$$GroupTableOrderingComposer,
|
|
$$GroupTableAnnotationComposer,
|
|
$$GroupTableCreateCompanionBuilder,
|
|
$$GroupTableUpdateCompanionBuilder,
|
|
(GroupData, $$GroupTableReferences),
|
|
GroupData,
|
|
PrefetchHooks Function({bool userGroupRefs})
|
|
>;
|
|
typedef $$UserGroupTableCreateCompanionBuilder =
|
|
UserGroupCompanion Function({
|
|
required String userId,
|
|
required String groupId,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$UserGroupTableUpdateCompanionBuilder =
|
|
UserGroupCompanion Function({
|
|
Value<String> userId,
|
|
Value<String> groupId,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$UserGroupTableReferences
|
|
extends BaseReferences<_$AppDatabase, $UserGroupTable, UserGroupData> {
|
|
$$UserGroupTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static $UserTable _userIdTable(_$AppDatabase db) => db.user.createAlias(
|
|
$_aliasNameGenerator(db.userGroup.userId, db.user.id),
|
|
);
|
|
|
|
$$UserTableProcessedTableManager get userId {
|
|
final $_column = $_itemColumn<String>('user_id')!;
|
|
|
|
final manager = $$UserTableTableManager(
|
|
$_db,
|
|
$_db.user,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_userIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
|
|
static $GroupTable _groupIdTable(_$AppDatabase db) => db.group.createAlias(
|
|
$_aliasNameGenerator(db.userGroup.groupId, db.group.id),
|
|
);
|
|
|
|
$$GroupTableProcessedTableManager get groupId {
|
|
final $_column = $_itemColumn<String>('group_id')!;
|
|
|
|
final manager = $$GroupTableTableManager(
|
|
$_db,
|
|
$_db.group,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_groupIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$UserGroupTableFilterComposer
|
|
extends Composer<_$AppDatabase, $UserGroupTable> {
|
|
$$UserGroupTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
$$UserTableFilterComposer get userId {
|
|
final $$UserTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.userId,
|
|
referencedTable: $db.user,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$UserTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.user,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$GroupTableFilterComposer get groupId {
|
|
final $$GroupTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.groupId,
|
|
referencedTable: $db.group,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$GroupTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.group,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$UserGroupTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $UserGroupTable> {
|
|
$$UserGroupTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
$$UserTableOrderingComposer get userId {
|
|
final $$UserTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.userId,
|
|
referencedTable: $db.user,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$UserTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.user,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$GroupTableOrderingComposer get groupId {
|
|
final $$GroupTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.groupId,
|
|
referencedTable: $db.group,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$GroupTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.group,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$UserGroupTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $UserGroupTable> {
|
|
$$UserGroupTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
$$UserTableAnnotationComposer get userId {
|
|
final $$UserTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.userId,
|
|
referencedTable: $db.user,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$UserTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.user,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$GroupTableAnnotationComposer get groupId {
|
|
final $$GroupTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.groupId,
|
|
referencedTable: $db.group,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$GroupTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.group,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$UserGroupTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$UserGroupTable,
|
|
UserGroupData,
|
|
$$UserGroupTableFilterComposer,
|
|
$$UserGroupTableOrderingComposer,
|
|
$$UserGroupTableAnnotationComposer,
|
|
$$UserGroupTableCreateCompanionBuilder,
|
|
$$UserGroupTableUpdateCompanionBuilder,
|
|
(UserGroupData, $$UserGroupTableReferences),
|
|
UserGroupData,
|
|
PrefetchHooks Function({bool userId, bool groupId})
|
|
> {
|
|
$$UserGroupTableTableManager(_$AppDatabase db, $UserGroupTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$UserGroupTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$UserGroupTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$UserGroupTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> userId = const Value.absent(),
|
|
Value<String> groupId = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => UserGroupCompanion(
|
|
userId: userId,
|
|
groupId: groupId,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String userId,
|
|
required String groupId,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => UserGroupCompanion.insert(
|
|
userId: userId,
|
|
groupId: groupId,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$UserGroupTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({userId = false, groupId = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [],
|
|
addJoins:
|
|
<
|
|
T extends TableManagerState<
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic
|
|
>
|
|
>(state) {
|
|
if (userId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.userId,
|
|
referencedTable: $$UserGroupTableReferences
|
|
._userIdTable(db),
|
|
referencedColumn: $$UserGroupTableReferences
|
|
._userIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
if (groupId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.groupId,
|
|
referencedTable: $$UserGroupTableReferences
|
|
._groupIdTable(db),
|
|
referencedColumn: $$UserGroupTableReferences
|
|
._groupIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$UserGroupTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$UserGroupTable,
|
|
UserGroupData,
|
|
$$UserGroupTableFilterComposer,
|
|
$$UserGroupTableOrderingComposer,
|
|
$$UserGroupTableAnnotationComposer,
|
|
$$UserGroupTableCreateCompanionBuilder,
|
|
$$UserGroupTableUpdateCompanionBuilder,
|
|
(UserGroupData, $$UserGroupTableReferences),
|
|
UserGroupData,
|
|
PrefetchHooks Function({bool userId, bool groupId})
|
|
>;
|
|
|
|
class $AppDatabaseManager {
|
|
final _$AppDatabase _db;
|
|
$AppDatabaseManager(this._db);
|
|
$$UserTableTableManager get user => $$UserTableTableManager(_db, _db.user);
|
|
$$GroupTableTableManager get group =>
|
|
$$GroupTableTableManager(_db, _db.group);
|
|
$$UserGroupTableTableManager get userGroup =>
|
|
$$UserGroupTableTableManager(_db, _db.userGroup);
|
|
}
|