6191 lines
198 KiB
Dart
6191 lines
198 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'database.dart';
|
|
|
|
// ignore_for_file: type=lint
|
|
class $PlayerTableTable extends PlayerTable
|
|
with TableInfo<$PlayerTableTable, PlayerTableData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$PlayerTableTable(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,
|
|
);
|
|
static const VerificationMeta _descriptionMeta = const VerificationMeta(
|
|
'description',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> description = GeneratedColumn<String>(
|
|
'description',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _createdAtMeta = const VerificationMeta(
|
|
'createdAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: true,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, name, description, createdAt];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'player_table';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<PlayerTableData> 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);
|
|
}
|
|
if (data.containsKey('description')) {
|
|
context.handle(
|
|
_descriptionMeta,
|
|
description.isAcceptableOrUnknown(
|
|
data['description']!,
|
|
_descriptionMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(
|
|
_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_createdAtMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
PlayerTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return PlayerTableData(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
name: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}name'],
|
|
)!,
|
|
description: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}description'],
|
|
),
|
|
createdAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}created_at'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$PlayerTableTable createAlias(String alias) {
|
|
return $PlayerTableTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class PlayerTableData extends DataClass implements Insertable<PlayerTableData> {
|
|
final String id;
|
|
final String name;
|
|
final String? description;
|
|
final DateTime createdAt;
|
|
const PlayerTableData({
|
|
required this.id,
|
|
required this.name,
|
|
this.description,
|
|
required this.createdAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<String>(id);
|
|
map['name'] = Variable<String>(name);
|
|
if (!nullToAbsent || description != null) {
|
|
map['description'] = Variable<String>(description);
|
|
}
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
return map;
|
|
}
|
|
|
|
PlayerTableCompanion toCompanion(bool nullToAbsent) {
|
|
return PlayerTableCompanion(
|
|
id: Value(id),
|
|
name: Value(name),
|
|
description: description == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(description),
|
|
createdAt: Value(createdAt),
|
|
);
|
|
}
|
|
|
|
factory PlayerTableData.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return PlayerTableData(
|
|
id: serializer.fromJson<String>(json['id']),
|
|
name: serializer.fromJson<String>(json['name']),
|
|
description: serializer.fromJson<String?>(json['description']),
|
|
createdAt: serializer.fromJson<DateTime>(json['createdAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<String>(id),
|
|
'name': serializer.toJson<String>(name),
|
|
'description': serializer.toJson<String?>(description),
|
|
'createdAt': serializer.toJson<DateTime>(createdAt),
|
|
};
|
|
}
|
|
|
|
PlayerTableData copyWith({
|
|
String? id,
|
|
String? name,
|
|
Value<String?> description = const Value.absent(),
|
|
DateTime? createdAt,
|
|
}) => PlayerTableData(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
description: description.present ? description.value : this.description,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
);
|
|
PlayerTableData copyWithCompanion(PlayerTableCompanion data) {
|
|
return PlayerTableData(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
name: data.name.present ? data.name.value : this.name,
|
|
description: data.description.present
|
|
? data.description.value
|
|
: this.description,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('PlayerTableData(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('description: $description, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, name, description, createdAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is PlayerTableData &&
|
|
other.id == this.id &&
|
|
other.name == this.name &&
|
|
other.description == this.description &&
|
|
other.createdAt == this.createdAt);
|
|
}
|
|
|
|
class PlayerTableCompanion extends UpdateCompanion<PlayerTableData> {
|
|
final Value<String> id;
|
|
final Value<String> name;
|
|
final Value<String?> description;
|
|
final Value<DateTime> createdAt;
|
|
final Value<int> rowid;
|
|
const PlayerTableCompanion({
|
|
this.id = const Value.absent(),
|
|
this.name = const Value.absent(),
|
|
this.description = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
PlayerTableCompanion.insert({
|
|
required String id,
|
|
required String name,
|
|
this.description = const Value.absent(),
|
|
required DateTime createdAt,
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id),
|
|
name = Value(name),
|
|
createdAt = Value(createdAt);
|
|
static Insertable<PlayerTableData> custom({
|
|
Expression<String>? id,
|
|
Expression<String>? name,
|
|
Expression<String>? description,
|
|
Expression<DateTime>? createdAt,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (name != null) 'name': name,
|
|
if (description != null) 'description': description,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
PlayerTableCompanion copyWith({
|
|
Value<String>? id,
|
|
Value<String>? name,
|
|
Value<String?>? description,
|
|
Value<DateTime>? createdAt,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return PlayerTableCompanion(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
description: description ?? this.description,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
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 (description.present) {
|
|
map['description'] = Variable<String>(description.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('PlayerTableCompanion(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('description: $description, ')
|
|
..write('createdAt: $createdAt, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $GroupTableTable extends GroupTable
|
|
with TableInfo<$GroupTableTable, GroupTableData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$GroupTableTable(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,
|
|
);
|
|
static const VerificationMeta _descriptionMeta = const VerificationMeta(
|
|
'description',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> description = GeneratedColumn<String>(
|
|
'description',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _createdAtMeta = const VerificationMeta(
|
|
'createdAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: true,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, name, description, createdAt];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'group_table';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<GroupTableData> 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);
|
|
}
|
|
if (data.containsKey('description')) {
|
|
context.handle(
|
|
_descriptionMeta,
|
|
description.isAcceptableOrUnknown(
|
|
data['description']!,
|
|
_descriptionMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(
|
|
_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_createdAtMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
GroupTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return GroupTableData(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
name: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}name'],
|
|
)!,
|
|
description: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}description'],
|
|
),
|
|
createdAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}created_at'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$GroupTableTable createAlias(String alias) {
|
|
return $GroupTableTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class GroupTableData extends DataClass implements Insertable<GroupTableData> {
|
|
final String id;
|
|
final String name;
|
|
final String? description;
|
|
final DateTime createdAt;
|
|
const GroupTableData({
|
|
required this.id,
|
|
required this.name,
|
|
this.description,
|
|
required this.createdAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<String>(id);
|
|
map['name'] = Variable<String>(name);
|
|
if (!nullToAbsent || description != null) {
|
|
map['description'] = Variable<String>(description);
|
|
}
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
return map;
|
|
}
|
|
|
|
GroupTableCompanion toCompanion(bool nullToAbsent) {
|
|
return GroupTableCompanion(
|
|
id: Value(id),
|
|
name: Value(name),
|
|
description: description == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(description),
|
|
createdAt: Value(createdAt),
|
|
);
|
|
}
|
|
|
|
factory GroupTableData.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return GroupTableData(
|
|
id: serializer.fromJson<String>(json['id']),
|
|
name: serializer.fromJson<String>(json['name']),
|
|
description: serializer.fromJson<String?>(json['description']),
|
|
createdAt: serializer.fromJson<DateTime>(json['createdAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<String>(id),
|
|
'name': serializer.toJson<String>(name),
|
|
'description': serializer.toJson<String?>(description),
|
|
'createdAt': serializer.toJson<DateTime>(createdAt),
|
|
};
|
|
}
|
|
|
|
GroupTableData copyWith({
|
|
String? id,
|
|
String? name,
|
|
Value<String?> description = const Value.absent(),
|
|
DateTime? createdAt,
|
|
}) => GroupTableData(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
description: description.present ? description.value : this.description,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
);
|
|
GroupTableData copyWithCompanion(GroupTableCompanion data) {
|
|
return GroupTableData(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
name: data.name.present ? data.name.value : this.name,
|
|
description: data.description.present
|
|
? data.description.value
|
|
: this.description,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('GroupTableData(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('description: $description, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, name, description, createdAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is GroupTableData &&
|
|
other.id == this.id &&
|
|
other.name == this.name &&
|
|
other.description == this.description &&
|
|
other.createdAt == this.createdAt);
|
|
}
|
|
|
|
class GroupTableCompanion extends UpdateCompanion<GroupTableData> {
|
|
final Value<String> id;
|
|
final Value<String> name;
|
|
final Value<String?> description;
|
|
final Value<DateTime> createdAt;
|
|
final Value<int> rowid;
|
|
const GroupTableCompanion({
|
|
this.id = const Value.absent(),
|
|
this.name = const Value.absent(),
|
|
this.description = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
GroupTableCompanion.insert({
|
|
required String id,
|
|
required String name,
|
|
this.description = const Value.absent(),
|
|
required DateTime createdAt,
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id),
|
|
name = Value(name),
|
|
createdAt = Value(createdAt);
|
|
static Insertable<GroupTableData> custom({
|
|
Expression<String>? id,
|
|
Expression<String>? name,
|
|
Expression<String>? description,
|
|
Expression<DateTime>? createdAt,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (name != null) 'name': name,
|
|
if (description != null) 'description': description,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
GroupTableCompanion copyWith({
|
|
Value<String>? id,
|
|
Value<String>? name,
|
|
Value<String?>? description,
|
|
Value<DateTime>? createdAt,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return GroupTableCompanion(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
description: description ?? this.description,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
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 (description.present) {
|
|
map['description'] = Variable<String>(description.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('GroupTableCompanion(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('description: $description, ')
|
|
..write('createdAt: $createdAt, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $GameTableTable extends GameTable
|
|
with TableInfo<$GameTableTable, GameTableData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$GameTableTable(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,
|
|
);
|
|
static const VerificationMeta _rulesetMeta = const VerificationMeta(
|
|
'ruleset',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> ruleset = GeneratedColumn<String>(
|
|
'ruleset',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _descriptionMeta = const VerificationMeta(
|
|
'description',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> description = GeneratedColumn<String>(
|
|
'description',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _colorMeta = const VerificationMeta('color');
|
|
@override
|
|
late final GeneratedColumn<String> color = GeneratedColumn<String>(
|
|
'color',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _iconMeta = const VerificationMeta('icon');
|
|
@override
|
|
late final GeneratedColumn<String> icon = GeneratedColumn<String>(
|
|
'icon',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _createdAtMeta = const VerificationMeta(
|
|
'createdAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: true,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
name,
|
|
ruleset,
|
|
description,
|
|
color,
|
|
icon,
|
|
createdAt,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'game_table';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<GameTableData> 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);
|
|
}
|
|
if (data.containsKey('ruleset')) {
|
|
context.handle(
|
|
_rulesetMeta,
|
|
ruleset.isAcceptableOrUnknown(data['ruleset']!, _rulesetMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_rulesetMeta);
|
|
}
|
|
if (data.containsKey('description')) {
|
|
context.handle(
|
|
_descriptionMeta,
|
|
description.isAcceptableOrUnknown(
|
|
data['description']!,
|
|
_descriptionMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('color')) {
|
|
context.handle(
|
|
_colorMeta,
|
|
color.isAcceptableOrUnknown(data['color']!, _colorMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('icon')) {
|
|
context.handle(
|
|
_iconMeta,
|
|
icon.isAcceptableOrUnknown(data['icon']!, _iconMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(
|
|
_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_createdAtMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
GameTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return GameTableData(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
name: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}name'],
|
|
)!,
|
|
ruleset: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}ruleset'],
|
|
)!,
|
|
description: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}description'],
|
|
),
|
|
color: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}color'],
|
|
),
|
|
icon: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}icon'],
|
|
),
|
|
createdAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}created_at'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$GameTableTable createAlias(String alias) {
|
|
return $GameTableTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class GameTableData extends DataClass implements Insertable<GameTableData> {
|
|
final String id;
|
|
final String name;
|
|
final String ruleset;
|
|
final String? description;
|
|
final String? color;
|
|
final String? icon;
|
|
final DateTime createdAt;
|
|
const GameTableData({
|
|
required this.id,
|
|
required this.name,
|
|
required this.ruleset,
|
|
this.description,
|
|
this.color,
|
|
this.icon,
|
|
required this.createdAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<String>(id);
|
|
map['name'] = Variable<String>(name);
|
|
map['ruleset'] = Variable<String>(ruleset);
|
|
if (!nullToAbsent || description != null) {
|
|
map['description'] = Variable<String>(description);
|
|
}
|
|
if (!nullToAbsent || color != null) {
|
|
map['color'] = Variable<String>(color);
|
|
}
|
|
if (!nullToAbsent || icon != null) {
|
|
map['icon'] = Variable<String>(icon);
|
|
}
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
return map;
|
|
}
|
|
|
|
GameTableCompanion toCompanion(bool nullToAbsent) {
|
|
return GameTableCompanion(
|
|
id: Value(id),
|
|
name: Value(name),
|
|
ruleset: Value(ruleset),
|
|
description: description == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(description),
|
|
color: color == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(color),
|
|
icon: icon == null && nullToAbsent ? const Value.absent() : Value(icon),
|
|
createdAt: Value(createdAt),
|
|
);
|
|
}
|
|
|
|
factory GameTableData.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return GameTableData(
|
|
id: serializer.fromJson<String>(json['id']),
|
|
name: serializer.fromJson<String>(json['name']),
|
|
ruleset: serializer.fromJson<String>(json['ruleset']),
|
|
description: serializer.fromJson<String?>(json['description']),
|
|
color: serializer.fromJson<String?>(json['color']),
|
|
icon: serializer.fromJson<String?>(json['icon']),
|
|
createdAt: serializer.fromJson<DateTime>(json['createdAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<String>(id),
|
|
'name': serializer.toJson<String>(name),
|
|
'ruleset': serializer.toJson<String>(ruleset),
|
|
'description': serializer.toJson<String?>(description),
|
|
'color': serializer.toJson<String?>(color),
|
|
'icon': serializer.toJson<String?>(icon),
|
|
'createdAt': serializer.toJson<DateTime>(createdAt),
|
|
};
|
|
}
|
|
|
|
GameTableData copyWith({
|
|
String? id,
|
|
String? name,
|
|
String? ruleset,
|
|
Value<String?> description = const Value.absent(),
|
|
Value<String?> color = const Value.absent(),
|
|
Value<String?> icon = const Value.absent(),
|
|
DateTime? createdAt,
|
|
}) => GameTableData(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
ruleset: ruleset ?? this.ruleset,
|
|
description: description.present ? description.value : this.description,
|
|
color: color.present ? color.value : this.color,
|
|
icon: icon.present ? icon.value : this.icon,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
);
|
|
GameTableData copyWithCompanion(GameTableCompanion data) {
|
|
return GameTableData(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
name: data.name.present ? data.name.value : this.name,
|
|
ruleset: data.ruleset.present ? data.ruleset.value : this.ruleset,
|
|
description: data.description.present
|
|
? data.description.value
|
|
: this.description,
|
|
color: data.color.present ? data.color.value : this.color,
|
|
icon: data.icon.present ? data.icon.value : this.icon,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('GameTableData(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('ruleset: $ruleset, ')
|
|
..write('description: $description, ')
|
|
..write('color: $color, ')
|
|
..write('icon: $icon, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode =>
|
|
Object.hash(id, name, ruleset, description, color, icon, createdAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is GameTableData &&
|
|
other.id == this.id &&
|
|
other.name == this.name &&
|
|
other.ruleset == this.ruleset &&
|
|
other.description == this.description &&
|
|
other.color == this.color &&
|
|
other.icon == this.icon &&
|
|
other.createdAt == this.createdAt);
|
|
}
|
|
|
|
class GameTableCompanion extends UpdateCompanion<GameTableData> {
|
|
final Value<String> id;
|
|
final Value<String> name;
|
|
final Value<String> ruleset;
|
|
final Value<String?> description;
|
|
final Value<String?> color;
|
|
final Value<String?> icon;
|
|
final Value<DateTime> createdAt;
|
|
final Value<int> rowid;
|
|
const GameTableCompanion({
|
|
this.id = const Value.absent(),
|
|
this.name = const Value.absent(),
|
|
this.ruleset = const Value.absent(),
|
|
this.description = const Value.absent(),
|
|
this.color = const Value.absent(),
|
|
this.icon = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
GameTableCompanion.insert({
|
|
required String id,
|
|
required String name,
|
|
required String ruleset,
|
|
this.description = const Value.absent(),
|
|
this.color = const Value.absent(),
|
|
this.icon = const Value.absent(),
|
|
required DateTime createdAt,
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id),
|
|
name = Value(name),
|
|
ruleset = Value(ruleset),
|
|
createdAt = Value(createdAt);
|
|
static Insertable<GameTableData> custom({
|
|
Expression<String>? id,
|
|
Expression<String>? name,
|
|
Expression<String>? ruleset,
|
|
Expression<String>? description,
|
|
Expression<String>? color,
|
|
Expression<String>? icon,
|
|
Expression<DateTime>? createdAt,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (name != null) 'name': name,
|
|
if (ruleset != null) 'ruleset': ruleset,
|
|
if (description != null) 'description': description,
|
|
if (color != null) 'color': color,
|
|
if (icon != null) 'icon': icon,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
GameTableCompanion copyWith({
|
|
Value<String>? id,
|
|
Value<String>? name,
|
|
Value<String>? ruleset,
|
|
Value<String?>? description,
|
|
Value<String?>? color,
|
|
Value<String?>? icon,
|
|
Value<DateTime>? createdAt,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return GameTableCompanion(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
ruleset: ruleset ?? this.ruleset,
|
|
description: description ?? this.description,
|
|
color: color ?? this.color,
|
|
icon: icon ?? this.icon,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
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 (ruleset.present) {
|
|
map['ruleset'] = Variable<String>(ruleset.value);
|
|
}
|
|
if (description.present) {
|
|
map['description'] = Variable<String>(description.value);
|
|
}
|
|
if (color.present) {
|
|
map['color'] = Variable<String>(color.value);
|
|
}
|
|
if (icon.present) {
|
|
map['icon'] = Variable<String>(icon.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('GameTableCompanion(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('ruleset: $ruleset, ')
|
|
..write('description: $description, ')
|
|
..write('color: $color, ')
|
|
..write('icon: $icon, ')
|
|
..write('createdAt: $createdAt, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $TeamTableTable extends TeamTable
|
|
with TableInfo<$TeamTableTable, TeamTableData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$TeamTableTable(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,
|
|
);
|
|
static const VerificationMeta _createdAtMeta = const VerificationMeta(
|
|
'createdAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: true,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, name, createdAt];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'team_table';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<TeamTableData> 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);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(
|
|
_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_createdAtMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
TeamTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return TeamTableData(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
name: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}name'],
|
|
)!,
|
|
createdAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}created_at'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$TeamTableTable createAlias(String alias) {
|
|
return $TeamTableTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class TeamTableData extends DataClass implements Insertable<TeamTableData> {
|
|
final String id;
|
|
final String name;
|
|
final DateTime createdAt;
|
|
const TeamTableData({
|
|
required this.id,
|
|
required this.name,
|
|
required this.createdAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<String>(id);
|
|
map['name'] = Variable<String>(name);
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
return map;
|
|
}
|
|
|
|
TeamTableCompanion toCompanion(bool nullToAbsent) {
|
|
return TeamTableCompanion(
|
|
id: Value(id),
|
|
name: Value(name),
|
|
createdAt: Value(createdAt),
|
|
);
|
|
}
|
|
|
|
factory TeamTableData.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return TeamTableData(
|
|
id: serializer.fromJson<String>(json['id']),
|
|
name: serializer.fromJson<String>(json['name']),
|
|
createdAt: serializer.fromJson<DateTime>(json['createdAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<String>(id),
|
|
'name': serializer.toJson<String>(name),
|
|
'createdAt': serializer.toJson<DateTime>(createdAt),
|
|
};
|
|
}
|
|
|
|
TeamTableData copyWith({String? id, String? name, DateTime? createdAt}) =>
|
|
TeamTableData(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
);
|
|
TeamTableData copyWithCompanion(TeamTableCompanion data) {
|
|
return TeamTableData(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
name: data.name.present ? data.name.value : this.name,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TeamTableData(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, name, createdAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is TeamTableData &&
|
|
other.id == this.id &&
|
|
other.name == this.name &&
|
|
other.createdAt == this.createdAt);
|
|
}
|
|
|
|
class TeamTableCompanion extends UpdateCompanion<TeamTableData> {
|
|
final Value<String> id;
|
|
final Value<String> name;
|
|
final Value<DateTime> createdAt;
|
|
final Value<int> rowid;
|
|
const TeamTableCompanion({
|
|
this.id = const Value.absent(),
|
|
this.name = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
TeamTableCompanion.insert({
|
|
required String id,
|
|
required String name,
|
|
required DateTime createdAt,
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id),
|
|
name = Value(name),
|
|
createdAt = Value(createdAt);
|
|
static Insertable<TeamTableData> custom({
|
|
Expression<String>? id,
|
|
Expression<String>? name,
|
|
Expression<DateTime>? createdAt,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (name != null) 'name': name,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
TeamTableCompanion copyWith({
|
|
Value<String>? id,
|
|
Value<String>? name,
|
|
Value<DateTime>? createdAt,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return TeamTableCompanion(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
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 (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TeamTableCompanion(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('createdAt: $createdAt, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $MatchTableTable extends MatchTable
|
|
with TableInfo<$MatchTableTable, MatchTableData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$MatchTableTable(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 _gameIdMeta = const VerificationMeta('gameId');
|
|
@override
|
|
late final GeneratedColumn<String> gameId = GeneratedColumn<String>(
|
|
'game_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES game_table (id) ON DELETE CASCADE',
|
|
),
|
|
);
|
|
static const VerificationMeta _groupIdMeta = const VerificationMeta(
|
|
'groupId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> groupId = GeneratedColumn<String>(
|
|
'group_id',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES group_table (id) ON DELETE CASCADE',
|
|
),
|
|
);
|
|
static const VerificationMeta _nameMeta = const VerificationMeta('name');
|
|
@override
|
|
late final GeneratedColumn<String> name = GeneratedColumn<String>(
|
|
'name',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _notesMeta = const VerificationMeta('notes');
|
|
@override
|
|
late final GeneratedColumn<String> notes = GeneratedColumn<String>(
|
|
'notes',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _createdAtMeta = const VerificationMeta(
|
|
'createdAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: true,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
gameId,
|
|
groupId,
|
|
name,
|
|
notes,
|
|
createdAt,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'match_table';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<MatchTableData> 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('game_id')) {
|
|
context.handle(
|
|
_gameIdMeta,
|
|
gameId.isAcceptableOrUnknown(data['game_id']!, _gameIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_gameIdMeta);
|
|
}
|
|
if (data.containsKey('group_id')) {
|
|
context.handle(
|
|
_groupIdMeta,
|
|
groupId.isAcceptableOrUnknown(data['group_id']!, _groupIdMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('name')) {
|
|
context.handle(
|
|
_nameMeta,
|
|
name.isAcceptableOrUnknown(data['name']!, _nameMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('notes')) {
|
|
context.handle(
|
|
_notesMeta,
|
|
notes.isAcceptableOrUnknown(data['notes']!, _notesMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(
|
|
_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_createdAtMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
MatchTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return MatchTableData(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
gameId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}game_id'],
|
|
)!,
|
|
groupId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}group_id'],
|
|
),
|
|
name: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}name'],
|
|
),
|
|
notes: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}notes'],
|
|
),
|
|
createdAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}created_at'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$MatchTableTable createAlias(String alias) {
|
|
return $MatchTableTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class MatchTableData extends DataClass implements Insertable<MatchTableData> {
|
|
final String id;
|
|
final String gameId;
|
|
final String? groupId;
|
|
final String? name;
|
|
final String? notes;
|
|
final DateTime createdAt;
|
|
const MatchTableData({
|
|
required this.id,
|
|
required this.gameId,
|
|
this.groupId,
|
|
this.name,
|
|
this.notes,
|
|
required this.createdAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<String>(id);
|
|
map['game_id'] = Variable<String>(gameId);
|
|
if (!nullToAbsent || groupId != null) {
|
|
map['group_id'] = Variable<String>(groupId);
|
|
}
|
|
if (!nullToAbsent || name != null) {
|
|
map['name'] = Variable<String>(name);
|
|
}
|
|
if (!nullToAbsent || notes != null) {
|
|
map['notes'] = Variable<String>(notes);
|
|
}
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
return map;
|
|
}
|
|
|
|
MatchTableCompanion toCompanion(bool nullToAbsent) {
|
|
return MatchTableCompanion(
|
|
id: Value(id),
|
|
gameId: Value(gameId),
|
|
groupId: groupId == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(groupId),
|
|
name: name == null && nullToAbsent ? const Value.absent() : Value(name),
|
|
notes: notes == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(notes),
|
|
createdAt: Value(createdAt),
|
|
);
|
|
}
|
|
|
|
factory MatchTableData.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return MatchTableData(
|
|
id: serializer.fromJson<String>(json['id']),
|
|
gameId: serializer.fromJson<String>(json['gameId']),
|
|
groupId: serializer.fromJson<String?>(json['groupId']),
|
|
name: serializer.fromJson<String?>(json['name']),
|
|
notes: serializer.fromJson<String?>(json['notes']),
|
|
createdAt: serializer.fromJson<DateTime>(json['createdAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<String>(id),
|
|
'gameId': serializer.toJson<String>(gameId),
|
|
'groupId': serializer.toJson<String?>(groupId),
|
|
'name': serializer.toJson<String?>(name),
|
|
'notes': serializer.toJson<String?>(notes),
|
|
'createdAt': serializer.toJson<DateTime>(createdAt),
|
|
};
|
|
}
|
|
|
|
MatchTableData copyWith({
|
|
String? id,
|
|
String? gameId,
|
|
Value<String?> groupId = const Value.absent(),
|
|
Value<String?> name = const Value.absent(),
|
|
Value<String?> notes = const Value.absent(),
|
|
DateTime? createdAt,
|
|
}) => MatchTableData(
|
|
id: id ?? this.id,
|
|
gameId: gameId ?? this.gameId,
|
|
groupId: groupId.present ? groupId.value : this.groupId,
|
|
name: name.present ? name.value : this.name,
|
|
notes: notes.present ? notes.value : this.notes,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
);
|
|
MatchTableData copyWithCompanion(MatchTableCompanion data) {
|
|
return MatchTableData(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
gameId: data.gameId.present ? data.gameId.value : this.gameId,
|
|
groupId: data.groupId.present ? data.groupId.value : this.groupId,
|
|
name: data.name.present ? data.name.value : this.name,
|
|
notes: data.notes.present ? data.notes.value : this.notes,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('MatchTableData(')
|
|
..write('id: $id, ')
|
|
..write('gameId: $gameId, ')
|
|
..write('groupId: $groupId, ')
|
|
..write('name: $name, ')
|
|
..write('notes: $notes, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, gameId, groupId, name, notes, createdAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is MatchTableData &&
|
|
other.id == this.id &&
|
|
other.gameId == this.gameId &&
|
|
other.groupId == this.groupId &&
|
|
other.name == this.name &&
|
|
other.notes == this.notes &&
|
|
other.createdAt == this.createdAt);
|
|
}
|
|
|
|
class MatchTableCompanion extends UpdateCompanion<MatchTableData> {
|
|
final Value<String> id;
|
|
final Value<String> gameId;
|
|
final Value<String?> groupId;
|
|
final Value<String?> name;
|
|
final Value<String?> notes;
|
|
final Value<DateTime> createdAt;
|
|
final Value<int> rowid;
|
|
const MatchTableCompanion({
|
|
this.id = const Value.absent(),
|
|
this.gameId = const Value.absent(),
|
|
this.groupId = const Value.absent(),
|
|
this.name = const Value.absent(),
|
|
this.notes = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
MatchTableCompanion.insert({
|
|
required String id,
|
|
required String gameId,
|
|
this.groupId = const Value.absent(),
|
|
this.name = const Value.absent(),
|
|
this.notes = const Value.absent(),
|
|
required DateTime createdAt,
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id),
|
|
gameId = Value(gameId),
|
|
createdAt = Value(createdAt);
|
|
static Insertable<MatchTableData> custom({
|
|
Expression<String>? id,
|
|
Expression<String>? gameId,
|
|
Expression<String>? groupId,
|
|
Expression<String>? name,
|
|
Expression<String>? notes,
|
|
Expression<DateTime>? createdAt,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (gameId != null) 'game_id': gameId,
|
|
if (groupId != null) 'group_id': groupId,
|
|
if (name != null) 'name': name,
|
|
if (notes != null) 'notes': notes,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
MatchTableCompanion copyWith({
|
|
Value<String>? id,
|
|
Value<String>? gameId,
|
|
Value<String?>? groupId,
|
|
Value<String?>? name,
|
|
Value<String?>? notes,
|
|
Value<DateTime>? createdAt,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return MatchTableCompanion(
|
|
id: id ?? this.id,
|
|
gameId: gameId ?? this.gameId,
|
|
groupId: groupId ?? this.groupId,
|
|
name: name ?? this.name,
|
|
notes: notes ?? this.notes,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
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 (gameId.present) {
|
|
map['game_id'] = Variable<String>(gameId.value);
|
|
}
|
|
if (groupId.present) {
|
|
map['group_id'] = Variable<String>(groupId.value);
|
|
}
|
|
if (name.present) {
|
|
map['name'] = Variable<String>(name.value);
|
|
}
|
|
if (notes.present) {
|
|
map['notes'] = Variable<String>(notes.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('MatchTableCompanion(')
|
|
..write('id: $id, ')
|
|
..write('gameId: $gameId, ')
|
|
..write('groupId: $groupId, ')
|
|
..write('name: $name, ')
|
|
..write('notes: $notes, ')
|
|
..write('createdAt: $createdAt, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $PlayerGroupTableTable extends PlayerGroupTable
|
|
with TableInfo<$PlayerGroupTableTable, PlayerGroupTableData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$PlayerGroupTableTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _playerIdMeta = const VerificationMeta(
|
|
'playerId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> playerId = GeneratedColumn<String>(
|
|
'player_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES player_table (id) ON DELETE CASCADE',
|
|
),
|
|
);
|
|
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_table (id) ON DELETE CASCADE',
|
|
),
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [playerId, groupId];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'player_group_table';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<PlayerGroupTableData> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('player_id')) {
|
|
context.handle(
|
|
_playerIdMeta,
|
|
playerId.isAcceptableOrUnknown(data['player_id']!, _playerIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_playerIdMeta);
|
|
}
|
|
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 => {playerId, groupId};
|
|
@override
|
|
PlayerGroupTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return PlayerGroupTableData(
|
|
playerId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}player_id'],
|
|
)!,
|
|
groupId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}group_id'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$PlayerGroupTableTable createAlias(String alias) {
|
|
return $PlayerGroupTableTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class PlayerGroupTableData extends DataClass
|
|
implements Insertable<PlayerGroupTableData> {
|
|
final String playerId;
|
|
final String groupId;
|
|
const PlayerGroupTableData({required this.playerId, required this.groupId});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['player_id'] = Variable<String>(playerId);
|
|
map['group_id'] = Variable<String>(groupId);
|
|
return map;
|
|
}
|
|
|
|
PlayerGroupTableCompanion toCompanion(bool nullToAbsent) {
|
|
return PlayerGroupTableCompanion(
|
|
playerId: Value(playerId),
|
|
groupId: Value(groupId),
|
|
);
|
|
}
|
|
|
|
factory PlayerGroupTableData.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return PlayerGroupTableData(
|
|
playerId: serializer.fromJson<String>(json['playerId']),
|
|
groupId: serializer.fromJson<String>(json['groupId']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'playerId': serializer.toJson<String>(playerId),
|
|
'groupId': serializer.toJson<String>(groupId),
|
|
};
|
|
}
|
|
|
|
PlayerGroupTableData copyWith({String? playerId, String? groupId}) =>
|
|
PlayerGroupTableData(
|
|
playerId: playerId ?? this.playerId,
|
|
groupId: groupId ?? this.groupId,
|
|
);
|
|
PlayerGroupTableData copyWithCompanion(PlayerGroupTableCompanion data) {
|
|
return PlayerGroupTableData(
|
|
playerId: data.playerId.present ? data.playerId.value : this.playerId,
|
|
groupId: data.groupId.present ? data.groupId.value : this.groupId,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('PlayerGroupTableData(')
|
|
..write('playerId: $playerId, ')
|
|
..write('groupId: $groupId')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(playerId, groupId);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is PlayerGroupTableData &&
|
|
other.playerId == this.playerId &&
|
|
other.groupId == this.groupId);
|
|
}
|
|
|
|
class PlayerGroupTableCompanion extends UpdateCompanion<PlayerGroupTableData> {
|
|
final Value<String> playerId;
|
|
final Value<String> groupId;
|
|
final Value<int> rowid;
|
|
const PlayerGroupTableCompanion({
|
|
this.playerId = const Value.absent(),
|
|
this.groupId = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
PlayerGroupTableCompanion.insert({
|
|
required String playerId,
|
|
required String groupId,
|
|
this.rowid = const Value.absent(),
|
|
}) : playerId = Value(playerId),
|
|
groupId = Value(groupId);
|
|
static Insertable<PlayerGroupTableData> custom({
|
|
Expression<String>? playerId,
|
|
Expression<String>? groupId,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (playerId != null) 'player_id': playerId,
|
|
if (groupId != null) 'group_id': groupId,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
PlayerGroupTableCompanion copyWith({
|
|
Value<String>? playerId,
|
|
Value<String>? groupId,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return PlayerGroupTableCompanion(
|
|
playerId: playerId ?? this.playerId,
|
|
groupId: groupId ?? this.groupId,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (playerId.present) {
|
|
map['player_id'] = Variable<String>(playerId.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('PlayerGroupTableCompanion(')
|
|
..write('playerId: $playerId, ')
|
|
..write('groupId: $groupId, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $PlayerMatchTableTable extends PlayerMatchTable
|
|
with TableInfo<$PlayerMatchTableTable, PlayerMatchTableData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$PlayerMatchTableTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _playerIdMeta = const VerificationMeta(
|
|
'playerId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> playerId = GeneratedColumn<String>(
|
|
'player_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES player_table (id) ON DELETE CASCADE',
|
|
),
|
|
);
|
|
static const VerificationMeta _matchIdMeta = const VerificationMeta(
|
|
'matchId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> matchId = GeneratedColumn<String>(
|
|
'match_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES match_table (id) ON DELETE CASCADE',
|
|
),
|
|
);
|
|
static const VerificationMeta _teamIdMeta = const VerificationMeta('teamId');
|
|
@override
|
|
late final GeneratedColumn<String> teamId = GeneratedColumn<String>(
|
|
'team_id',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES team_table (id)',
|
|
),
|
|
);
|
|
static const VerificationMeta _scoreMeta = const VerificationMeta('score');
|
|
@override
|
|
late final GeneratedColumn<int> score = GeneratedColumn<int>(
|
|
'score',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [playerId, matchId, teamId, score];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'player_match_table';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<PlayerMatchTableData> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('player_id')) {
|
|
context.handle(
|
|
_playerIdMeta,
|
|
playerId.isAcceptableOrUnknown(data['player_id']!, _playerIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_playerIdMeta);
|
|
}
|
|
if (data.containsKey('match_id')) {
|
|
context.handle(
|
|
_matchIdMeta,
|
|
matchId.isAcceptableOrUnknown(data['match_id']!, _matchIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_matchIdMeta);
|
|
}
|
|
if (data.containsKey('team_id')) {
|
|
context.handle(
|
|
_teamIdMeta,
|
|
teamId.isAcceptableOrUnknown(data['team_id']!, _teamIdMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('score')) {
|
|
context.handle(
|
|
_scoreMeta,
|
|
score.isAcceptableOrUnknown(data['score']!, _scoreMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_scoreMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {playerId, matchId};
|
|
@override
|
|
PlayerMatchTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return PlayerMatchTableData(
|
|
playerId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}player_id'],
|
|
)!,
|
|
matchId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}match_id'],
|
|
)!,
|
|
teamId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}team_id'],
|
|
),
|
|
score: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}score'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$PlayerMatchTableTable createAlias(String alias) {
|
|
return $PlayerMatchTableTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class PlayerMatchTableData extends DataClass
|
|
implements Insertable<PlayerMatchTableData> {
|
|
final String playerId;
|
|
final String matchId;
|
|
final String? teamId;
|
|
final int score;
|
|
const PlayerMatchTableData({
|
|
required this.playerId,
|
|
required this.matchId,
|
|
this.teamId,
|
|
required this.score,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['player_id'] = Variable<String>(playerId);
|
|
map['match_id'] = Variable<String>(matchId);
|
|
if (!nullToAbsent || teamId != null) {
|
|
map['team_id'] = Variable<String>(teamId);
|
|
}
|
|
map['score'] = Variable<int>(score);
|
|
return map;
|
|
}
|
|
|
|
PlayerMatchTableCompanion toCompanion(bool nullToAbsent) {
|
|
return PlayerMatchTableCompanion(
|
|
playerId: Value(playerId),
|
|
matchId: Value(matchId),
|
|
teamId: teamId == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(teamId),
|
|
score: Value(score),
|
|
);
|
|
}
|
|
|
|
factory PlayerMatchTableData.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return PlayerMatchTableData(
|
|
playerId: serializer.fromJson<String>(json['playerId']),
|
|
matchId: serializer.fromJson<String>(json['matchId']),
|
|
teamId: serializer.fromJson<String?>(json['teamId']),
|
|
score: serializer.fromJson<int>(json['score']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'playerId': serializer.toJson<String>(playerId),
|
|
'matchId': serializer.toJson<String>(matchId),
|
|
'teamId': serializer.toJson<String?>(teamId),
|
|
'score': serializer.toJson<int>(score),
|
|
};
|
|
}
|
|
|
|
PlayerMatchTableData copyWith({
|
|
String? playerId,
|
|
String? matchId,
|
|
Value<String?> teamId = const Value.absent(),
|
|
int? score,
|
|
}) => PlayerMatchTableData(
|
|
playerId: playerId ?? this.playerId,
|
|
matchId: matchId ?? this.matchId,
|
|
teamId: teamId.present ? teamId.value : this.teamId,
|
|
score: score ?? this.score,
|
|
);
|
|
PlayerMatchTableData copyWithCompanion(PlayerMatchTableCompanion data) {
|
|
return PlayerMatchTableData(
|
|
playerId: data.playerId.present ? data.playerId.value : this.playerId,
|
|
matchId: data.matchId.present ? data.matchId.value : this.matchId,
|
|
teamId: data.teamId.present ? data.teamId.value : this.teamId,
|
|
score: data.score.present ? data.score.value : this.score,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('PlayerMatchTableData(')
|
|
..write('playerId: $playerId, ')
|
|
..write('matchId: $matchId, ')
|
|
..write('teamId: $teamId, ')
|
|
..write('score: $score')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(playerId, matchId, teamId, score);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is PlayerMatchTableData &&
|
|
other.playerId == this.playerId &&
|
|
other.matchId == this.matchId &&
|
|
other.teamId == this.teamId &&
|
|
other.score == this.score);
|
|
}
|
|
|
|
class PlayerMatchTableCompanion extends UpdateCompanion<PlayerMatchTableData> {
|
|
final Value<String> playerId;
|
|
final Value<String> matchId;
|
|
final Value<String?> teamId;
|
|
final Value<int> score;
|
|
final Value<int> rowid;
|
|
const PlayerMatchTableCompanion({
|
|
this.playerId = const Value.absent(),
|
|
this.matchId = const Value.absent(),
|
|
this.teamId = const Value.absent(),
|
|
this.score = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
PlayerMatchTableCompanion.insert({
|
|
required String playerId,
|
|
required String matchId,
|
|
this.teamId = const Value.absent(),
|
|
required int score,
|
|
this.rowid = const Value.absent(),
|
|
}) : playerId = Value(playerId),
|
|
matchId = Value(matchId),
|
|
score = Value(score);
|
|
static Insertable<PlayerMatchTableData> custom({
|
|
Expression<String>? playerId,
|
|
Expression<String>? matchId,
|
|
Expression<String>? teamId,
|
|
Expression<int>? score,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (playerId != null) 'player_id': playerId,
|
|
if (matchId != null) 'match_id': matchId,
|
|
if (teamId != null) 'team_id': teamId,
|
|
if (score != null) 'score': score,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
PlayerMatchTableCompanion copyWith({
|
|
Value<String>? playerId,
|
|
Value<String>? matchId,
|
|
Value<String?>? teamId,
|
|
Value<int>? score,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return PlayerMatchTableCompanion(
|
|
playerId: playerId ?? this.playerId,
|
|
matchId: matchId ?? this.matchId,
|
|
teamId: teamId ?? this.teamId,
|
|
score: score ?? this.score,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (playerId.present) {
|
|
map['player_id'] = Variable<String>(playerId.value);
|
|
}
|
|
if (matchId.present) {
|
|
map['match_id'] = Variable<String>(matchId.value);
|
|
}
|
|
if (teamId.present) {
|
|
map['team_id'] = Variable<String>(teamId.value);
|
|
}
|
|
if (score.present) {
|
|
map['score'] = Variable<int>(score.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('PlayerMatchTableCompanion(')
|
|
..write('playerId: $playerId, ')
|
|
..write('matchId: $matchId, ')
|
|
..write('teamId: $teamId, ')
|
|
..write('score: $score, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $ScoreTableTable extends ScoreTable
|
|
with TableInfo<$ScoreTableTable, ScoreTableData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$ScoreTableTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _playerIdMeta = const VerificationMeta(
|
|
'playerId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> playerId = GeneratedColumn<String>(
|
|
'player_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES player_table (id) ON DELETE CASCADE',
|
|
),
|
|
);
|
|
static const VerificationMeta _matchIdMeta = const VerificationMeta(
|
|
'matchId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> matchId = GeneratedColumn<String>(
|
|
'match_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES match_table (id) ON DELETE CASCADE',
|
|
),
|
|
);
|
|
static const VerificationMeta _roundNumberMeta = const VerificationMeta(
|
|
'roundNumber',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> roundNumber = GeneratedColumn<int>(
|
|
'round_number',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _scoreMeta = const VerificationMeta('score');
|
|
@override
|
|
late final GeneratedColumn<int> score = GeneratedColumn<int>(
|
|
'score',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _changeMeta = const VerificationMeta('change');
|
|
@override
|
|
late final GeneratedColumn<int> change = GeneratedColumn<int>(
|
|
'change',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
playerId,
|
|
matchId,
|
|
roundNumber,
|
|
score,
|
|
change,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'score_table';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<ScoreTableData> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('player_id')) {
|
|
context.handle(
|
|
_playerIdMeta,
|
|
playerId.isAcceptableOrUnknown(data['player_id']!, _playerIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_playerIdMeta);
|
|
}
|
|
if (data.containsKey('match_id')) {
|
|
context.handle(
|
|
_matchIdMeta,
|
|
matchId.isAcceptableOrUnknown(data['match_id']!, _matchIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_matchIdMeta);
|
|
}
|
|
if (data.containsKey('round_number')) {
|
|
context.handle(
|
|
_roundNumberMeta,
|
|
roundNumber.isAcceptableOrUnknown(
|
|
data['round_number']!,
|
|
_roundNumberMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_roundNumberMeta);
|
|
}
|
|
if (data.containsKey('score')) {
|
|
context.handle(
|
|
_scoreMeta,
|
|
score.isAcceptableOrUnknown(data['score']!, _scoreMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_scoreMeta);
|
|
}
|
|
if (data.containsKey('change')) {
|
|
context.handle(
|
|
_changeMeta,
|
|
change.isAcceptableOrUnknown(data['change']!, _changeMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_changeMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {playerId, matchId, roundNumber};
|
|
@override
|
|
ScoreTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return ScoreTableData(
|
|
playerId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}player_id'],
|
|
)!,
|
|
matchId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}match_id'],
|
|
)!,
|
|
roundNumber: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}round_number'],
|
|
)!,
|
|
score: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}score'],
|
|
)!,
|
|
change: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}change'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$ScoreTableTable createAlias(String alias) {
|
|
return $ScoreTableTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class ScoreTableData extends DataClass implements Insertable<ScoreTableData> {
|
|
final String playerId;
|
|
final String matchId;
|
|
final int roundNumber;
|
|
final int score;
|
|
final int change;
|
|
const ScoreTableData({
|
|
required this.playerId,
|
|
required this.matchId,
|
|
required this.roundNumber,
|
|
required this.score,
|
|
required this.change,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['player_id'] = Variable<String>(playerId);
|
|
map['match_id'] = Variable<String>(matchId);
|
|
map['round_number'] = Variable<int>(roundNumber);
|
|
map['score'] = Variable<int>(score);
|
|
map['change'] = Variable<int>(change);
|
|
return map;
|
|
}
|
|
|
|
ScoreTableCompanion toCompanion(bool nullToAbsent) {
|
|
return ScoreTableCompanion(
|
|
playerId: Value(playerId),
|
|
matchId: Value(matchId),
|
|
roundNumber: Value(roundNumber),
|
|
score: Value(score),
|
|
change: Value(change),
|
|
);
|
|
}
|
|
|
|
factory ScoreTableData.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return ScoreTableData(
|
|
playerId: serializer.fromJson<String>(json['playerId']),
|
|
matchId: serializer.fromJson<String>(json['matchId']),
|
|
roundNumber: serializer.fromJson<int>(json['roundNumber']),
|
|
score: serializer.fromJson<int>(json['score']),
|
|
change: serializer.fromJson<int>(json['change']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'playerId': serializer.toJson<String>(playerId),
|
|
'matchId': serializer.toJson<String>(matchId),
|
|
'roundNumber': serializer.toJson<int>(roundNumber),
|
|
'score': serializer.toJson<int>(score),
|
|
'change': serializer.toJson<int>(change),
|
|
};
|
|
}
|
|
|
|
ScoreTableData copyWith({
|
|
String? playerId,
|
|
String? matchId,
|
|
int? roundNumber,
|
|
int? score,
|
|
int? change,
|
|
}) => ScoreTableData(
|
|
playerId: playerId ?? this.playerId,
|
|
matchId: matchId ?? this.matchId,
|
|
roundNumber: roundNumber ?? this.roundNumber,
|
|
score: score ?? this.score,
|
|
change: change ?? this.change,
|
|
);
|
|
ScoreTableData copyWithCompanion(ScoreTableCompanion data) {
|
|
return ScoreTableData(
|
|
playerId: data.playerId.present ? data.playerId.value : this.playerId,
|
|
matchId: data.matchId.present ? data.matchId.value : this.matchId,
|
|
roundNumber: data.roundNumber.present
|
|
? data.roundNumber.value
|
|
: this.roundNumber,
|
|
score: data.score.present ? data.score.value : this.score,
|
|
change: data.change.present ? data.change.value : this.change,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ScoreTableData(')
|
|
..write('playerId: $playerId, ')
|
|
..write('matchId: $matchId, ')
|
|
..write('roundNumber: $roundNumber, ')
|
|
..write('score: $score, ')
|
|
..write('change: $change')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode =>
|
|
Object.hash(playerId, matchId, roundNumber, score, change);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is ScoreTableData &&
|
|
other.playerId == this.playerId &&
|
|
other.matchId == this.matchId &&
|
|
other.roundNumber == this.roundNumber &&
|
|
other.score == this.score &&
|
|
other.change == this.change);
|
|
}
|
|
|
|
class ScoreTableCompanion extends UpdateCompanion<ScoreTableData> {
|
|
final Value<String> playerId;
|
|
final Value<String> matchId;
|
|
final Value<int> roundNumber;
|
|
final Value<int> score;
|
|
final Value<int> change;
|
|
final Value<int> rowid;
|
|
const ScoreTableCompanion({
|
|
this.playerId = const Value.absent(),
|
|
this.matchId = const Value.absent(),
|
|
this.roundNumber = const Value.absent(),
|
|
this.score = const Value.absent(),
|
|
this.change = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
ScoreTableCompanion.insert({
|
|
required String playerId,
|
|
required String matchId,
|
|
required int roundNumber,
|
|
required int score,
|
|
required int change,
|
|
this.rowid = const Value.absent(),
|
|
}) : playerId = Value(playerId),
|
|
matchId = Value(matchId),
|
|
roundNumber = Value(roundNumber),
|
|
score = Value(score),
|
|
change = Value(change);
|
|
static Insertable<ScoreTableData> custom({
|
|
Expression<String>? playerId,
|
|
Expression<String>? matchId,
|
|
Expression<int>? roundNumber,
|
|
Expression<int>? score,
|
|
Expression<int>? change,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (playerId != null) 'player_id': playerId,
|
|
if (matchId != null) 'match_id': matchId,
|
|
if (roundNumber != null) 'round_number': roundNumber,
|
|
if (score != null) 'score': score,
|
|
if (change != null) 'change': change,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
ScoreTableCompanion copyWith({
|
|
Value<String>? playerId,
|
|
Value<String>? matchId,
|
|
Value<int>? roundNumber,
|
|
Value<int>? score,
|
|
Value<int>? change,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return ScoreTableCompanion(
|
|
playerId: playerId ?? this.playerId,
|
|
matchId: matchId ?? this.matchId,
|
|
roundNumber: roundNumber ?? this.roundNumber,
|
|
score: score ?? this.score,
|
|
change: change ?? this.change,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (playerId.present) {
|
|
map['player_id'] = Variable<String>(playerId.value);
|
|
}
|
|
if (matchId.present) {
|
|
map['match_id'] = Variable<String>(matchId.value);
|
|
}
|
|
if (roundNumber.present) {
|
|
map['round_number'] = Variable<int>(roundNumber.value);
|
|
}
|
|
if (score.present) {
|
|
map['score'] = Variable<int>(score.value);
|
|
}
|
|
if (change.present) {
|
|
map['change'] = Variable<int>(change.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ScoreTableCompanion(')
|
|
..write('playerId: $playerId, ')
|
|
..write('matchId: $matchId, ')
|
|
..write('roundNumber: $roundNumber, ')
|
|
..write('score: $score, ')
|
|
..write('change: $change, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
abstract class _$AppDatabase extends GeneratedDatabase {
|
|
_$AppDatabase(QueryExecutor e) : super(e);
|
|
$AppDatabaseManager get managers => $AppDatabaseManager(this);
|
|
late final $PlayerTableTable playerTable = $PlayerTableTable(this);
|
|
late final $GroupTableTable groupTable = $GroupTableTable(this);
|
|
late final $GameTableTable gameTable = $GameTableTable(this);
|
|
late final $TeamTableTable teamTable = $TeamTableTable(this);
|
|
late final $MatchTableTable matchTable = $MatchTableTable(this);
|
|
late final $PlayerGroupTableTable playerGroupTable = $PlayerGroupTableTable(
|
|
this,
|
|
);
|
|
late final $PlayerMatchTableTable playerMatchTable = $PlayerMatchTableTable(
|
|
this,
|
|
);
|
|
late final $ScoreTableTable scoreTable = $ScoreTableTable(this);
|
|
late final PlayerDao playerDao = PlayerDao(this as AppDatabase);
|
|
late final GroupDao groupDao = GroupDao(this as AppDatabase);
|
|
late final GameDao gameDao = GameDao(this as AppDatabase);
|
|
late final TeamDao teamDao = TeamDao(this as AppDatabase);
|
|
late final MatchDao matchDao = MatchDao(this as AppDatabase);
|
|
late final PlayerGroupDao playerGroupDao = PlayerGroupDao(
|
|
this as AppDatabase,
|
|
);
|
|
late final PlayerMatchDao playerMatchDao = PlayerMatchDao(
|
|
this as AppDatabase,
|
|
);
|
|
late final ScoreDao scoreDao = ScoreDao(this as AppDatabase);
|
|
@override
|
|
Iterable<TableInfo<Table, Object?>> get allTables =>
|
|
allSchemaEntities.whereType<TableInfo<Table, Object?>>();
|
|
@override
|
|
List<DatabaseSchemaEntity> get allSchemaEntities => [
|
|
playerTable,
|
|
groupTable,
|
|
gameTable,
|
|
teamTable,
|
|
matchTable,
|
|
playerGroupTable,
|
|
playerMatchTable,
|
|
scoreTable,
|
|
];
|
|
@override
|
|
StreamQueryUpdateRules get streamUpdateRules => const StreamQueryUpdateRules([
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName(
|
|
'game_table',
|
|
limitUpdateKind: UpdateKind.delete,
|
|
),
|
|
result: [TableUpdate('match_table', kind: UpdateKind.delete)],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName(
|
|
'group_table',
|
|
limitUpdateKind: UpdateKind.delete,
|
|
),
|
|
result: [TableUpdate('match_table', kind: UpdateKind.delete)],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName(
|
|
'player_table',
|
|
limitUpdateKind: UpdateKind.delete,
|
|
),
|
|
result: [TableUpdate('player_group_table', kind: UpdateKind.delete)],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName(
|
|
'group_table',
|
|
limitUpdateKind: UpdateKind.delete,
|
|
),
|
|
result: [TableUpdate('player_group_table', kind: UpdateKind.delete)],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName(
|
|
'player_table',
|
|
limitUpdateKind: UpdateKind.delete,
|
|
),
|
|
result: [TableUpdate('player_match_table', kind: UpdateKind.delete)],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName(
|
|
'match_table',
|
|
limitUpdateKind: UpdateKind.delete,
|
|
),
|
|
result: [TableUpdate('player_match_table', kind: UpdateKind.delete)],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName(
|
|
'player_table',
|
|
limitUpdateKind: UpdateKind.delete,
|
|
),
|
|
result: [TableUpdate('score_table', kind: UpdateKind.delete)],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName(
|
|
'match_table',
|
|
limitUpdateKind: UpdateKind.delete,
|
|
),
|
|
result: [TableUpdate('score_table', kind: UpdateKind.delete)],
|
|
),
|
|
]);
|
|
}
|
|
|
|
typedef $$PlayerTableTableCreateCompanionBuilder =
|
|
PlayerTableCompanion Function({
|
|
required String id,
|
|
required String name,
|
|
Value<String?> description,
|
|
required DateTime createdAt,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$PlayerTableTableUpdateCompanionBuilder =
|
|
PlayerTableCompanion Function({
|
|
Value<String> id,
|
|
Value<String> name,
|
|
Value<String?> description,
|
|
Value<DateTime> createdAt,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$PlayerTableTableReferences
|
|
extends BaseReferences<_$AppDatabase, $PlayerTableTable, PlayerTableData> {
|
|
$$PlayerTableTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$PlayerGroupTableTable, List<PlayerGroupTableData>>
|
|
_playerGroupTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.playerGroupTable,
|
|
aliasName: $_aliasNameGenerator(
|
|
db.playerTable.id,
|
|
db.playerGroupTable.playerId,
|
|
),
|
|
);
|
|
|
|
$$PlayerGroupTableTableProcessedTableManager get playerGroupTableRefs {
|
|
final manager = $$PlayerGroupTableTableTableManager(
|
|
$_db,
|
|
$_db.playerGroupTable,
|
|
).filter((f) => f.playerId.id.sqlEquals($_itemColumn<String>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(
|
|
_playerGroupTableRefsTable($_db),
|
|
);
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
|
|
static MultiTypedResultKey<$PlayerMatchTableTable, List<PlayerMatchTableData>>
|
|
_playerMatchTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.playerMatchTable,
|
|
aliasName: $_aliasNameGenerator(
|
|
db.playerTable.id,
|
|
db.playerMatchTable.playerId,
|
|
),
|
|
);
|
|
|
|
$$PlayerMatchTableTableProcessedTableManager get playerMatchTableRefs {
|
|
final manager = $$PlayerMatchTableTableTableManager(
|
|
$_db,
|
|
$_db.playerMatchTable,
|
|
).filter((f) => f.playerId.id.sqlEquals($_itemColumn<String>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(
|
|
_playerMatchTableRefsTable($_db),
|
|
);
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
|
|
static MultiTypedResultKey<$ScoreTableTable, List<ScoreTableData>>
|
|
_scoreTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.scoreTable,
|
|
aliasName: $_aliasNameGenerator(db.playerTable.id, db.scoreTable.playerId),
|
|
);
|
|
|
|
$$ScoreTableTableProcessedTableManager get scoreTableRefs {
|
|
final manager = $$ScoreTableTableTableManager(
|
|
$_db,
|
|
$_db.scoreTable,
|
|
).filter((f) => f.playerId.id.sqlEquals($_itemColumn<String>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(_scoreTableRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$PlayerTableTableFilterComposer
|
|
extends Composer<_$AppDatabase, $PlayerTableTable> {
|
|
$$PlayerTableTableFilterComposer({
|
|
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),
|
|
);
|
|
|
|
ColumnFilters<String> get description => $composableBuilder(
|
|
column: $table.description,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
Expression<bool> playerGroupTableRefs(
|
|
Expression<bool> Function($$PlayerGroupTableTableFilterComposer f) f,
|
|
) {
|
|
final $$PlayerGroupTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.playerGroupTable,
|
|
getReferencedColumn: (t) => t.playerId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlayerGroupTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.playerGroupTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
|
|
Expression<bool> playerMatchTableRefs(
|
|
Expression<bool> Function($$PlayerMatchTableTableFilterComposer f) f,
|
|
) {
|
|
final $$PlayerMatchTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.playerMatchTable,
|
|
getReferencedColumn: (t) => t.playerId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlayerMatchTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.playerMatchTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
|
|
Expression<bool> scoreTableRefs(
|
|
Expression<bool> Function($$ScoreTableTableFilterComposer f) f,
|
|
) {
|
|
final $$ScoreTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.scoreTable,
|
|
getReferencedColumn: (t) => t.playerId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$ScoreTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.scoreTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$PlayerTableTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $PlayerTableTable> {
|
|
$$PlayerTableTableOrderingComposer({
|
|
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),
|
|
);
|
|
|
|
ColumnOrderings<String> get description => $composableBuilder(
|
|
column: $table.description,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$PlayerTableTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $PlayerTableTable> {
|
|
$$PlayerTableTableAnnotationComposer({
|
|
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);
|
|
|
|
GeneratedColumn<String> get description => $composableBuilder(
|
|
column: $table.description,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
Expression<T> playerGroupTableRefs<T extends Object>(
|
|
Expression<T> Function($$PlayerGroupTableTableAnnotationComposer a) f,
|
|
) {
|
|
final $$PlayerGroupTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.playerGroupTable,
|
|
getReferencedColumn: (t) => t.playerId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlayerGroupTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.playerGroupTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
|
|
Expression<T> playerMatchTableRefs<T extends Object>(
|
|
Expression<T> Function($$PlayerMatchTableTableAnnotationComposer a) f,
|
|
) {
|
|
final $$PlayerMatchTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.playerMatchTable,
|
|
getReferencedColumn: (t) => t.playerId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlayerMatchTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.playerMatchTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
|
|
Expression<T> scoreTableRefs<T extends Object>(
|
|
Expression<T> Function($$ScoreTableTableAnnotationComposer a) f,
|
|
) {
|
|
final $$ScoreTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.scoreTable,
|
|
getReferencedColumn: (t) => t.playerId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$ScoreTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.scoreTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$PlayerTableTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$PlayerTableTable,
|
|
PlayerTableData,
|
|
$$PlayerTableTableFilterComposer,
|
|
$$PlayerTableTableOrderingComposer,
|
|
$$PlayerTableTableAnnotationComposer,
|
|
$$PlayerTableTableCreateCompanionBuilder,
|
|
$$PlayerTableTableUpdateCompanionBuilder,
|
|
(PlayerTableData, $$PlayerTableTableReferences),
|
|
PlayerTableData,
|
|
PrefetchHooks Function({
|
|
bool playerGroupTableRefs,
|
|
bool playerMatchTableRefs,
|
|
bool scoreTableRefs,
|
|
})
|
|
> {
|
|
$$PlayerTableTableTableManager(_$AppDatabase db, $PlayerTableTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$PlayerTableTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$PlayerTableTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$PlayerTableTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> id = const Value.absent(),
|
|
Value<String> name = const Value.absent(),
|
|
Value<String?> description = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => PlayerTableCompanion(
|
|
id: id,
|
|
name: name,
|
|
description: description,
|
|
createdAt: createdAt,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String id,
|
|
required String name,
|
|
Value<String?> description = const Value.absent(),
|
|
required DateTime createdAt,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => PlayerTableCompanion.insert(
|
|
id: id,
|
|
name: name,
|
|
description: description,
|
|
createdAt: createdAt,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$PlayerTableTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback:
|
|
({
|
|
playerGroupTableRefs = false,
|
|
playerMatchTableRefs = false,
|
|
scoreTableRefs = false,
|
|
}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [
|
|
if (playerGroupTableRefs) db.playerGroupTable,
|
|
if (playerMatchTableRefs) db.playerMatchTable,
|
|
if (scoreTableRefs) db.scoreTable,
|
|
],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (playerGroupTableRefs)
|
|
await $_getPrefetchedData<
|
|
PlayerTableData,
|
|
$PlayerTableTable,
|
|
PlayerGroupTableData
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$PlayerTableTableReferences
|
|
._playerGroupTableRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$PlayerTableTableReferences(
|
|
db,
|
|
table,
|
|
p0,
|
|
).playerGroupTableRefs,
|
|
referencedItemsForCurrentItem:
|
|
(item, referencedItems) => referencedItems.where(
|
|
(e) => e.playerId == item.id,
|
|
),
|
|
typedResults: items,
|
|
),
|
|
if (playerMatchTableRefs)
|
|
await $_getPrefetchedData<
|
|
PlayerTableData,
|
|
$PlayerTableTable,
|
|
PlayerMatchTableData
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$PlayerTableTableReferences
|
|
._playerMatchTableRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$PlayerTableTableReferences(
|
|
db,
|
|
table,
|
|
p0,
|
|
).playerMatchTableRefs,
|
|
referencedItemsForCurrentItem:
|
|
(item, referencedItems) => referencedItems.where(
|
|
(e) => e.playerId == item.id,
|
|
),
|
|
typedResults: items,
|
|
),
|
|
if (scoreTableRefs)
|
|
await $_getPrefetchedData<
|
|
PlayerTableData,
|
|
$PlayerTableTable,
|
|
ScoreTableData
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$PlayerTableTableReferences
|
|
._scoreTableRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$PlayerTableTableReferences(
|
|
db,
|
|
table,
|
|
p0,
|
|
).scoreTableRefs,
|
|
referencedItemsForCurrentItem:
|
|
(item, referencedItems) => referencedItems.where(
|
|
(e) => e.playerId == item.id,
|
|
),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$PlayerTableTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$PlayerTableTable,
|
|
PlayerTableData,
|
|
$$PlayerTableTableFilterComposer,
|
|
$$PlayerTableTableOrderingComposer,
|
|
$$PlayerTableTableAnnotationComposer,
|
|
$$PlayerTableTableCreateCompanionBuilder,
|
|
$$PlayerTableTableUpdateCompanionBuilder,
|
|
(PlayerTableData, $$PlayerTableTableReferences),
|
|
PlayerTableData,
|
|
PrefetchHooks Function({
|
|
bool playerGroupTableRefs,
|
|
bool playerMatchTableRefs,
|
|
bool scoreTableRefs,
|
|
})
|
|
>;
|
|
typedef $$GroupTableTableCreateCompanionBuilder =
|
|
GroupTableCompanion Function({
|
|
required String id,
|
|
required String name,
|
|
Value<String?> description,
|
|
required DateTime createdAt,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$GroupTableTableUpdateCompanionBuilder =
|
|
GroupTableCompanion Function({
|
|
Value<String> id,
|
|
Value<String> name,
|
|
Value<String?> description,
|
|
Value<DateTime> createdAt,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$GroupTableTableReferences
|
|
extends BaseReferences<_$AppDatabase, $GroupTableTable, GroupTableData> {
|
|
$$GroupTableTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$MatchTableTable, List<MatchTableData>>
|
|
_matchTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.matchTable,
|
|
aliasName: $_aliasNameGenerator(db.groupTable.id, db.matchTable.groupId),
|
|
);
|
|
|
|
$$MatchTableTableProcessedTableManager get matchTableRefs {
|
|
final manager = $$MatchTableTableTableManager(
|
|
$_db,
|
|
$_db.matchTable,
|
|
).filter((f) => f.groupId.id.sqlEquals($_itemColumn<String>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(_matchTableRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
|
|
static MultiTypedResultKey<$PlayerGroupTableTable, List<PlayerGroupTableData>>
|
|
_playerGroupTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.playerGroupTable,
|
|
aliasName: $_aliasNameGenerator(
|
|
db.groupTable.id,
|
|
db.playerGroupTable.groupId,
|
|
),
|
|
);
|
|
|
|
$$PlayerGroupTableTableProcessedTableManager get playerGroupTableRefs {
|
|
final manager = $$PlayerGroupTableTableTableManager(
|
|
$_db,
|
|
$_db.playerGroupTable,
|
|
).filter((f) => f.groupId.id.sqlEquals($_itemColumn<String>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(
|
|
_playerGroupTableRefsTable($_db),
|
|
);
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$GroupTableTableFilterComposer
|
|
extends Composer<_$AppDatabase, $GroupTableTable> {
|
|
$$GroupTableTableFilterComposer({
|
|
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),
|
|
);
|
|
|
|
ColumnFilters<String> get description => $composableBuilder(
|
|
column: $table.description,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
Expression<bool> matchTableRefs(
|
|
Expression<bool> Function($$MatchTableTableFilterComposer f) f,
|
|
) {
|
|
final $$MatchTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.matchTable,
|
|
getReferencedColumn: (t) => t.groupId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$MatchTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.matchTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
|
|
Expression<bool> playerGroupTableRefs(
|
|
Expression<bool> Function($$PlayerGroupTableTableFilterComposer f) f,
|
|
) {
|
|
final $$PlayerGroupTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.playerGroupTable,
|
|
getReferencedColumn: (t) => t.groupId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlayerGroupTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.playerGroupTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$GroupTableTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $GroupTableTable> {
|
|
$$GroupTableTableOrderingComposer({
|
|
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),
|
|
);
|
|
|
|
ColumnOrderings<String> get description => $composableBuilder(
|
|
column: $table.description,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$GroupTableTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $GroupTableTable> {
|
|
$$GroupTableTableAnnotationComposer({
|
|
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);
|
|
|
|
GeneratedColumn<String> get description => $composableBuilder(
|
|
column: $table.description,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
Expression<T> matchTableRefs<T extends Object>(
|
|
Expression<T> Function($$MatchTableTableAnnotationComposer a) f,
|
|
) {
|
|
final $$MatchTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.matchTable,
|
|
getReferencedColumn: (t) => t.groupId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$MatchTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.matchTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
|
|
Expression<T> playerGroupTableRefs<T extends Object>(
|
|
Expression<T> Function($$PlayerGroupTableTableAnnotationComposer a) f,
|
|
) {
|
|
final $$PlayerGroupTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.playerGroupTable,
|
|
getReferencedColumn: (t) => t.groupId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlayerGroupTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.playerGroupTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$GroupTableTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$GroupTableTable,
|
|
GroupTableData,
|
|
$$GroupTableTableFilterComposer,
|
|
$$GroupTableTableOrderingComposer,
|
|
$$GroupTableTableAnnotationComposer,
|
|
$$GroupTableTableCreateCompanionBuilder,
|
|
$$GroupTableTableUpdateCompanionBuilder,
|
|
(GroupTableData, $$GroupTableTableReferences),
|
|
GroupTableData,
|
|
PrefetchHooks Function({
|
|
bool matchTableRefs,
|
|
bool playerGroupTableRefs,
|
|
})
|
|
> {
|
|
$$GroupTableTableTableManager(_$AppDatabase db, $GroupTableTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$GroupTableTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$GroupTableTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$GroupTableTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> id = const Value.absent(),
|
|
Value<String> name = const Value.absent(),
|
|
Value<String?> description = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => GroupTableCompanion(
|
|
id: id,
|
|
name: name,
|
|
description: description,
|
|
createdAt: createdAt,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String id,
|
|
required String name,
|
|
Value<String?> description = const Value.absent(),
|
|
required DateTime createdAt,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => GroupTableCompanion.insert(
|
|
id: id,
|
|
name: name,
|
|
description: description,
|
|
createdAt: createdAt,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$GroupTableTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback:
|
|
({matchTableRefs = false, playerGroupTableRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [
|
|
if (matchTableRefs) db.matchTable,
|
|
if (playerGroupTableRefs) db.playerGroupTable,
|
|
],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (matchTableRefs)
|
|
await $_getPrefetchedData<
|
|
GroupTableData,
|
|
$GroupTableTable,
|
|
MatchTableData
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$GroupTableTableReferences
|
|
._matchTableRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$GroupTableTableReferences(
|
|
db,
|
|
table,
|
|
p0,
|
|
).matchTableRefs,
|
|
referencedItemsForCurrentItem:
|
|
(item, referencedItems) => referencedItems.where(
|
|
(e) => e.groupId == item.id,
|
|
),
|
|
typedResults: items,
|
|
),
|
|
if (playerGroupTableRefs)
|
|
await $_getPrefetchedData<
|
|
GroupTableData,
|
|
$GroupTableTable,
|
|
PlayerGroupTableData
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$GroupTableTableReferences
|
|
._playerGroupTableRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$GroupTableTableReferences(
|
|
db,
|
|
table,
|
|
p0,
|
|
).playerGroupTableRefs,
|
|
referencedItemsForCurrentItem:
|
|
(item, referencedItems) => referencedItems.where(
|
|
(e) => e.groupId == item.id,
|
|
),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$GroupTableTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$GroupTableTable,
|
|
GroupTableData,
|
|
$$GroupTableTableFilterComposer,
|
|
$$GroupTableTableOrderingComposer,
|
|
$$GroupTableTableAnnotationComposer,
|
|
$$GroupTableTableCreateCompanionBuilder,
|
|
$$GroupTableTableUpdateCompanionBuilder,
|
|
(GroupTableData, $$GroupTableTableReferences),
|
|
GroupTableData,
|
|
PrefetchHooks Function({bool matchTableRefs, bool playerGroupTableRefs})
|
|
>;
|
|
typedef $$GameTableTableCreateCompanionBuilder =
|
|
GameTableCompanion Function({
|
|
required String id,
|
|
required String name,
|
|
required String ruleset,
|
|
Value<String?> description,
|
|
Value<String?> color,
|
|
Value<String?> icon,
|
|
required DateTime createdAt,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$GameTableTableUpdateCompanionBuilder =
|
|
GameTableCompanion Function({
|
|
Value<String> id,
|
|
Value<String> name,
|
|
Value<String> ruleset,
|
|
Value<String?> description,
|
|
Value<String?> color,
|
|
Value<String?> icon,
|
|
Value<DateTime> createdAt,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$GameTableTableReferences
|
|
extends BaseReferences<_$AppDatabase, $GameTableTable, GameTableData> {
|
|
$$GameTableTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$MatchTableTable, List<MatchTableData>>
|
|
_matchTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.matchTable,
|
|
aliasName: $_aliasNameGenerator(db.gameTable.id, db.matchTable.gameId),
|
|
);
|
|
|
|
$$MatchTableTableProcessedTableManager get matchTableRefs {
|
|
final manager = $$MatchTableTableTableManager(
|
|
$_db,
|
|
$_db.matchTable,
|
|
).filter((f) => f.gameId.id.sqlEquals($_itemColumn<String>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(_matchTableRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$GameTableTableFilterComposer
|
|
extends Composer<_$AppDatabase, $GameTableTable> {
|
|
$$GameTableTableFilterComposer({
|
|
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),
|
|
);
|
|
|
|
ColumnFilters<String> get ruleset => $composableBuilder(
|
|
column: $table.ruleset,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get description => $composableBuilder(
|
|
column: $table.description,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get color => $composableBuilder(
|
|
column: $table.color,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get icon => $composableBuilder(
|
|
column: $table.icon,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
Expression<bool> matchTableRefs(
|
|
Expression<bool> Function($$MatchTableTableFilterComposer f) f,
|
|
) {
|
|
final $$MatchTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.matchTable,
|
|
getReferencedColumn: (t) => t.gameId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$MatchTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.matchTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$GameTableTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $GameTableTable> {
|
|
$$GameTableTableOrderingComposer({
|
|
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),
|
|
);
|
|
|
|
ColumnOrderings<String> get ruleset => $composableBuilder(
|
|
column: $table.ruleset,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get description => $composableBuilder(
|
|
column: $table.description,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get color => $composableBuilder(
|
|
column: $table.color,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get icon => $composableBuilder(
|
|
column: $table.icon,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$GameTableTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $GameTableTable> {
|
|
$$GameTableTableAnnotationComposer({
|
|
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);
|
|
|
|
GeneratedColumn<String> get ruleset =>
|
|
$composableBuilder(column: $table.ruleset, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get description => $composableBuilder(
|
|
column: $table.description,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<String> get color =>
|
|
$composableBuilder(column: $table.color, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get icon =>
|
|
$composableBuilder(column: $table.icon, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
Expression<T> matchTableRefs<T extends Object>(
|
|
Expression<T> Function($$MatchTableTableAnnotationComposer a) f,
|
|
) {
|
|
final $$MatchTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.matchTable,
|
|
getReferencedColumn: (t) => t.gameId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$MatchTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.matchTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$GameTableTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$GameTableTable,
|
|
GameTableData,
|
|
$$GameTableTableFilterComposer,
|
|
$$GameTableTableOrderingComposer,
|
|
$$GameTableTableAnnotationComposer,
|
|
$$GameTableTableCreateCompanionBuilder,
|
|
$$GameTableTableUpdateCompanionBuilder,
|
|
(GameTableData, $$GameTableTableReferences),
|
|
GameTableData,
|
|
PrefetchHooks Function({bool matchTableRefs})
|
|
> {
|
|
$$GameTableTableTableManager(_$AppDatabase db, $GameTableTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$GameTableTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$GameTableTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$GameTableTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> id = const Value.absent(),
|
|
Value<String> name = const Value.absent(),
|
|
Value<String> ruleset = const Value.absent(),
|
|
Value<String?> description = const Value.absent(),
|
|
Value<String?> color = const Value.absent(),
|
|
Value<String?> icon = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => GameTableCompanion(
|
|
id: id,
|
|
name: name,
|
|
ruleset: ruleset,
|
|
description: description,
|
|
color: color,
|
|
icon: icon,
|
|
createdAt: createdAt,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String id,
|
|
required String name,
|
|
required String ruleset,
|
|
Value<String?> description = const Value.absent(),
|
|
Value<String?> color = const Value.absent(),
|
|
Value<String?> icon = const Value.absent(),
|
|
required DateTime createdAt,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => GameTableCompanion.insert(
|
|
id: id,
|
|
name: name,
|
|
ruleset: ruleset,
|
|
description: description,
|
|
color: color,
|
|
icon: icon,
|
|
createdAt: createdAt,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$GameTableTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({matchTableRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [if (matchTableRefs) db.matchTable],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (matchTableRefs)
|
|
await $_getPrefetchedData<
|
|
GameTableData,
|
|
$GameTableTable,
|
|
MatchTableData
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$GameTableTableReferences
|
|
._matchTableRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$GameTableTableReferences(
|
|
db,
|
|
table,
|
|
p0,
|
|
).matchTableRefs,
|
|
referencedItemsForCurrentItem: (item, referencedItems) =>
|
|
referencedItems.where((e) => e.gameId == item.id),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$GameTableTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$GameTableTable,
|
|
GameTableData,
|
|
$$GameTableTableFilterComposer,
|
|
$$GameTableTableOrderingComposer,
|
|
$$GameTableTableAnnotationComposer,
|
|
$$GameTableTableCreateCompanionBuilder,
|
|
$$GameTableTableUpdateCompanionBuilder,
|
|
(GameTableData, $$GameTableTableReferences),
|
|
GameTableData,
|
|
PrefetchHooks Function({bool matchTableRefs})
|
|
>;
|
|
typedef $$TeamTableTableCreateCompanionBuilder =
|
|
TeamTableCompanion Function({
|
|
required String id,
|
|
required String name,
|
|
required DateTime createdAt,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$TeamTableTableUpdateCompanionBuilder =
|
|
TeamTableCompanion Function({
|
|
Value<String> id,
|
|
Value<String> name,
|
|
Value<DateTime> createdAt,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$TeamTableTableReferences
|
|
extends BaseReferences<_$AppDatabase, $TeamTableTable, TeamTableData> {
|
|
$$TeamTableTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$PlayerMatchTableTable, List<PlayerMatchTableData>>
|
|
_playerMatchTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.playerMatchTable,
|
|
aliasName: $_aliasNameGenerator(
|
|
db.teamTable.id,
|
|
db.playerMatchTable.teamId,
|
|
),
|
|
);
|
|
|
|
$$PlayerMatchTableTableProcessedTableManager get playerMatchTableRefs {
|
|
final manager = $$PlayerMatchTableTableTableManager(
|
|
$_db,
|
|
$_db.playerMatchTable,
|
|
).filter((f) => f.teamId.id.sqlEquals($_itemColumn<String>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(
|
|
_playerMatchTableRefsTable($_db),
|
|
);
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$TeamTableTableFilterComposer
|
|
extends Composer<_$AppDatabase, $TeamTableTable> {
|
|
$$TeamTableTableFilterComposer({
|
|
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),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
Expression<bool> playerMatchTableRefs(
|
|
Expression<bool> Function($$PlayerMatchTableTableFilterComposer f) f,
|
|
) {
|
|
final $$PlayerMatchTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.playerMatchTable,
|
|
getReferencedColumn: (t) => t.teamId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlayerMatchTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.playerMatchTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$TeamTableTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $TeamTableTable> {
|
|
$$TeamTableTableOrderingComposer({
|
|
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),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$TeamTableTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $TeamTableTable> {
|
|
$$TeamTableTableAnnotationComposer({
|
|
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);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
Expression<T> playerMatchTableRefs<T extends Object>(
|
|
Expression<T> Function($$PlayerMatchTableTableAnnotationComposer a) f,
|
|
) {
|
|
final $$PlayerMatchTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.playerMatchTable,
|
|
getReferencedColumn: (t) => t.teamId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlayerMatchTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.playerMatchTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$TeamTableTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$TeamTableTable,
|
|
TeamTableData,
|
|
$$TeamTableTableFilterComposer,
|
|
$$TeamTableTableOrderingComposer,
|
|
$$TeamTableTableAnnotationComposer,
|
|
$$TeamTableTableCreateCompanionBuilder,
|
|
$$TeamTableTableUpdateCompanionBuilder,
|
|
(TeamTableData, $$TeamTableTableReferences),
|
|
TeamTableData,
|
|
PrefetchHooks Function({bool playerMatchTableRefs})
|
|
> {
|
|
$$TeamTableTableTableManager(_$AppDatabase db, $TeamTableTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$TeamTableTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$TeamTableTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$TeamTableTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> id = const Value.absent(),
|
|
Value<String> name = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => TeamTableCompanion(
|
|
id: id,
|
|
name: name,
|
|
createdAt: createdAt,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String id,
|
|
required String name,
|
|
required DateTime createdAt,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => TeamTableCompanion.insert(
|
|
id: id,
|
|
name: name,
|
|
createdAt: createdAt,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$TeamTableTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({playerMatchTableRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [
|
|
if (playerMatchTableRefs) db.playerMatchTable,
|
|
],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (playerMatchTableRefs)
|
|
await $_getPrefetchedData<
|
|
TeamTableData,
|
|
$TeamTableTable,
|
|
PlayerMatchTableData
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$TeamTableTableReferences
|
|
._playerMatchTableRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$TeamTableTableReferences(
|
|
db,
|
|
table,
|
|
p0,
|
|
).playerMatchTableRefs,
|
|
referencedItemsForCurrentItem: (item, referencedItems) =>
|
|
referencedItems.where((e) => e.teamId == item.id),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$TeamTableTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$TeamTableTable,
|
|
TeamTableData,
|
|
$$TeamTableTableFilterComposer,
|
|
$$TeamTableTableOrderingComposer,
|
|
$$TeamTableTableAnnotationComposer,
|
|
$$TeamTableTableCreateCompanionBuilder,
|
|
$$TeamTableTableUpdateCompanionBuilder,
|
|
(TeamTableData, $$TeamTableTableReferences),
|
|
TeamTableData,
|
|
PrefetchHooks Function({bool playerMatchTableRefs})
|
|
>;
|
|
typedef $$MatchTableTableCreateCompanionBuilder =
|
|
MatchTableCompanion Function({
|
|
required String id,
|
|
required String gameId,
|
|
Value<String?> groupId,
|
|
Value<String?> name,
|
|
Value<String?> notes,
|
|
required DateTime createdAt,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$MatchTableTableUpdateCompanionBuilder =
|
|
MatchTableCompanion Function({
|
|
Value<String> id,
|
|
Value<String> gameId,
|
|
Value<String?> groupId,
|
|
Value<String?> name,
|
|
Value<String?> notes,
|
|
Value<DateTime> createdAt,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$MatchTableTableReferences
|
|
extends BaseReferences<_$AppDatabase, $MatchTableTable, MatchTableData> {
|
|
$$MatchTableTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static $GameTableTable _gameIdTable(_$AppDatabase db) => db.gameTable
|
|
.createAlias($_aliasNameGenerator(db.matchTable.gameId, db.gameTable.id));
|
|
|
|
$$GameTableTableProcessedTableManager get gameId {
|
|
final $_column = $_itemColumn<String>('game_id')!;
|
|
|
|
final manager = $$GameTableTableTableManager(
|
|
$_db,
|
|
$_db.gameTable,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_gameIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
|
|
static $GroupTableTable _groupIdTable(_$AppDatabase db) =>
|
|
db.groupTable.createAlias(
|
|
$_aliasNameGenerator(db.matchTable.groupId, db.groupTable.id),
|
|
);
|
|
|
|
$$GroupTableTableProcessedTableManager? get groupId {
|
|
final $_column = $_itemColumn<String>('group_id');
|
|
if ($_column == null) return null;
|
|
final manager = $$GroupTableTableTableManager(
|
|
$_db,
|
|
$_db.groupTable,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_groupIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
|
|
static MultiTypedResultKey<$PlayerMatchTableTable, List<PlayerMatchTableData>>
|
|
_playerMatchTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.playerMatchTable,
|
|
aliasName: $_aliasNameGenerator(
|
|
db.matchTable.id,
|
|
db.playerMatchTable.matchId,
|
|
),
|
|
);
|
|
|
|
$$PlayerMatchTableTableProcessedTableManager get playerMatchTableRefs {
|
|
final manager = $$PlayerMatchTableTableTableManager(
|
|
$_db,
|
|
$_db.playerMatchTable,
|
|
).filter((f) => f.matchId.id.sqlEquals($_itemColumn<String>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(
|
|
_playerMatchTableRefsTable($_db),
|
|
);
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
|
|
static MultiTypedResultKey<$ScoreTableTable, List<ScoreTableData>>
|
|
_scoreTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.scoreTable,
|
|
aliasName: $_aliasNameGenerator(db.matchTable.id, db.scoreTable.matchId),
|
|
);
|
|
|
|
$$ScoreTableTableProcessedTableManager get scoreTableRefs {
|
|
final manager = $$ScoreTableTableTableManager(
|
|
$_db,
|
|
$_db.scoreTable,
|
|
).filter((f) => f.matchId.id.sqlEquals($_itemColumn<String>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(_scoreTableRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$MatchTableTableFilterComposer
|
|
extends Composer<_$AppDatabase, $MatchTableTable> {
|
|
$$MatchTableTableFilterComposer({
|
|
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),
|
|
);
|
|
|
|
ColumnFilters<String> get notes => $composableBuilder(
|
|
column: $table.notes,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
$$GameTableTableFilterComposer get gameId {
|
|
final $$GameTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.gameId,
|
|
referencedTable: $db.gameTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$GameTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.gameTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$GroupTableTableFilterComposer get groupId {
|
|
final $$GroupTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.groupId,
|
|
referencedTable: $db.groupTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$GroupTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.groupTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
Expression<bool> playerMatchTableRefs(
|
|
Expression<bool> Function($$PlayerMatchTableTableFilterComposer f) f,
|
|
) {
|
|
final $$PlayerMatchTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.playerMatchTable,
|
|
getReferencedColumn: (t) => t.matchId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlayerMatchTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.playerMatchTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
|
|
Expression<bool> scoreTableRefs(
|
|
Expression<bool> Function($$ScoreTableTableFilterComposer f) f,
|
|
) {
|
|
final $$ScoreTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.scoreTable,
|
|
getReferencedColumn: (t) => t.matchId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$ScoreTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.scoreTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$MatchTableTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $MatchTableTable> {
|
|
$$MatchTableTableOrderingComposer({
|
|
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),
|
|
);
|
|
|
|
ColumnOrderings<String> get notes => $composableBuilder(
|
|
column: $table.notes,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
$$GameTableTableOrderingComposer get gameId {
|
|
final $$GameTableTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.gameId,
|
|
referencedTable: $db.gameTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$GameTableTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.gameTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$GroupTableTableOrderingComposer get groupId {
|
|
final $$GroupTableTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.groupId,
|
|
referencedTable: $db.groupTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$GroupTableTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.groupTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$MatchTableTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $MatchTableTable> {
|
|
$$MatchTableTableAnnotationComposer({
|
|
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);
|
|
|
|
GeneratedColumn<String> get notes =>
|
|
$composableBuilder(column: $table.notes, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
$$GameTableTableAnnotationComposer get gameId {
|
|
final $$GameTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.gameId,
|
|
referencedTable: $db.gameTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$GameTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.gameTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$GroupTableTableAnnotationComposer get groupId {
|
|
final $$GroupTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.groupId,
|
|
referencedTable: $db.groupTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$GroupTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.groupTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
Expression<T> playerMatchTableRefs<T extends Object>(
|
|
Expression<T> Function($$PlayerMatchTableTableAnnotationComposer a) f,
|
|
) {
|
|
final $$PlayerMatchTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.playerMatchTable,
|
|
getReferencedColumn: (t) => t.matchId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlayerMatchTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.playerMatchTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
|
|
Expression<T> scoreTableRefs<T extends Object>(
|
|
Expression<T> Function($$ScoreTableTableAnnotationComposer a) f,
|
|
) {
|
|
final $$ScoreTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.scoreTable,
|
|
getReferencedColumn: (t) => t.matchId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$ScoreTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.scoreTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$MatchTableTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$MatchTableTable,
|
|
MatchTableData,
|
|
$$MatchTableTableFilterComposer,
|
|
$$MatchTableTableOrderingComposer,
|
|
$$MatchTableTableAnnotationComposer,
|
|
$$MatchTableTableCreateCompanionBuilder,
|
|
$$MatchTableTableUpdateCompanionBuilder,
|
|
(MatchTableData, $$MatchTableTableReferences),
|
|
MatchTableData,
|
|
PrefetchHooks Function({
|
|
bool gameId,
|
|
bool groupId,
|
|
bool playerMatchTableRefs,
|
|
bool scoreTableRefs,
|
|
})
|
|
> {
|
|
$$MatchTableTableTableManager(_$AppDatabase db, $MatchTableTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$MatchTableTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$MatchTableTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$MatchTableTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> id = const Value.absent(),
|
|
Value<String> gameId = const Value.absent(),
|
|
Value<String?> groupId = const Value.absent(),
|
|
Value<String?> name = const Value.absent(),
|
|
Value<String?> notes = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => MatchTableCompanion(
|
|
id: id,
|
|
gameId: gameId,
|
|
groupId: groupId,
|
|
name: name,
|
|
notes: notes,
|
|
createdAt: createdAt,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String id,
|
|
required String gameId,
|
|
Value<String?> groupId = const Value.absent(),
|
|
Value<String?> name = const Value.absent(),
|
|
Value<String?> notes = const Value.absent(),
|
|
required DateTime createdAt,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => MatchTableCompanion.insert(
|
|
id: id,
|
|
gameId: gameId,
|
|
groupId: groupId,
|
|
name: name,
|
|
notes: notes,
|
|
createdAt: createdAt,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$MatchTableTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback:
|
|
({
|
|
gameId = false,
|
|
groupId = false,
|
|
playerMatchTableRefs = false,
|
|
scoreTableRefs = false,
|
|
}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [
|
|
if (playerMatchTableRefs) db.playerMatchTable,
|
|
if (scoreTableRefs) db.scoreTable,
|
|
],
|
|
addJoins:
|
|
<
|
|
T extends TableManagerState<
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic
|
|
>
|
|
>(state) {
|
|
if (gameId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.gameId,
|
|
referencedTable: $$MatchTableTableReferences
|
|
._gameIdTable(db),
|
|
referencedColumn:
|
|
$$MatchTableTableReferences
|
|
._gameIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
if (groupId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.groupId,
|
|
referencedTable: $$MatchTableTableReferences
|
|
._groupIdTable(db),
|
|
referencedColumn:
|
|
$$MatchTableTableReferences
|
|
._groupIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (playerMatchTableRefs)
|
|
await $_getPrefetchedData<
|
|
MatchTableData,
|
|
$MatchTableTable,
|
|
PlayerMatchTableData
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$MatchTableTableReferences
|
|
._playerMatchTableRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$MatchTableTableReferences(
|
|
db,
|
|
table,
|
|
p0,
|
|
).playerMatchTableRefs,
|
|
referencedItemsForCurrentItem:
|
|
(item, referencedItems) => referencedItems.where(
|
|
(e) => e.matchId == item.id,
|
|
),
|
|
typedResults: items,
|
|
),
|
|
if (scoreTableRefs)
|
|
await $_getPrefetchedData<
|
|
MatchTableData,
|
|
$MatchTableTable,
|
|
ScoreTableData
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$MatchTableTableReferences
|
|
._scoreTableRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$MatchTableTableReferences(
|
|
db,
|
|
table,
|
|
p0,
|
|
).scoreTableRefs,
|
|
referencedItemsForCurrentItem:
|
|
(item, referencedItems) => referencedItems.where(
|
|
(e) => e.matchId == item.id,
|
|
),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$MatchTableTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$MatchTableTable,
|
|
MatchTableData,
|
|
$$MatchTableTableFilterComposer,
|
|
$$MatchTableTableOrderingComposer,
|
|
$$MatchTableTableAnnotationComposer,
|
|
$$MatchTableTableCreateCompanionBuilder,
|
|
$$MatchTableTableUpdateCompanionBuilder,
|
|
(MatchTableData, $$MatchTableTableReferences),
|
|
MatchTableData,
|
|
PrefetchHooks Function({
|
|
bool gameId,
|
|
bool groupId,
|
|
bool playerMatchTableRefs,
|
|
bool scoreTableRefs,
|
|
})
|
|
>;
|
|
typedef $$PlayerGroupTableTableCreateCompanionBuilder =
|
|
PlayerGroupTableCompanion Function({
|
|
required String playerId,
|
|
required String groupId,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$PlayerGroupTableTableUpdateCompanionBuilder =
|
|
PlayerGroupTableCompanion Function({
|
|
Value<String> playerId,
|
|
Value<String> groupId,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$PlayerGroupTableTableReferences
|
|
extends
|
|
BaseReferences<
|
|
_$AppDatabase,
|
|
$PlayerGroupTableTable,
|
|
PlayerGroupTableData
|
|
> {
|
|
$$PlayerGroupTableTableReferences(
|
|
super.$_db,
|
|
super.$_table,
|
|
super.$_typedResult,
|
|
);
|
|
|
|
static $PlayerTableTable _playerIdTable(_$AppDatabase db) =>
|
|
db.playerTable.createAlias(
|
|
$_aliasNameGenerator(db.playerGroupTable.playerId, db.playerTable.id),
|
|
);
|
|
|
|
$$PlayerTableTableProcessedTableManager get playerId {
|
|
final $_column = $_itemColumn<String>('player_id')!;
|
|
|
|
final manager = $$PlayerTableTableTableManager(
|
|
$_db,
|
|
$_db.playerTable,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_playerIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
|
|
static $GroupTableTable _groupIdTable(_$AppDatabase db) =>
|
|
db.groupTable.createAlias(
|
|
$_aliasNameGenerator(db.playerGroupTable.groupId, db.groupTable.id),
|
|
);
|
|
|
|
$$GroupTableTableProcessedTableManager get groupId {
|
|
final $_column = $_itemColumn<String>('group_id')!;
|
|
|
|
final manager = $$GroupTableTableTableManager(
|
|
$_db,
|
|
$_db.groupTable,
|
|
).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 $$PlayerGroupTableTableFilterComposer
|
|
extends Composer<_$AppDatabase, $PlayerGroupTableTable> {
|
|
$$PlayerGroupTableTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
$$PlayerTableTableFilterComposer get playerId {
|
|
final $$PlayerTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.playerId,
|
|
referencedTable: $db.playerTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlayerTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.playerTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$GroupTableTableFilterComposer get groupId {
|
|
final $$GroupTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.groupId,
|
|
referencedTable: $db.groupTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$GroupTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.groupTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$PlayerGroupTableTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $PlayerGroupTableTable> {
|
|
$$PlayerGroupTableTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
$$PlayerTableTableOrderingComposer get playerId {
|
|
final $$PlayerTableTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.playerId,
|
|
referencedTable: $db.playerTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlayerTableTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.playerTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$GroupTableTableOrderingComposer get groupId {
|
|
final $$GroupTableTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.groupId,
|
|
referencedTable: $db.groupTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$GroupTableTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.groupTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$PlayerGroupTableTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $PlayerGroupTableTable> {
|
|
$$PlayerGroupTableTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
$$PlayerTableTableAnnotationComposer get playerId {
|
|
final $$PlayerTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.playerId,
|
|
referencedTable: $db.playerTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlayerTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.playerTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$GroupTableTableAnnotationComposer get groupId {
|
|
final $$GroupTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.groupId,
|
|
referencedTable: $db.groupTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$GroupTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.groupTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$PlayerGroupTableTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$PlayerGroupTableTable,
|
|
PlayerGroupTableData,
|
|
$$PlayerGroupTableTableFilterComposer,
|
|
$$PlayerGroupTableTableOrderingComposer,
|
|
$$PlayerGroupTableTableAnnotationComposer,
|
|
$$PlayerGroupTableTableCreateCompanionBuilder,
|
|
$$PlayerGroupTableTableUpdateCompanionBuilder,
|
|
(PlayerGroupTableData, $$PlayerGroupTableTableReferences),
|
|
PlayerGroupTableData,
|
|
PrefetchHooks Function({bool playerId, bool groupId})
|
|
> {
|
|
$$PlayerGroupTableTableTableManager(
|
|
_$AppDatabase db,
|
|
$PlayerGroupTableTable table,
|
|
) : super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$PlayerGroupTableTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$PlayerGroupTableTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$PlayerGroupTableTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> playerId = const Value.absent(),
|
|
Value<String> groupId = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => PlayerGroupTableCompanion(
|
|
playerId: playerId,
|
|
groupId: groupId,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String playerId,
|
|
required String groupId,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => PlayerGroupTableCompanion.insert(
|
|
playerId: playerId,
|
|
groupId: groupId,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$PlayerGroupTableTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({playerId = 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 (playerId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.playerId,
|
|
referencedTable:
|
|
$$PlayerGroupTableTableReferences
|
|
._playerIdTable(db),
|
|
referencedColumn:
|
|
$$PlayerGroupTableTableReferences
|
|
._playerIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
if (groupId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.groupId,
|
|
referencedTable:
|
|
$$PlayerGroupTableTableReferences
|
|
._groupIdTable(db),
|
|
referencedColumn:
|
|
$$PlayerGroupTableTableReferences
|
|
._groupIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$PlayerGroupTableTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$PlayerGroupTableTable,
|
|
PlayerGroupTableData,
|
|
$$PlayerGroupTableTableFilterComposer,
|
|
$$PlayerGroupTableTableOrderingComposer,
|
|
$$PlayerGroupTableTableAnnotationComposer,
|
|
$$PlayerGroupTableTableCreateCompanionBuilder,
|
|
$$PlayerGroupTableTableUpdateCompanionBuilder,
|
|
(PlayerGroupTableData, $$PlayerGroupTableTableReferences),
|
|
PlayerGroupTableData,
|
|
PrefetchHooks Function({bool playerId, bool groupId})
|
|
>;
|
|
typedef $$PlayerMatchTableTableCreateCompanionBuilder =
|
|
PlayerMatchTableCompanion Function({
|
|
required String playerId,
|
|
required String matchId,
|
|
Value<String?> teamId,
|
|
required int score,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$PlayerMatchTableTableUpdateCompanionBuilder =
|
|
PlayerMatchTableCompanion Function({
|
|
Value<String> playerId,
|
|
Value<String> matchId,
|
|
Value<String?> teamId,
|
|
Value<int> score,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$PlayerMatchTableTableReferences
|
|
extends
|
|
BaseReferences<
|
|
_$AppDatabase,
|
|
$PlayerMatchTableTable,
|
|
PlayerMatchTableData
|
|
> {
|
|
$$PlayerMatchTableTableReferences(
|
|
super.$_db,
|
|
super.$_table,
|
|
super.$_typedResult,
|
|
);
|
|
|
|
static $PlayerTableTable _playerIdTable(_$AppDatabase db) =>
|
|
db.playerTable.createAlias(
|
|
$_aliasNameGenerator(db.playerMatchTable.playerId, db.playerTable.id),
|
|
);
|
|
|
|
$$PlayerTableTableProcessedTableManager get playerId {
|
|
final $_column = $_itemColumn<String>('player_id')!;
|
|
|
|
final manager = $$PlayerTableTableTableManager(
|
|
$_db,
|
|
$_db.playerTable,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_playerIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
|
|
static $MatchTableTable _matchIdTable(_$AppDatabase db) =>
|
|
db.matchTable.createAlias(
|
|
$_aliasNameGenerator(db.playerMatchTable.matchId, db.matchTable.id),
|
|
);
|
|
|
|
$$MatchTableTableProcessedTableManager get matchId {
|
|
final $_column = $_itemColumn<String>('match_id')!;
|
|
|
|
final manager = $$MatchTableTableTableManager(
|
|
$_db,
|
|
$_db.matchTable,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_matchIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
|
|
static $TeamTableTable _teamIdTable(_$AppDatabase db) =>
|
|
db.teamTable.createAlias(
|
|
$_aliasNameGenerator(db.playerMatchTable.teamId, db.teamTable.id),
|
|
);
|
|
|
|
$$TeamTableTableProcessedTableManager? get teamId {
|
|
final $_column = $_itemColumn<String>('team_id');
|
|
if ($_column == null) return null;
|
|
final manager = $$TeamTableTableTableManager(
|
|
$_db,
|
|
$_db.teamTable,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_teamIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$PlayerMatchTableTableFilterComposer
|
|
extends Composer<_$AppDatabase, $PlayerMatchTableTable> {
|
|
$$PlayerMatchTableTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<int> get score => $composableBuilder(
|
|
column: $table.score,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
$$PlayerTableTableFilterComposer get playerId {
|
|
final $$PlayerTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.playerId,
|
|
referencedTable: $db.playerTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlayerTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.playerTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$MatchTableTableFilterComposer get matchId {
|
|
final $$MatchTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.matchId,
|
|
referencedTable: $db.matchTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$MatchTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.matchTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$TeamTableTableFilterComposer get teamId {
|
|
final $$TeamTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.teamId,
|
|
referencedTable: $db.teamTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TeamTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.teamTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$PlayerMatchTableTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $PlayerMatchTableTable> {
|
|
$$PlayerMatchTableTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<int> get score => $composableBuilder(
|
|
column: $table.score,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
$$PlayerTableTableOrderingComposer get playerId {
|
|
final $$PlayerTableTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.playerId,
|
|
referencedTable: $db.playerTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlayerTableTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.playerTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$MatchTableTableOrderingComposer get matchId {
|
|
final $$MatchTableTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.matchId,
|
|
referencedTable: $db.matchTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$MatchTableTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.matchTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$TeamTableTableOrderingComposer get teamId {
|
|
final $$TeamTableTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.teamId,
|
|
referencedTable: $db.teamTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TeamTableTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.teamTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$PlayerMatchTableTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $PlayerMatchTableTable> {
|
|
$$PlayerMatchTableTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<int> get score =>
|
|
$composableBuilder(column: $table.score, builder: (column) => column);
|
|
|
|
$$PlayerTableTableAnnotationComposer get playerId {
|
|
final $$PlayerTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.playerId,
|
|
referencedTable: $db.playerTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlayerTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.playerTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$MatchTableTableAnnotationComposer get matchId {
|
|
final $$MatchTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.matchId,
|
|
referencedTable: $db.matchTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$MatchTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.matchTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$TeamTableTableAnnotationComposer get teamId {
|
|
final $$TeamTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.teamId,
|
|
referencedTable: $db.teamTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TeamTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.teamTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$PlayerMatchTableTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$PlayerMatchTableTable,
|
|
PlayerMatchTableData,
|
|
$$PlayerMatchTableTableFilterComposer,
|
|
$$PlayerMatchTableTableOrderingComposer,
|
|
$$PlayerMatchTableTableAnnotationComposer,
|
|
$$PlayerMatchTableTableCreateCompanionBuilder,
|
|
$$PlayerMatchTableTableUpdateCompanionBuilder,
|
|
(PlayerMatchTableData, $$PlayerMatchTableTableReferences),
|
|
PlayerMatchTableData,
|
|
PrefetchHooks Function({bool playerId, bool matchId, bool teamId})
|
|
> {
|
|
$$PlayerMatchTableTableTableManager(
|
|
_$AppDatabase db,
|
|
$PlayerMatchTableTable table,
|
|
) : super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$PlayerMatchTableTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$PlayerMatchTableTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$PlayerMatchTableTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> playerId = const Value.absent(),
|
|
Value<String> matchId = const Value.absent(),
|
|
Value<String?> teamId = const Value.absent(),
|
|
Value<int> score = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => PlayerMatchTableCompanion(
|
|
playerId: playerId,
|
|
matchId: matchId,
|
|
teamId: teamId,
|
|
score: score,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String playerId,
|
|
required String matchId,
|
|
Value<String?> teamId = const Value.absent(),
|
|
required int score,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => PlayerMatchTableCompanion.insert(
|
|
playerId: playerId,
|
|
matchId: matchId,
|
|
teamId: teamId,
|
|
score: score,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$PlayerMatchTableTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback:
|
|
({playerId = false, matchId = false, teamId = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [],
|
|
addJoins:
|
|
<
|
|
T extends TableManagerState<
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic
|
|
>
|
|
>(state) {
|
|
if (playerId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.playerId,
|
|
referencedTable:
|
|
$$PlayerMatchTableTableReferences
|
|
._playerIdTable(db),
|
|
referencedColumn:
|
|
$$PlayerMatchTableTableReferences
|
|
._playerIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
if (matchId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.matchId,
|
|
referencedTable:
|
|
$$PlayerMatchTableTableReferences
|
|
._matchIdTable(db),
|
|
referencedColumn:
|
|
$$PlayerMatchTableTableReferences
|
|
._matchIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
if (teamId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.teamId,
|
|
referencedTable:
|
|
$$PlayerMatchTableTableReferences
|
|
._teamIdTable(db),
|
|
referencedColumn:
|
|
$$PlayerMatchTableTableReferences
|
|
._teamIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$PlayerMatchTableTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$PlayerMatchTableTable,
|
|
PlayerMatchTableData,
|
|
$$PlayerMatchTableTableFilterComposer,
|
|
$$PlayerMatchTableTableOrderingComposer,
|
|
$$PlayerMatchTableTableAnnotationComposer,
|
|
$$PlayerMatchTableTableCreateCompanionBuilder,
|
|
$$PlayerMatchTableTableUpdateCompanionBuilder,
|
|
(PlayerMatchTableData, $$PlayerMatchTableTableReferences),
|
|
PlayerMatchTableData,
|
|
PrefetchHooks Function({bool playerId, bool matchId, bool teamId})
|
|
>;
|
|
typedef $$ScoreTableTableCreateCompanionBuilder =
|
|
ScoreTableCompanion Function({
|
|
required String playerId,
|
|
required String matchId,
|
|
required int roundNumber,
|
|
required int score,
|
|
required int change,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$ScoreTableTableUpdateCompanionBuilder =
|
|
ScoreTableCompanion Function({
|
|
Value<String> playerId,
|
|
Value<String> matchId,
|
|
Value<int> roundNumber,
|
|
Value<int> score,
|
|
Value<int> change,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$ScoreTableTableReferences
|
|
extends BaseReferences<_$AppDatabase, $ScoreTableTable, ScoreTableData> {
|
|
$$ScoreTableTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static $PlayerTableTable _playerIdTable(_$AppDatabase db) =>
|
|
db.playerTable.createAlias(
|
|
$_aliasNameGenerator(db.scoreTable.playerId, db.playerTable.id),
|
|
);
|
|
|
|
$$PlayerTableTableProcessedTableManager get playerId {
|
|
final $_column = $_itemColumn<String>('player_id')!;
|
|
|
|
final manager = $$PlayerTableTableTableManager(
|
|
$_db,
|
|
$_db.playerTable,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_playerIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
|
|
static $MatchTableTable _matchIdTable(_$AppDatabase db) =>
|
|
db.matchTable.createAlias(
|
|
$_aliasNameGenerator(db.scoreTable.matchId, db.matchTable.id),
|
|
);
|
|
|
|
$$MatchTableTableProcessedTableManager get matchId {
|
|
final $_column = $_itemColumn<String>('match_id')!;
|
|
|
|
final manager = $$MatchTableTableTableManager(
|
|
$_db,
|
|
$_db.matchTable,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_matchIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$ScoreTableTableFilterComposer
|
|
extends Composer<_$AppDatabase, $ScoreTableTable> {
|
|
$$ScoreTableTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<int> get roundNumber => $composableBuilder(
|
|
column: $table.roundNumber,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get score => $composableBuilder(
|
|
column: $table.score,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get change => $composableBuilder(
|
|
column: $table.change,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
$$PlayerTableTableFilterComposer get playerId {
|
|
final $$PlayerTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.playerId,
|
|
referencedTable: $db.playerTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlayerTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.playerTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$MatchTableTableFilterComposer get matchId {
|
|
final $$MatchTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.matchId,
|
|
referencedTable: $db.matchTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$MatchTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.matchTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$ScoreTableTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $ScoreTableTable> {
|
|
$$ScoreTableTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<int> get roundNumber => $composableBuilder(
|
|
column: $table.roundNumber,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get score => $composableBuilder(
|
|
column: $table.score,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get change => $composableBuilder(
|
|
column: $table.change,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
$$PlayerTableTableOrderingComposer get playerId {
|
|
final $$PlayerTableTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.playerId,
|
|
referencedTable: $db.playerTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlayerTableTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.playerTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$MatchTableTableOrderingComposer get matchId {
|
|
final $$MatchTableTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.matchId,
|
|
referencedTable: $db.matchTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$MatchTableTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.matchTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$ScoreTableTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $ScoreTableTable> {
|
|
$$ScoreTableTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<int> get roundNumber => $composableBuilder(
|
|
column: $table.roundNumber,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<int> get score =>
|
|
$composableBuilder(column: $table.score, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get change =>
|
|
$composableBuilder(column: $table.change, builder: (column) => column);
|
|
|
|
$$PlayerTableTableAnnotationComposer get playerId {
|
|
final $$PlayerTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.playerId,
|
|
referencedTable: $db.playerTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlayerTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.playerTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$MatchTableTableAnnotationComposer get matchId {
|
|
final $$MatchTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.matchId,
|
|
referencedTable: $db.matchTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$MatchTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.matchTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$ScoreTableTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$ScoreTableTable,
|
|
ScoreTableData,
|
|
$$ScoreTableTableFilterComposer,
|
|
$$ScoreTableTableOrderingComposer,
|
|
$$ScoreTableTableAnnotationComposer,
|
|
$$ScoreTableTableCreateCompanionBuilder,
|
|
$$ScoreTableTableUpdateCompanionBuilder,
|
|
(ScoreTableData, $$ScoreTableTableReferences),
|
|
ScoreTableData,
|
|
PrefetchHooks Function({bool playerId, bool matchId})
|
|
> {
|
|
$$ScoreTableTableTableManager(_$AppDatabase db, $ScoreTableTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$ScoreTableTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$ScoreTableTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$ScoreTableTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> playerId = const Value.absent(),
|
|
Value<String> matchId = const Value.absent(),
|
|
Value<int> roundNumber = const Value.absent(),
|
|
Value<int> score = const Value.absent(),
|
|
Value<int> change = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => ScoreTableCompanion(
|
|
playerId: playerId,
|
|
matchId: matchId,
|
|
roundNumber: roundNumber,
|
|
score: score,
|
|
change: change,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String playerId,
|
|
required String matchId,
|
|
required int roundNumber,
|
|
required int score,
|
|
required int change,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => ScoreTableCompanion.insert(
|
|
playerId: playerId,
|
|
matchId: matchId,
|
|
roundNumber: roundNumber,
|
|
score: score,
|
|
change: change,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$ScoreTableTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({playerId = false, matchId = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [],
|
|
addJoins:
|
|
<
|
|
T extends TableManagerState<
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic
|
|
>
|
|
>(state) {
|
|
if (playerId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.playerId,
|
|
referencedTable: $$ScoreTableTableReferences
|
|
._playerIdTable(db),
|
|
referencedColumn: $$ScoreTableTableReferences
|
|
._playerIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
if (matchId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.matchId,
|
|
referencedTable: $$ScoreTableTableReferences
|
|
._matchIdTable(db),
|
|
referencedColumn: $$ScoreTableTableReferences
|
|
._matchIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$ScoreTableTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$ScoreTableTable,
|
|
ScoreTableData,
|
|
$$ScoreTableTableFilterComposer,
|
|
$$ScoreTableTableOrderingComposer,
|
|
$$ScoreTableTableAnnotationComposer,
|
|
$$ScoreTableTableCreateCompanionBuilder,
|
|
$$ScoreTableTableUpdateCompanionBuilder,
|
|
(ScoreTableData, $$ScoreTableTableReferences),
|
|
ScoreTableData,
|
|
PrefetchHooks Function({bool playerId, bool matchId})
|
|
>;
|
|
|
|
class $AppDatabaseManager {
|
|
final _$AppDatabase _db;
|
|
$AppDatabaseManager(this._db);
|
|
$$PlayerTableTableTableManager get playerTable =>
|
|
$$PlayerTableTableTableManager(_db, _db.playerTable);
|
|
$$GroupTableTableTableManager get groupTable =>
|
|
$$GroupTableTableTableManager(_db, _db.groupTable);
|
|
$$GameTableTableTableManager get gameTable =>
|
|
$$GameTableTableTableManager(_db, _db.gameTable);
|
|
$$TeamTableTableTableManager get teamTable =>
|
|
$$TeamTableTableTableManager(_db, _db.teamTable);
|
|
$$MatchTableTableTableManager get matchTable =>
|
|
$$MatchTableTableTableManager(_db, _db.matchTable);
|
|
$$PlayerGroupTableTableTableManager get playerGroupTable =>
|
|
$$PlayerGroupTableTableTableManager(_db, _db.playerGroupTable);
|
|
$$PlayerMatchTableTableTableManager get playerMatchTable =>
|
|
$$PlayerMatchTableTableTableManager(_db, _db.playerMatchTable);
|
|
$$ScoreTableTableTableManager get scoreTable =>
|
|
$$ScoreTableTableTableManager(_db, _db.scoreTable);
|
|
}
|