2788 lines
103 KiB
Dart
2788 lines
103 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'database.dart';
|
|
|
|
// ignore_for_file: type=lint
|
|
class $GameSessionTableTable extends GameSessionTable
|
|
with TableInfo<$GameSessionTableTable, GameSessionTableData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$GameSessionTableTable(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 _createdAtMeta =
|
|
const VerificationMeta('createdAt');
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at', aliasedName, false,
|
|
type: DriftSqlType.dateTime, requiredDuringInsert: true);
|
|
static const VerificationMeta _gameTitleMeta =
|
|
const VerificationMeta('gameTitle');
|
|
@override
|
|
late final GeneratedColumn<String> gameTitle = GeneratedColumn<String>(
|
|
'game_title', aliasedName, false,
|
|
type: DriftSqlType.string, requiredDuringInsert: true);
|
|
static const VerificationMeta _pointLimitMeta =
|
|
const VerificationMeta('pointLimit');
|
|
@override
|
|
late final GeneratedColumn<int> pointLimit = GeneratedColumn<int>(
|
|
'point_limit', aliasedName, false,
|
|
type: DriftSqlType.int, requiredDuringInsert: true);
|
|
static const VerificationMeta _caboPenaltyMeta =
|
|
const VerificationMeta('caboPenalty');
|
|
@override
|
|
late final GeneratedColumn<int> caboPenalty = GeneratedColumn<int>(
|
|
'cabo_penalty', aliasedName, false,
|
|
type: DriftSqlType.int, requiredDuringInsert: true);
|
|
static const VerificationMeta _isPointsLimitEnabledMeta =
|
|
const VerificationMeta('isPointsLimitEnabled');
|
|
@override
|
|
late final GeneratedColumn<bool> isPointsLimitEnabled = GeneratedColumn<bool>(
|
|
'is_points_limit_enabled', aliasedName, false,
|
|
type: DriftSqlType.bool,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'CHECK ("is_points_limit_enabled" IN (0, 1))'));
|
|
static const VerificationMeta _isGameFinishedMeta =
|
|
const VerificationMeta('isGameFinished');
|
|
@override
|
|
late final GeneratedColumn<bool> isGameFinished = GeneratedColumn<bool>(
|
|
'is_game_finished', aliasedName, false,
|
|
type: DriftSqlType.bool,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'CHECK ("is_game_finished" IN (0, 1))'));
|
|
static const VerificationMeta _winnerMeta = const VerificationMeta('winner');
|
|
@override
|
|
late final GeneratedColumn<String> winner = GeneratedColumn<String>(
|
|
'winner', aliasedName, true,
|
|
type: DriftSqlType.string, requiredDuringInsert: false);
|
|
static const VerificationMeta _roundNumberMeta =
|
|
const VerificationMeta('roundNumber');
|
|
@override
|
|
late final GeneratedColumn<int> roundNumber = GeneratedColumn<int>(
|
|
'round_number', aliasedName, false,
|
|
type: DriftSqlType.int, requiredDuringInsert: true);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
createdAt,
|
|
gameTitle,
|
|
pointLimit,
|
|
caboPenalty,
|
|
isPointsLimitEnabled,
|
|
isGameFinished,
|
|
winner,
|
|
roundNumber
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'game_session_table';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<GameSessionTableData> 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('created_at')) {
|
|
context.handle(_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_createdAtMeta);
|
|
}
|
|
if (data.containsKey('game_title')) {
|
|
context.handle(_gameTitleMeta,
|
|
gameTitle.isAcceptableOrUnknown(data['game_title']!, _gameTitleMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_gameTitleMeta);
|
|
}
|
|
if (data.containsKey('point_limit')) {
|
|
context.handle(
|
|
_pointLimitMeta,
|
|
pointLimit.isAcceptableOrUnknown(
|
|
data['point_limit']!, _pointLimitMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_pointLimitMeta);
|
|
}
|
|
if (data.containsKey('cabo_penalty')) {
|
|
context.handle(
|
|
_caboPenaltyMeta,
|
|
caboPenalty.isAcceptableOrUnknown(
|
|
data['cabo_penalty']!, _caboPenaltyMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_caboPenaltyMeta);
|
|
}
|
|
if (data.containsKey('is_points_limit_enabled')) {
|
|
context.handle(
|
|
_isPointsLimitEnabledMeta,
|
|
isPointsLimitEnabled.isAcceptableOrUnknown(
|
|
data['is_points_limit_enabled']!, _isPointsLimitEnabledMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_isPointsLimitEnabledMeta);
|
|
}
|
|
if (data.containsKey('is_game_finished')) {
|
|
context.handle(
|
|
_isGameFinishedMeta,
|
|
isGameFinished.isAcceptableOrUnknown(
|
|
data['is_game_finished']!, _isGameFinishedMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_isGameFinishedMeta);
|
|
}
|
|
if (data.containsKey('winner')) {
|
|
context.handle(_winnerMeta,
|
|
winner.isAcceptableOrUnknown(data['winner']!, _winnerMeta));
|
|
}
|
|
if (data.containsKey('round_number')) {
|
|
context.handle(
|
|
_roundNumberMeta,
|
|
roundNumber.isAcceptableOrUnknown(
|
|
data['round_number']!, _roundNumberMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_roundNumberMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
GameSessionTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return GameSessionTableData(
|
|
id: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}id'])!,
|
|
createdAt: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.dateTime, data['${effectivePrefix}created_at'])!,
|
|
gameTitle: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}game_title'])!,
|
|
pointLimit: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}point_limit'])!,
|
|
caboPenalty: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}cabo_penalty'])!,
|
|
isPointsLimitEnabled: attachedDatabase.typeMapping.read(DriftSqlType.bool,
|
|
data['${effectivePrefix}is_points_limit_enabled'])!,
|
|
isGameFinished: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.bool, data['${effectivePrefix}is_game_finished'])!,
|
|
winner: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}winner']),
|
|
roundNumber: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}round_number'])!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$GameSessionTableTable createAlias(String alias) {
|
|
return $GameSessionTableTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class GameSessionTableData extends DataClass
|
|
implements Insertable<GameSessionTableData> {
|
|
final String id;
|
|
final DateTime createdAt;
|
|
final String gameTitle;
|
|
final int pointLimit;
|
|
final int caboPenalty;
|
|
final bool isPointsLimitEnabled;
|
|
final bool isGameFinished;
|
|
final String? winner;
|
|
final int roundNumber;
|
|
const GameSessionTableData(
|
|
{required this.id,
|
|
required this.createdAt,
|
|
required this.gameTitle,
|
|
required this.pointLimit,
|
|
required this.caboPenalty,
|
|
required this.isPointsLimitEnabled,
|
|
required this.isGameFinished,
|
|
this.winner,
|
|
required this.roundNumber});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<String>(id);
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
map['game_title'] = Variable<String>(gameTitle);
|
|
map['point_limit'] = Variable<int>(pointLimit);
|
|
map['cabo_penalty'] = Variable<int>(caboPenalty);
|
|
map['is_points_limit_enabled'] = Variable<bool>(isPointsLimitEnabled);
|
|
map['is_game_finished'] = Variable<bool>(isGameFinished);
|
|
if (!nullToAbsent || winner != null) {
|
|
map['winner'] = Variable<String>(winner);
|
|
}
|
|
map['round_number'] = Variable<int>(roundNumber);
|
|
return map;
|
|
}
|
|
|
|
GameSessionTableCompanion toCompanion(bool nullToAbsent) {
|
|
return GameSessionTableCompanion(
|
|
id: Value(id),
|
|
createdAt: Value(createdAt),
|
|
gameTitle: Value(gameTitle),
|
|
pointLimit: Value(pointLimit),
|
|
caboPenalty: Value(caboPenalty),
|
|
isPointsLimitEnabled: Value(isPointsLimitEnabled),
|
|
isGameFinished: Value(isGameFinished),
|
|
winner:
|
|
winner == null && nullToAbsent ? const Value.absent() : Value(winner),
|
|
roundNumber: Value(roundNumber),
|
|
);
|
|
}
|
|
|
|
factory GameSessionTableData.fromJson(Map<String, dynamic> json,
|
|
{ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return GameSessionTableData(
|
|
id: serializer.fromJson<String>(json['id']),
|
|
createdAt: serializer.fromJson<DateTime>(json['createdAt']),
|
|
gameTitle: serializer.fromJson<String>(json['gameTitle']),
|
|
pointLimit: serializer.fromJson<int>(json['pointLimit']),
|
|
caboPenalty: serializer.fromJson<int>(json['caboPenalty']),
|
|
isPointsLimitEnabled:
|
|
serializer.fromJson<bool>(json['isPointsLimitEnabled']),
|
|
isGameFinished: serializer.fromJson<bool>(json['isGameFinished']),
|
|
winner: serializer.fromJson<String?>(json['winner']),
|
|
roundNumber: serializer.fromJson<int>(json['roundNumber']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<String>(id),
|
|
'createdAt': serializer.toJson<DateTime>(createdAt),
|
|
'gameTitle': serializer.toJson<String>(gameTitle),
|
|
'pointLimit': serializer.toJson<int>(pointLimit),
|
|
'caboPenalty': serializer.toJson<int>(caboPenalty),
|
|
'isPointsLimitEnabled': serializer.toJson<bool>(isPointsLimitEnabled),
|
|
'isGameFinished': serializer.toJson<bool>(isGameFinished),
|
|
'winner': serializer.toJson<String?>(winner),
|
|
'roundNumber': serializer.toJson<int>(roundNumber),
|
|
};
|
|
}
|
|
|
|
GameSessionTableData copyWith(
|
|
{String? id,
|
|
DateTime? createdAt,
|
|
String? gameTitle,
|
|
int? pointLimit,
|
|
int? caboPenalty,
|
|
bool? isPointsLimitEnabled,
|
|
bool? isGameFinished,
|
|
Value<String?> winner = const Value.absent(),
|
|
int? roundNumber}) =>
|
|
GameSessionTableData(
|
|
id: id ?? this.id,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
gameTitle: gameTitle ?? this.gameTitle,
|
|
pointLimit: pointLimit ?? this.pointLimit,
|
|
caboPenalty: caboPenalty ?? this.caboPenalty,
|
|
isPointsLimitEnabled: isPointsLimitEnabled ?? this.isPointsLimitEnabled,
|
|
isGameFinished: isGameFinished ?? this.isGameFinished,
|
|
winner: winner.present ? winner.value : this.winner,
|
|
roundNumber: roundNumber ?? this.roundNumber,
|
|
);
|
|
GameSessionTableData copyWithCompanion(GameSessionTableCompanion data) {
|
|
return GameSessionTableData(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
gameTitle: data.gameTitle.present ? data.gameTitle.value : this.gameTitle,
|
|
pointLimit:
|
|
data.pointLimit.present ? data.pointLimit.value : this.pointLimit,
|
|
caboPenalty:
|
|
data.caboPenalty.present ? data.caboPenalty.value : this.caboPenalty,
|
|
isPointsLimitEnabled: data.isPointsLimitEnabled.present
|
|
? data.isPointsLimitEnabled.value
|
|
: this.isPointsLimitEnabled,
|
|
isGameFinished: data.isGameFinished.present
|
|
? data.isGameFinished.value
|
|
: this.isGameFinished,
|
|
winner: data.winner.present ? data.winner.value : this.winner,
|
|
roundNumber:
|
|
data.roundNumber.present ? data.roundNumber.value : this.roundNumber,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('GameSessionTableData(')
|
|
..write('id: $id, ')
|
|
..write('createdAt: $createdAt, ')
|
|
..write('gameTitle: $gameTitle, ')
|
|
..write('pointLimit: $pointLimit, ')
|
|
..write('caboPenalty: $caboPenalty, ')
|
|
..write('isPointsLimitEnabled: $isPointsLimitEnabled, ')
|
|
..write('isGameFinished: $isGameFinished, ')
|
|
..write('winner: $winner, ')
|
|
..write('roundNumber: $roundNumber')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, createdAt, gameTitle, pointLimit,
|
|
caboPenalty, isPointsLimitEnabled, isGameFinished, winner, roundNumber);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is GameSessionTableData &&
|
|
other.id == this.id &&
|
|
other.createdAt == this.createdAt &&
|
|
other.gameTitle == this.gameTitle &&
|
|
other.pointLimit == this.pointLimit &&
|
|
other.caboPenalty == this.caboPenalty &&
|
|
other.isPointsLimitEnabled == this.isPointsLimitEnabled &&
|
|
other.isGameFinished == this.isGameFinished &&
|
|
other.winner == this.winner &&
|
|
other.roundNumber == this.roundNumber);
|
|
}
|
|
|
|
class GameSessionTableCompanion extends UpdateCompanion<GameSessionTableData> {
|
|
final Value<String> id;
|
|
final Value<DateTime> createdAt;
|
|
final Value<String> gameTitle;
|
|
final Value<int> pointLimit;
|
|
final Value<int> caboPenalty;
|
|
final Value<bool> isPointsLimitEnabled;
|
|
final Value<bool> isGameFinished;
|
|
final Value<String?> winner;
|
|
final Value<int> roundNumber;
|
|
final Value<int> rowid;
|
|
const GameSessionTableCompanion({
|
|
this.id = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
this.gameTitle = const Value.absent(),
|
|
this.pointLimit = const Value.absent(),
|
|
this.caboPenalty = const Value.absent(),
|
|
this.isPointsLimitEnabled = const Value.absent(),
|
|
this.isGameFinished = const Value.absent(),
|
|
this.winner = const Value.absent(),
|
|
this.roundNumber = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
GameSessionTableCompanion.insert({
|
|
required String id,
|
|
required DateTime createdAt,
|
|
required String gameTitle,
|
|
required int pointLimit,
|
|
required int caboPenalty,
|
|
required bool isPointsLimitEnabled,
|
|
required bool isGameFinished,
|
|
this.winner = const Value.absent(),
|
|
required int roundNumber,
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id),
|
|
createdAt = Value(createdAt),
|
|
gameTitle = Value(gameTitle),
|
|
pointLimit = Value(pointLimit),
|
|
caboPenalty = Value(caboPenalty),
|
|
isPointsLimitEnabled = Value(isPointsLimitEnabled),
|
|
isGameFinished = Value(isGameFinished),
|
|
roundNumber = Value(roundNumber);
|
|
static Insertable<GameSessionTableData> custom({
|
|
Expression<String>? id,
|
|
Expression<DateTime>? createdAt,
|
|
Expression<String>? gameTitle,
|
|
Expression<int>? pointLimit,
|
|
Expression<int>? caboPenalty,
|
|
Expression<bool>? isPointsLimitEnabled,
|
|
Expression<bool>? isGameFinished,
|
|
Expression<String>? winner,
|
|
Expression<int>? roundNumber,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
if (gameTitle != null) 'game_title': gameTitle,
|
|
if (pointLimit != null) 'point_limit': pointLimit,
|
|
if (caboPenalty != null) 'cabo_penalty': caboPenalty,
|
|
if (isPointsLimitEnabled != null)
|
|
'is_points_limit_enabled': isPointsLimitEnabled,
|
|
if (isGameFinished != null) 'is_game_finished': isGameFinished,
|
|
if (winner != null) 'winner': winner,
|
|
if (roundNumber != null) 'round_number': roundNumber,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
GameSessionTableCompanion copyWith(
|
|
{Value<String>? id,
|
|
Value<DateTime>? createdAt,
|
|
Value<String>? gameTitle,
|
|
Value<int>? pointLimit,
|
|
Value<int>? caboPenalty,
|
|
Value<bool>? isPointsLimitEnabled,
|
|
Value<bool>? isGameFinished,
|
|
Value<String?>? winner,
|
|
Value<int>? roundNumber,
|
|
Value<int>? rowid}) {
|
|
return GameSessionTableCompanion(
|
|
id: id ?? this.id,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
gameTitle: gameTitle ?? this.gameTitle,
|
|
pointLimit: pointLimit ?? this.pointLimit,
|
|
caboPenalty: caboPenalty ?? this.caboPenalty,
|
|
isPointsLimitEnabled: isPointsLimitEnabled ?? this.isPointsLimitEnabled,
|
|
isGameFinished: isGameFinished ?? this.isGameFinished,
|
|
winner: winner ?? this.winner,
|
|
roundNumber: roundNumber ?? this.roundNumber,
|
|
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 (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
if (gameTitle.present) {
|
|
map['game_title'] = Variable<String>(gameTitle.value);
|
|
}
|
|
if (pointLimit.present) {
|
|
map['point_limit'] = Variable<int>(pointLimit.value);
|
|
}
|
|
if (caboPenalty.present) {
|
|
map['cabo_penalty'] = Variable<int>(caboPenalty.value);
|
|
}
|
|
if (isPointsLimitEnabled.present) {
|
|
map['is_points_limit_enabled'] =
|
|
Variable<bool>(isPointsLimitEnabled.value);
|
|
}
|
|
if (isGameFinished.present) {
|
|
map['is_game_finished'] = Variable<bool>(isGameFinished.value);
|
|
}
|
|
if (winner.present) {
|
|
map['winner'] = Variable<String>(winner.value);
|
|
}
|
|
if (roundNumber.present) {
|
|
map['round_number'] = Variable<int>(roundNumber.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('GameSessionTableCompanion(')
|
|
..write('id: $id, ')
|
|
..write('createdAt: $createdAt, ')
|
|
..write('gameTitle: $gameTitle, ')
|
|
..write('pointLimit: $pointLimit, ')
|
|
..write('caboPenalty: $caboPenalty, ')
|
|
..write('isPointsLimitEnabled: $isPointsLimitEnabled, ')
|
|
..write('isGameFinished: $isGameFinished, ')
|
|
..write('winner: $winner, ')
|
|
..write('roundNumber: $roundNumber, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $PlayerTableTable extends PlayerTable
|
|
with TableInfo<$PlayerTableTable, PlayerTableData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$PlayerTableTable(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 game_session_table (id) ON DELETE CASCADE'));
|
|
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_session_table (id) ON DELETE CASCADE'));
|
|
static const VerificationMeta _totalScoreMeta =
|
|
const VerificationMeta('totalScore');
|
|
@override
|
|
late final GeneratedColumn<int> totalScore = GeneratedColumn<int>(
|
|
'total_score', aliasedName, false,
|
|
type: DriftSqlType.int, requiredDuringInsert: true);
|
|
static const VerificationMeta _positionMeta =
|
|
const VerificationMeta('position');
|
|
@override
|
|
late final GeneratedColumn<int> position = GeneratedColumn<int>(
|
|
'position', aliasedName, false,
|
|
type: DriftSqlType.int, requiredDuringInsert: true);
|
|
static const VerificationMeta _nameMeta = const VerificationMeta('name');
|
|
@override
|
|
late final GeneratedColumn<String> name = GeneratedColumn<String>(
|
|
'name', aliasedName, false,
|
|
type: DriftSqlType.string, requiredDuringInsert: true);
|
|
@override
|
|
List<GeneratedColumn> get $columns =>
|
|
[playerId, gameId, totalScore, position, name];
|
|
@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('player_id')) {
|
|
context.handle(_playerIdMeta,
|
|
playerId.isAcceptableOrUnknown(data['player_id']!, _playerIdMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_playerIdMeta);
|
|
}
|
|
if (data.containsKey('game_id')) {
|
|
context.handle(_gameIdMeta,
|
|
gameId.isAcceptableOrUnknown(data['game_id']!, _gameIdMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_gameIdMeta);
|
|
}
|
|
if (data.containsKey('total_score')) {
|
|
context.handle(
|
|
_totalScoreMeta,
|
|
totalScore.isAcceptableOrUnknown(
|
|
data['total_score']!, _totalScoreMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_totalScoreMeta);
|
|
}
|
|
if (data.containsKey('position')) {
|
|
context.handle(_positionMeta,
|
|
position.isAcceptableOrUnknown(data['position']!, _positionMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_positionMeta);
|
|
}
|
|
if (data.containsKey('name')) {
|
|
context.handle(
|
|
_nameMeta, name.isAcceptableOrUnknown(data['name']!, _nameMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_nameMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => const {};
|
|
@override
|
|
PlayerTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return PlayerTableData(
|
|
playerId: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}player_id'])!,
|
|
gameId: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}game_id'])!,
|
|
totalScore: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}total_score'])!,
|
|
position: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}position'])!,
|
|
name: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}name'])!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$PlayerTableTable createAlias(String alias) {
|
|
return $PlayerTableTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class PlayerTableData extends DataClass implements Insertable<PlayerTableData> {
|
|
final String playerId;
|
|
final String gameId;
|
|
final int totalScore;
|
|
final int position;
|
|
final String name;
|
|
const PlayerTableData(
|
|
{required this.playerId,
|
|
required this.gameId,
|
|
required this.totalScore,
|
|
required this.position,
|
|
required this.name});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['player_id'] = Variable<String>(playerId);
|
|
map['game_id'] = Variable<String>(gameId);
|
|
map['total_score'] = Variable<int>(totalScore);
|
|
map['position'] = Variable<int>(position);
|
|
map['name'] = Variable<String>(name);
|
|
return map;
|
|
}
|
|
|
|
PlayerTableCompanion toCompanion(bool nullToAbsent) {
|
|
return PlayerTableCompanion(
|
|
playerId: Value(playerId),
|
|
gameId: Value(gameId),
|
|
totalScore: Value(totalScore),
|
|
position: Value(position),
|
|
name: Value(name),
|
|
);
|
|
}
|
|
|
|
factory PlayerTableData.fromJson(Map<String, dynamic> json,
|
|
{ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return PlayerTableData(
|
|
playerId: serializer.fromJson<String>(json['playerId']),
|
|
gameId: serializer.fromJson<String>(json['gameId']),
|
|
totalScore: serializer.fromJson<int>(json['totalScore']),
|
|
position: serializer.fromJson<int>(json['position']),
|
|
name: serializer.fromJson<String>(json['name']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'playerId': serializer.toJson<String>(playerId),
|
|
'gameId': serializer.toJson<String>(gameId),
|
|
'totalScore': serializer.toJson<int>(totalScore),
|
|
'position': serializer.toJson<int>(position),
|
|
'name': serializer.toJson<String>(name),
|
|
};
|
|
}
|
|
|
|
PlayerTableData copyWith(
|
|
{String? playerId,
|
|
String? gameId,
|
|
int? totalScore,
|
|
int? position,
|
|
String? name}) =>
|
|
PlayerTableData(
|
|
playerId: playerId ?? this.playerId,
|
|
gameId: gameId ?? this.gameId,
|
|
totalScore: totalScore ?? this.totalScore,
|
|
position: position ?? this.position,
|
|
name: name ?? this.name,
|
|
);
|
|
PlayerTableData copyWithCompanion(PlayerTableCompanion data) {
|
|
return PlayerTableData(
|
|
playerId: data.playerId.present ? data.playerId.value : this.playerId,
|
|
gameId: data.gameId.present ? data.gameId.value : this.gameId,
|
|
totalScore:
|
|
data.totalScore.present ? data.totalScore.value : this.totalScore,
|
|
position: data.position.present ? data.position.value : this.position,
|
|
name: data.name.present ? data.name.value : this.name,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('PlayerTableData(')
|
|
..write('playerId: $playerId, ')
|
|
..write('gameId: $gameId, ')
|
|
..write('totalScore: $totalScore, ')
|
|
..write('position: $position, ')
|
|
..write('name: $name')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(playerId, gameId, totalScore, position, name);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is PlayerTableData &&
|
|
other.playerId == this.playerId &&
|
|
other.gameId == this.gameId &&
|
|
other.totalScore == this.totalScore &&
|
|
other.position == this.position &&
|
|
other.name == this.name);
|
|
}
|
|
|
|
class PlayerTableCompanion extends UpdateCompanion<PlayerTableData> {
|
|
final Value<String> playerId;
|
|
final Value<String> gameId;
|
|
final Value<int> totalScore;
|
|
final Value<int> position;
|
|
final Value<String> name;
|
|
final Value<int> rowid;
|
|
const PlayerTableCompanion({
|
|
this.playerId = const Value.absent(),
|
|
this.gameId = const Value.absent(),
|
|
this.totalScore = const Value.absent(),
|
|
this.position = const Value.absent(),
|
|
this.name = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
PlayerTableCompanion.insert({
|
|
required String playerId,
|
|
required String gameId,
|
|
required int totalScore,
|
|
required int position,
|
|
required String name,
|
|
this.rowid = const Value.absent(),
|
|
}) : playerId = Value(playerId),
|
|
gameId = Value(gameId),
|
|
totalScore = Value(totalScore),
|
|
position = Value(position),
|
|
name = Value(name);
|
|
static Insertable<PlayerTableData> custom({
|
|
Expression<String>? playerId,
|
|
Expression<String>? gameId,
|
|
Expression<int>? totalScore,
|
|
Expression<int>? position,
|
|
Expression<String>? name,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (playerId != null) 'player_id': playerId,
|
|
if (gameId != null) 'game_id': gameId,
|
|
if (totalScore != null) 'total_score': totalScore,
|
|
if (position != null) 'position': position,
|
|
if (name != null) 'name': name,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
PlayerTableCompanion copyWith(
|
|
{Value<String>? playerId,
|
|
Value<String>? gameId,
|
|
Value<int>? totalScore,
|
|
Value<int>? position,
|
|
Value<String>? name,
|
|
Value<int>? rowid}) {
|
|
return PlayerTableCompanion(
|
|
playerId: playerId ?? this.playerId,
|
|
gameId: gameId ?? this.gameId,
|
|
totalScore: totalScore ?? this.totalScore,
|
|
position: position ?? this.position,
|
|
name: name ?? this.name,
|
|
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 (gameId.present) {
|
|
map['game_id'] = Variable<String>(gameId.value);
|
|
}
|
|
if (totalScore.present) {
|
|
map['total_score'] = Variable<int>(totalScore.value);
|
|
}
|
|
if (position.present) {
|
|
map['position'] = Variable<int>(position.value);
|
|
}
|
|
if (name.present) {
|
|
map['name'] = Variable<String>(name.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('PlayerTableCompanion(')
|
|
..write('playerId: $playerId, ')
|
|
..write('gameId: $gameId, ')
|
|
..write('totalScore: $totalScore, ')
|
|
..write('position: $position, ')
|
|
..write('name: $name, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $RoundsTableTable extends RoundsTable
|
|
with TableInfo<$RoundsTableTable, RoundsTableData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$RoundsTableTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _roundIdMeta =
|
|
const VerificationMeta('roundId');
|
|
@override
|
|
late final GeneratedColumn<String> roundId = GeneratedColumn<String>(
|
|
'round_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_session_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 _caboPlayerIndexMeta =
|
|
const VerificationMeta('caboPlayerIndex');
|
|
@override
|
|
late final GeneratedColumn<int> caboPlayerIndex = GeneratedColumn<int>(
|
|
'cabo_player_index', aliasedName, false,
|
|
type: DriftSqlType.int, requiredDuringInsert: true);
|
|
static const VerificationMeta _kamikazePlayerIndexMeta =
|
|
const VerificationMeta('kamikazePlayerIndex');
|
|
@override
|
|
late final GeneratedColumn<int> kamikazePlayerIndex = GeneratedColumn<int>(
|
|
'kamikaze_player_index', aliasedName, true,
|
|
type: DriftSqlType.int, requiredDuringInsert: false);
|
|
@override
|
|
List<GeneratedColumn> get $columns =>
|
|
[roundId, gameId, roundNumber, caboPlayerIndex, kamikazePlayerIndex];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'rounds_table';
|
|
@override
|
|
VerificationContext validateIntegrity(Insertable<RoundsTableData> instance,
|
|
{bool isInserting = false}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('round_id')) {
|
|
context.handle(_roundIdMeta,
|
|
roundId.isAcceptableOrUnknown(data['round_id']!, _roundIdMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_roundIdMeta);
|
|
}
|
|
if (data.containsKey('game_id')) {
|
|
context.handle(_gameIdMeta,
|
|
gameId.isAcceptableOrUnknown(data['game_id']!, _gameIdMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_gameIdMeta);
|
|
}
|
|
if (data.containsKey('round_number')) {
|
|
context.handle(
|
|
_roundNumberMeta,
|
|
roundNumber.isAcceptableOrUnknown(
|
|
data['round_number']!, _roundNumberMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_roundNumberMeta);
|
|
}
|
|
if (data.containsKey('cabo_player_index')) {
|
|
context.handle(
|
|
_caboPlayerIndexMeta,
|
|
caboPlayerIndex.isAcceptableOrUnknown(
|
|
data['cabo_player_index']!, _caboPlayerIndexMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_caboPlayerIndexMeta);
|
|
}
|
|
if (data.containsKey('kamikaze_player_index')) {
|
|
context.handle(
|
|
_kamikazePlayerIndexMeta,
|
|
kamikazePlayerIndex.isAcceptableOrUnknown(
|
|
data['kamikaze_player_index']!, _kamikazePlayerIndexMeta));
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {roundId};
|
|
@override
|
|
RoundsTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return RoundsTableData(
|
|
roundId: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}round_id'])!,
|
|
gameId: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}game_id'])!,
|
|
roundNumber: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}round_number'])!,
|
|
caboPlayerIndex: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}cabo_player_index'])!,
|
|
kamikazePlayerIndex: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int, data['${effectivePrefix}kamikaze_player_index']),
|
|
);
|
|
}
|
|
|
|
@override
|
|
$RoundsTableTable createAlias(String alias) {
|
|
return $RoundsTableTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class RoundsTableData extends DataClass implements Insertable<RoundsTableData> {
|
|
final String roundId;
|
|
final String gameId;
|
|
final int roundNumber;
|
|
final int caboPlayerIndex;
|
|
final int? kamikazePlayerIndex;
|
|
const RoundsTableData(
|
|
{required this.roundId,
|
|
required this.gameId,
|
|
required this.roundNumber,
|
|
required this.caboPlayerIndex,
|
|
this.kamikazePlayerIndex});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['round_id'] = Variable<String>(roundId);
|
|
map['game_id'] = Variable<String>(gameId);
|
|
map['round_number'] = Variable<int>(roundNumber);
|
|
map['cabo_player_index'] = Variable<int>(caboPlayerIndex);
|
|
if (!nullToAbsent || kamikazePlayerIndex != null) {
|
|
map['kamikaze_player_index'] = Variable<int>(kamikazePlayerIndex);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
RoundsTableCompanion toCompanion(bool nullToAbsent) {
|
|
return RoundsTableCompanion(
|
|
roundId: Value(roundId),
|
|
gameId: Value(gameId),
|
|
roundNumber: Value(roundNumber),
|
|
caboPlayerIndex: Value(caboPlayerIndex),
|
|
kamikazePlayerIndex: kamikazePlayerIndex == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(kamikazePlayerIndex),
|
|
);
|
|
}
|
|
|
|
factory RoundsTableData.fromJson(Map<String, dynamic> json,
|
|
{ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return RoundsTableData(
|
|
roundId: serializer.fromJson<String>(json['roundId']),
|
|
gameId: serializer.fromJson<String>(json['gameId']),
|
|
roundNumber: serializer.fromJson<int>(json['roundNumber']),
|
|
caboPlayerIndex: serializer.fromJson<int>(json['caboPlayerIndex']),
|
|
kamikazePlayerIndex:
|
|
serializer.fromJson<int?>(json['kamikazePlayerIndex']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'roundId': serializer.toJson<String>(roundId),
|
|
'gameId': serializer.toJson<String>(gameId),
|
|
'roundNumber': serializer.toJson<int>(roundNumber),
|
|
'caboPlayerIndex': serializer.toJson<int>(caboPlayerIndex),
|
|
'kamikazePlayerIndex': serializer.toJson<int?>(kamikazePlayerIndex),
|
|
};
|
|
}
|
|
|
|
RoundsTableData copyWith(
|
|
{String? roundId,
|
|
String? gameId,
|
|
int? roundNumber,
|
|
int? caboPlayerIndex,
|
|
Value<int?> kamikazePlayerIndex = const Value.absent()}) =>
|
|
RoundsTableData(
|
|
roundId: roundId ?? this.roundId,
|
|
gameId: gameId ?? this.gameId,
|
|
roundNumber: roundNumber ?? this.roundNumber,
|
|
caboPlayerIndex: caboPlayerIndex ?? this.caboPlayerIndex,
|
|
kamikazePlayerIndex: kamikazePlayerIndex.present
|
|
? kamikazePlayerIndex.value
|
|
: this.kamikazePlayerIndex,
|
|
);
|
|
RoundsTableData copyWithCompanion(RoundsTableCompanion data) {
|
|
return RoundsTableData(
|
|
roundId: data.roundId.present ? data.roundId.value : this.roundId,
|
|
gameId: data.gameId.present ? data.gameId.value : this.gameId,
|
|
roundNumber:
|
|
data.roundNumber.present ? data.roundNumber.value : this.roundNumber,
|
|
caboPlayerIndex: data.caboPlayerIndex.present
|
|
? data.caboPlayerIndex.value
|
|
: this.caboPlayerIndex,
|
|
kamikazePlayerIndex: data.kamikazePlayerIndex.present
|
|
? data.kamikazePlayerIndex.value
|
|
: this.kamikazePlayerIndex,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('RoundsTableData(')
|
|
..write('roundId: $roundId, ')
|
|
..write('gameId: $gameId, ')
|
|
..write('roundNumber: $roundNumber, ')
|
|
..write('caboPlayerIndex: $caboPlayerIndex, ')
|
|
..write('kamikazePlayerIndex: $kamikazePlayerIndex')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(
|
|
roundId, gameId, roundNumber, caboPlayerIndex, kamikazePlayerIndex);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is RoundsTableData &&
|
|
other.roundId == this.roundId &&
|
|
other.gameId == this.gameId &&
|
|
other.roundNumber == this.roundNumber &&
|
|
other.caboPlayerIndex == this.caboPlayerIndex &&
|
|
other.kamikazePlayerIndex == this.kamikazePlayerIndex);
|
|
}
|
|
|
|
class RoundsTableCompanion extends UpdateCompanion<RoundsTableData> {
|
|
final Value<String> roundId;
|
|
final Value<String> gameId;
|
|
final Value<int> roundNumber;
|
|
final Value<int> caboPlayerIndex;
|
|
final Value<int?> kamikazePlayerIndex;
|
|
final Value<int> rowid;
|
|
const RoundsTableCompanion({
|
|
this.roundId = const Value.absent(),
|
|
this.gameId = const Value.absent(),
|
|
this.roundNumber = const Value.absent(),
|
|
this.caboPlayerIndex = const Value.absent(),
|
|
this.kamikazePlayerIndex = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
RoundsTableCompanion.insert({
|
|
required String roundId,
|
|
required String gameId,
|
|
required int roundNumber,
|
|
required int caboPlayerIndex,
|
|
this.kamikazePlayerIndex = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
}) : roundId = Value(roundId),
|
|
gameId = Value(gameId),
|
|
roundNumber = Value(roundNumber),
|
|
caboPlayerIndex = Value(caboPlayerIndex);
|
|
static Insertable<RoundsTableData> custom({
|
|
Expression<String>? roundId,
|
|
Expression<String>? gameId,
|
|
Expression<int>? roundNumber,
|
|
Expression<int>? caboPlayerIndex,
|
|
Expression<int>? kamikazePlayerIndex,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (roundId != null) 'round_id': roundId,
|
|
if (gameId != null) 'game_id': gameId,
|
|
if (roundNumber != null) 'round_number': roundNumber,
|
|
if (caboPlayerIndex != null) 'cabo_player_index': caboPlayerIndex,
|
|
if (kamikazePlayerIndex != null)
|
|
'kamikaze_player_index': kamikazePlayerIndex,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
RoundsTableCompanion copyWith(
|
|
{Value<String>? roundId,
|
|
Value<String>? gameId,
|
|
Value<int>? roundNumber,
|
|
Value<int>? caboPlayerIndex,
|
|
Value<int?>? kamikazePlayerIndex,
|
|
Value<int>? rowid}) {
|
|
return RoundsTableCompanion(
|
|
roundId: roundId ?? this.roundId,
|
|
gameId: gameId ?? this.gameId,
|
|
roundNumber: roundNumber ?? this.roundNumber,
|
|
caboPlayerIndex: caboPlayerIndex ?? this.caboPlayerIndex,
|
|
kamikazePlayerIndex: kamikazePlayerIndex ?? this.kamikazePlayerIndex,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (roundId.present) {
|
|
map['round_id'] = Variable<String>(roundId.value);
|
|
}
|
|
if (gameId.present) {
|
|
map['game_id'] = Variable<String>(gameId.value);
|
|
}
|
|
if (roundNumber.present) {
|
|
map['round_number'] = Variable<int>(roundNumber.value);
|
|
}
|
|
if (caboPlayerIndex.present) {
|
|
map['cabo_player_index'] = Variable<int>(caboPlayerIndex.value);
|
|
}
|
|
if (kamikazePlayerIndex.present) {
|
|
map['kamikaze_player_index'] = Variable<int>(kamikazePlayerIndex.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('RoundsTableCompanion(')
|
|
..write('roundId: $roundId, ')
|
|
..write('gameId: $gameId, ')
|
|
..write('roundNumber: $roundNumber, ')
|
|
..write('caboPlayerIndex: $caboPlayerIndex, ')
|
|
..write('kamikazePlayerIndex: $kamikazePlayerIndex, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $RoundScoresTableTable extends RoundScoresTable
|
|
with TableInfo<$RoundScoresTableTable, RoundScoresTableData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$RoundScoresTableTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _roundIdMeta =
|
|
const VerificationMeta('roundId');
|
|
@override
|
|
late final GeneratedColumn<String> roundId = GeneratedColumn<String>(
|
|
'round_id', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES rounds_table (round_id) ON DELETE CASCADE'));
|
|
static const VerificationMeta _playerIdMeta =
|
|
const VerificationMeta('playerId');
|
|
@override
|
|
late final GeneratedColumn<String> playerId = GeneratedColumn<String>(
|
|
'player_id', aliasedName, false,
|
|
type: DriftSqlType.string, 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 _scoreUpdateMeta =
|
|
const VerificationMeta('scoreUpdate');
|
|
@override
|
|
late final GeneratedColumn<int> scoreUpdate = GeneratedColumn<int>(
|
|
'score_update', aliasedName, false,
|
|
type: DriftSqlType.int, requiredDuringInsert: true);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [roundId, playerId, score, scoreUpdate];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'round_scores_table';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<RoundScoresTableData> instance,
|
|
{bool isInserting = false}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('round_id')) {
|
|
context.handle(_roundIdMeta,
|
|
roundId.isAcceptableOrUnknown(data['round_id']!, _roundIdMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_roundIdMeta);
|
|
}
|
|
if (data.containsKey('player_id')) {
|
|
context.handle(_playerIdMeta,
|
|
playerId.isAcceptableOrUnknown(data['player_id']!, _playerIdMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_playerIdMeta);
|
|
}
|
|
if (data.containsKey('score')) {
|
|
context.handle(
|
|
_scoreMeta, score.isAcceptableOrUnknown(data['score']!, _scoreMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_scoreMeta);
|
|
}
|
|
if (data.containsKey('score_update')) {
|
|
context.handle(
|
|
_scoreUpdateMeta,
|
|
scoreUpdate.isAcceptableOrUnknown(
|
|
data['score_update']!, _scoreUpdateMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_scoreUpdateMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {roundId, playerId};
|
|
@override
|
|
RoundScoresTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return RoundScoresTableData(
|
|
roundId: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}round_id'])!,
|
|
playerId: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}player_id'])!,
|
|
score: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}score'])!,
|
|
scoreUpdate: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}score_update'])!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$RoundScoresTableTable createAlias(String alias) {
|
|
return $RoundScoresTableTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class RoundScoresTableData extends DataClass
|
|
implements Insertable<RoundScoresTableData> {
|
|
final String roundId;
|
|
final String playerId;
|
|
final int score;
|
|
final int scoreUpdate;
|
|
const RoundScoresTableData(
|
|
{required this.roundId,
|
|
required this.playerId,
|
|
required this.score,
|
|
required this.scoreUpdate});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['round_id'] = Variable<String>(roundId);
|
|
map['player_id'] = Variable<String>(playerId);
|
|
map['score'] = Variable<int>(score);
|
|
map['score_update'] = Variable<int>(scoreUpdate);
|
|
return map;
|
|
}
|
|
|
|
RoundScoresTableCompanion toCompanion(bool nullToAbsent) {
|
|
return RoundScoresTableCompanion(
|
|
roundId: Value(roundId),
|
|
playerId: Value(playerId),
|
|
score: Value(score),
|
|
scoreUpdate: Value(scoreUpdate),
|
|
);
|
|
}
|
|
|
|
factory RoundScoresTableData.fromJson(Map<String, dynamic> json,
|
|
{ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return RoundScoresTableData(
|
|
roundId: serializer.fromJson<String>(json['roundId']),
|
|
playerId: serializer.fromJson<String>(json['playerId']),
|
|
score: serializer.fromJson<int>(json['score']),
|
|
scoreUpdate: serializer.fromJson<int>(json['scoreUpdate']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'roundId': serializer.toJson<String>(roundId),
|
|
'playerId': serializer.toJson<String>(playerId),
|
|
'score': serializer.toJson<int>(score),
|
|
'scoreUpdate': serializer.toJson<int>(scoreUpdate),
|
|
};
|
|
}
|
|
|
|
RoundScoresTableData copyWith(
|
|
{String? roundId, String? playerId, int? score, int? scoreUpdate}) =>
|
|
RoundScoresTableData(
|
|
roundId: roundId ?? this.roundId,
|
|
playerId: playerId ?? this.playerId,
|
|
score: score ?? this.score,
|
|
scoreUpdate: scoreUpdate ?? this.scoreUpdate,
|
|
);
|
|
RoundScoresTableData copyWithCompanion(RoundScoresTableCompanion data) {
|
|
return RoundScoresTableData(
|
|
roundId: data.roundId.present ? data.roundId.value : this.roundId,
|
|
playerId: data.playerId.present ? data.playerId.value : this.playerId,
|
|
score: data.score.present ? data.score.value : this.score,
|
|
scoreUpdate:
|
|
data.scoreUpdate.present ? data.scoreUpdate.value : this.scoreUpdate,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('RoundScoresTableData(')
|
|
..write('roundId: $roundId, ')
|
|
..write('playerId: $playerId, ')
|
|
..write('score: $score, ')
|
|
..write('scoreUpdate: $scoreUpdate')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(roundId, playerId, score, scoreUpdate);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is RoundScoresTableData &&
|
|
other.roundId == this.roundId &&
|
|
other.playerId == this.playerId &&
|
|
other.score == this.score &&
|
|
other.scoreUpdate == this.scoreUpdate);
|
|
}
|
|
|
|
class RoundScoresTableCompanion extends UpdateCompanion<RoundScoresTableData> {
|
|
final Value<String> roundId;
|
|
final Value<String> playerId;
|
|
final Value<int> score;
|
|
final Value<int> scoreUpdate;
|
|
final Value<int> rowid;
|
|
const RoundScoresTableCompanion({
|
|
this.roundId = const Value.absent(),
|
|
this.playerId = const Value.absent(),
|
|
this.score = const Value.absent(),
|
|
this.scoreUpdate = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
RoundScoresTableCompanion.insert({
|
|
required String roundId,
|
|
required String playerId,
|
|
required int score,
|
|
required int scoreUpdate,
|
|
this.rowid = const Value.absent(),
|
|
}) : roundId = Value(roundId),
|
|
playerId = Value(playerId),
|
|
score = Value(score),
|
|
scoreUpdate = Value(scoreUpdate);
|
|
static Insertable<RoundScoresTableData> custom({
|
|
Expression<String>? roundId,
|
|
Expression<String>? playerId,
|
|
Expression<int>? score,
|
|
Expression<int>? scoreUpdate,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (roundId != null) 'round_id': roundId,
|
|
if (playerId != null) 'player_id': playerId,
|
|
if (score != null) 'score': score,
|
|
if (scoreUpdate != null) 'score_update': scoreUpdate,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
RoundScoresTableCompanion copyWith(
|
|
{Value<String>? roundId,
|
|
Value<String>? playerId,
|
|
Value<int>? score,
|
|
Value<int>? scoreUpdate,
|
|
Value<int>? rowid}) {
|
|
return RoundScoresTableCompanion(
|
|
roundId: roundId ?? this.roundId,
|
|
playerId: playerId ?? this.playerId,
|
|
score: score ?? this.score,
|
|
scoreUpdate: scoreUpdate ?? this.scoreUpdate,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (roundId.present) {
|
|
map['round_id'] = Variable<String>(roundId.value);
|
|
}
|
|
if (playerId.present) {
|
|
map['player_id'] = Variable<String>(playerId.value);
|
|
}
|
|
if (score.present) {
|
|
map['score'] = Variable<int>(score.value);
|
|
}
|
|
if (scoreUpdate.present) {
|
|
map['score_update'] = Variable<int>(scoreUpdate.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('RoundScoresTableCompanion(')
|
|
..write('roundId: $roundId, ')
|
|
..write('playerId: $playerId, ')
|
|
..write('score: $score, ')
|
|
..write('scoreUpdate: $scoreUpdate, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
abstract class _$AppDatabase extends GeneratedDatabase {
|
|
_$AppDatabase(QueryExecutor e) : super(e);
|
|
$AppDatabaseManager get managers => $AppDatabaseManager(this);
|
|
late final $GameSessionTableTable gameSessionTable =
|
|
$GameSessionTableTable(this);
|
|
late final $PlayerTableTable playerTable = $PlayerTableTable(this);
|
|
late final $RoundsTableTable roundsTable = $RoundsTableTable(this);
|
|
late final $RoundScoresTableTable roundScoresTable =
|
|
$RoundScoresTableTable(this);
|
|
late final GameSessionDao gameSessionDao =
|
|
GameSessionDao(this as AppDatabase);
|
|
late final PlayerDao playerDao = PlayerDao(this as AppDatabase);
|
|
late final RoundsDao roundsDao = RoundsDao(this as AppDatabase);
|
|
late final RoundScoresDao roundScoresDao =
|
|
RoundScoresDao(this as AppDatabase);
|
|
@override
|
|
Iterable<TableInfo<Table, Object?>> get allTables =>
|
|
allSchemaEntities.whereType<TableInfo<Table, Object?>>();
|
|
@override
|
|
List<DatabaseSchemaEntity> get allSchemaEntities =>
|
|
[gameSessionTable, playerTable, roundsTable, roundScoresTable];
|
|
@override
|
|
StreamQueryUpdateRules get streamUpdateRules => const StreamQueryUpdateRules(
|
|
[
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName('game_session_table',
|
|
limitUpdateKind: UpdateKind.delete),
|
|
result: [
|
|
TableUpdate('player_table', kind: UpdateKind.delete),
|
|
],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName('game_session_table',
|
|
limitUpdateKind: UpdateKind.delete),
|
|
result: [
|
|
TableUpdate('player_table', kind: UpdateKind.delete),
|
|
],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName('game_session_table',
|
|
limitUpdateKind: UpdateKind.delete),
|
|
result: [
|
|
TableUpdate('rounds_table', kind: UpdateKind.delete),
|
|
],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName('rounds_table',
|
|
limitUpdateKind: UpdateKind.delete),
|
|
result: [
|
|
TableUpdate('round_scores_table', kind: UpdateKind.delete),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
typedef $$GameSessionTableTableCreateCompanionBuilder
|
|
= GameSessionTableCompanion Function({
|
|
required String id,
|
|
required DateTime createdAt,
|
|
required String gameTitle,
|
|
required int pointLimit,
|
|
required int caboPenalty,
|
|
required bool isPointsLimitEnabled,
|
|
required bool isGameFinished,
|
|
Value<String?> winner,
|
|
required int roundNumber,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$GameSessionTableTableUpdateCompanionBuilder
|
|
= GameSessionTableCompanion Function({
|
|
Value<String> id,
|
|
Value<DateTime> createdAt,
|
|
Value<String> gameTitle,
|
|
Value<int> pointLimit,
|
|
Value<int> caboPenalty,
|
|
Value<bool> isPointsLimitEnabled,
|
|
Value<bool> isGameFinished,
|
|
Value<String?> winner,
|
|
Value<int> roundNumber,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$GameSessionTableTableReferences extends BaseReferences<
|
|
_$AppDatabase, $GameSessionTableTable, GameSessionTableData> {
|
|
$$GameSessionTableTableReferences(
|
|
super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$RoundsTableTable, List<RoundsTableData>>
|
|
_roundsTableRefsTable(_$AppDatabase db) =>
|
|
MultiTypedResultKey.fromTable(db.roundsTable,
|
|
aliasName: $_aliasNameGenerator(
|
|
db.gameSessionTable.id, db.roundsTable.gameId));
|
|
|
|
$$RoundsTableTableProcessedTableManager get roundsTableRefs {
|
|
final manager = $$RoundsTableTableTableManager($_db, $_db.roundsTable)
|
|
.filter((f) => f.gameId.id.sqlEquals($_itemColumn<String>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(_roundsTableRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache));
|
|
}
|
|
}
|
|
|
|
class $$GameSessionTableTableFilterComposer
|
|
extends Composer<_$AppDatabase, $GameSessionTableTable> {
|
|
$$GameSessionTableTableFilterComposer({
|
|
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<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get gameTitle => $composableBuilder(
|
|
column: $table.gameTitle, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<int> get pointLimit => $composableBuilder(
|
|
column: $table.pointLimit, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<int> get caboPenalty => $composableBuilder(
|
|
column: $table.caboPenalty, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<bool> get isPointsLimitEnabled => $composableBuilder(
|
|
column: $table.isPointsLimitEnabled,
|
|
builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<bool> get isGameFinished => $composableBuilder(
|
|
column: $table.isGameFinished,
|
|
builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get winner => $composableBuilder(
|
|
column: $table.winner, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<int> get roundNumber => $composableBuilder(
|
|
column: $table.roundNumber, builder: (column) => ColumnFilters(column));
|
|
|
|
Expression<bool> roundsTableRefs(
|
|
Expression<bool> Function($$RoundsTableTableFilterComposer f) f) {
|
|
final $$RoundsTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.roundsTable,
|
|
getReferencedColumn: (t) => t.gameId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$RoundsTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.roundsTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$GameSessionTableTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $GameSessionTableTable> {
|
|
$$GameSessionTableTableOrderingComposer({
|
|
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<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get gameTitle => $composableBuilder(
|
|
column: $table.gameTitle, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<int> get pointLimit => $composableBuilder(
|
|
column: $table.pointLimit, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<int> get caboPenalty => $composableBuilder(
|
|
column: $table.caboPenalty, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<bool> get isPointsLimitEnabled => $composableBuilder(
|
|
column: $table.isPointsLimitEnabled,
|
|
builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<bool> get isGameFinished => $composableBuilder(
|
|
column: $table.isGameFinished,
|
|
builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get winner => $composableBuilder(
|
|
column: $table.winner, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<int> get roundNumber => $composableBuilder(
|
|
column: $table.roundNumber, builder: (column) => ColumnOrderings(column));
|
|
}
|
|
|
|
class $$GameSessionTableTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $GameSessionTableTable> {
|
|
$$GameSessionTableTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get gameTitle =>
|
|
$composableBuilder(column: $table.gameTitle, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get pointLimit => $composableBuilder(
|
|
column: $table.pointLimit, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get caboPenalty => $composableBuilder(
|
|
column: $table.caboPenalty, builder: (column) => column);
|
|
|
|
GeneratedColumn<bool> get isPointsLimitEnabled => $composableBuilder(
|
|
column: $table.isPointsLimitEnabled, builder: (column) => column);
|
|
|
|
GeneratedColumn<bool> get isGameFinished => $composableBuilder(
|
|
column: $table.isGameFinished, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get winner =>
|
|
$composableBuilder(column: $table.winner, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get roundNumber => $composableBuilder(
|
|
column: $table.roundNumber, builder: (column) => column);
|
|
|
|
Expression<T> roundsTableRefs<T extends Object>(
|
|
Expression<T> Function($$RoundsTableTableAnnotationComposer a) f) {
|
|
final $$RoundsTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.roundsTable,
|
|
getReferencedColumn: (t) => t.gameId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$RoundsTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.roundsTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$GameSessionTableTableTableManager extends RootTableManager<
|
|
_$AppDatabase,
|
|
$GameSessionTableTable,
|
|
GameSessionTableData,
|
|
$$GameSessionTableTableFilterComposer,
|
|
$$GameSessionTableTableOrderingComposer,
|
|
$$GameSessionTableTableAnnotationComposer,
|
|
$$GameSessionTableTableCreateCompanionBuilder,
|
|
$$GameSessionTableTableUpdateCompanionBuilder,
|
|
(GameSessionTableData, $$GameSessionTableTableReferences),
|
|
GameSessionTableData,
|
|
PrefetchHooks Function({bool roundsTableRefs})> {
|
|
$$GameSessionTableTableTableManager(
|
|
_$AppDatabase db, $GameSessionTableTable table)
|
|
: super(TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$GameSessionTableTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$GameSessionTableTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$GameSessionTableTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback: ({
|
|
Value<String> id = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
Value<String> gameTitle = const Value.absent(),
|
|
Value<int> pointLimit = const Value.absent(),
|
|
Value<int> caboPenalty = const Value.absent(),
|
|
Value<bool> isPointsLimitEnabled = const Value.absent(),
|
|
Value<bool> isGameFinished = const Value.absent(),
|
|
Value<String?> winner = const Value.absent(),
|
|
Value<int> roundNumber = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
GameSessionTableCompanion(
|
|
id: id,
|
|
createdAt: createdAt,
|
|
gameTitle: gameTitle,
|
|
pointLimit: pointLimit,
|
|
caboPenalty: caboPenalty,
|
|
isPointsLimitEnabled: isPointsLimitEnabled,
|
|
isGameFinished: isGameFinished,
|
|
winner: winner,
|
|
roundNumber: roundNumber,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback: ({
|
|
required String id,
|
|
required DateTime createdAt,
|
|
required String gameTitle,
|
|
required int pointLimit,
|
|
required int caboPenalty,
|
|
required bool isPointsLimitEnabled,
|
|
required bool isGameFinished,
|
|
Value<String?> winner = const Value.absent(),
|
|
required int roundNumber,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
GameSessionTableCompanion.insert(
|
|
id: id,
|
|
createdAt: createdAt,
|
|
gameTitle: gameTitle,
|
|
pointLimit: pointLimit,
|
|
caboPenalty: caboPenalty,
|
|
isPointsLimitEnabled: isPointsLimitEnabled,
|
|
isGameFinished: isGameFinished,
|
|
winner: winner,
|
|
roundNumber: roundNumber,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (
|
|
e.readTable(table),
|
|
$$GameSessionTableTableReferences(db, table, e)
|
|
))
|
|
.toList(),
|
|
prefetchHooksCallback: ({roundsTableRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [if (roundsTableRefs) db.roundsTable],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (roundsTableRefs)
|
|
await $_getPrefetchedData<GameSessionTableData,
|
|
$GameSessionTableTable, RoundsTableData>(
|
|
currentTable: table,
|
|
referencedTable: $$GameSessionTableTableReferences
|
|
._roundsTableRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$GameSessionTableTableReferences(db, table, p0)
|
|
.roundsTableRefs,
|
|
referencedItemsForCurrentItem: (item,
|
|
referencedItems) =>
|
|
referencedItems.where((e) => e.gameId == item.id),
|
|
typedResults: items)
|
|
];
|
|
},
|
|
);
|
|
},
|
|
));
|
|
}
|
|
|
|
typedef $$GameSessionTableTableProcessedTableManager = ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$GameSessionTableTable,
|
|
GameSessionTableData,
|
|
$$GameSessionTableTableFilterComposer,
|
|
$$GameSessionTableTableOrderingComposer,
|
|
$$GameSessionTableTableAnnotationComposer,
|
|
$$GameSessionTableTableCreateCompanionBuilder,
|
|
$$GameSessionTableTableUpdateCompanionBuilder,
|
|
(GameSessionTableData, $$GameSessionTableTableReferences),
|
|
GameSessionTableData,
|
|
PrefetchHooks Function({bool roundsTableRefs})>;
|
|
typedef $$PlayerTableTableCreateCompanionBuilder = PlayerTableCompanion
|
|
Function({
|
|
required String playerId,
|
|
required String gameId,
|
|
required int totalScore,
|
|
required int position,
|
|
required String name,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$PlayerTableTableUpdateCompanionBuilder = PlayerTableCompanion
|
|
Function({
|
|
Value<String> playerId,
|
|
Value<String> gameId,
|
|
Value<int> totalScore,
|
|
Value<int> position,
|
|
Value<String> name,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$PlayerTableTableReferences
|
|
extends BaseReferences<_$AppDatabase, $PlayerTableTable, PlayerTableData> {
|
|
$$PlayerTableTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static $GameSessionTableTable _playerIdTable(_$AppDatabase db) =>
|
|
db.gameSessionTable.createAlias($_aliasNameGenerator(
|
|
db.playerTable.playerId, db.gameSessionTable.id));
|
|
|
|
$$GameSessionTableTableProcessedTableManager get playerId {
|
|
final $_column = $_itemColumn<String>('player_id')!;
|
|
|
|
final manager =
|
|
$$GameSessionTableTableTableManager($_db, $_db.gameSessionTable)
|
|
.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 $GameSessionTableTable _gameIdTable(_$AppDatabase db) =>
|
|
db.gameSessionTable.createAlias(
|
|
$_aliasNameGenerator(db.playerTable.gameId, db.gameSessionTable.id));
|
|
|
|
$$GameSessionTableTableProcessedTableManager get gameId {
|
|
final $_column = $_itemColumn<String>('game_id')!;
|
|
|
|
final manager =
|
|
$$GameSessionTableTableTableManager($_db, $_db.gameSessionTable)
|
|
.filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_gameIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]));
|
|
}
|
|
}
|
|
|
|
class $$PlayerTableTableFilterComposer
|
|
extends Composer<_$AppDatabase, $PlayerTableTable> {
|
|
$$PlayerTableTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<int> get totalScore => $composableBuilder(
|
|
column: $table.totalScore, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<int> get position => $composableBuilder(
|
|
column: $table.position, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get name => $composableBuilder(
|
|
column: $table.name, builder: (column) => ColumnFilters(column));
|
|
|
|
$$GameSessionTableTableFilterComposer get playerId {
|
|
final $$GameSessionTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.playerId,
|
|
referencedTable: $db.gameSessionTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$GameSessionTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.gameSessionTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
|
|
$$GameSessionTableTableFilterComposer get gameId {
|
|
final $$GameSessionTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.gameId,
|
|
referencedTable: $db.gameSessionTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$GameSessionTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.gameSessionTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$PlayerTableTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $PlayerTableTable> {
|
|
$$PlayerTableTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<int> get totalScore => $composableBuilder(
|
|
column: $table.totalScore, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<int> get position => $composableBuilder(
|
|
column: $table.position, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get name => $composableBuilder(
|
|
column: $table.name, builder: (column) => ColumnOrderings(column));
|
|
|
|
$$GameSessionTableTableOrderingComposer get playerId {
|
|
final $$GameSessionTableTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.playerId,
|
|
referencedTable: $db.gameSessionTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$GameSessionTableTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.gameSessionTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
|
|
$$GameSessionTableTableOrderingComposer get gameId {
|
|
final $$GameSessionTableTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.gameId,
|
|
referencedTable: $db.gameSessionTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$GameSessionTableTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.gameSessionTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$PlayerTableTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $PlayerTableTable> {
|
|
$$PlayerTableTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<int> get totalScore => $composableBuilder(
|
|
column: $table.totalScore, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get position =>
|
|
$composableBuilder(column: $table.position, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get name =>
|
|
$composableBuilder(column: $table.name, builder: (column) => column);
|
|
|
|
$$GameSessionTableTableAnnotationComposer get playerId {
|
|
final $$GameSessionTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.playerId,
|
|
referencedTable: $db.gameSessionTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$GameSessionTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.gameSessionTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
|
|
$$GameSessionTableTableAnnotationComposer get gameId {
|
|
final $$GameSessionTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.gameId,
|
|
referencedTable: $db.gameSessionTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$GameSessionTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.gameSessionTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$PlayerTableTableTableManager extends RootTableManager<
|
|
_$AppDatabase,
|
|
$PlayerTableTable,
|
|
PlayerTableData,
|
|
$$PlayerTableTableFilterComposer,
|
|
$$PlayerTableTableOrderingComposer,
|
|
$$PlayerTableTableAnnotationComposer,
|
|
$$PlayerTableTableCreateCompanionBuilder,
|
|
$$PlayerTableTableUpdateCompanionBuilder,
|
|
(PlayerTableData, $$PlayerTableTableReferences),
|
|
PlayerTableData,
|
|
PrefetchHooks Function({bool playerId, bool gameId})> {
|
|
$$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> playerId = const Value.absent(),
|
|
Value<String> gameId = const Value.absent(),
|
|
Value<int> totalScore = const Value.absent(),
|
|
Value<int> position = const Value.absent(),
|
|
Value<String> name = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
PlayerTableCompanion(
|
|
playerId: playerId,
|
|
gameId: gameId,
|
|
totalScore: totalScore,
|
|
position: position,
|
|
name: name,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback: ({
|
|
required String playerId,
|
|
required String gameId,
|
|
required int totalScore,
|
|
required int position,
|
|
required String name,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
PlayerTableCompanion.insert(
|
|
playerId: playerId,
|
|
gameId: gameId,
|
|
totalScore: totalScore,
|
|
position: position,
|
|
name: name,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (
|
|
e.readTable(table),
|
|
$$PlayerTableTableReferences(db, table, e)
|
|
))
|
|
.toList(),
|
|
prefetchHooksCallback: ({playerId = false, gameId = 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:
|
|
$$PlayerTableTableReferences._playerIdTable(db),
|
|
referencedColumn:
|
|
$$PlayerTableTableReferences._playerIdTable(db).id,
|
|
) as T;
|
|
}
|
|
if (gameId) {
|
|
state = state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.gameId,
|
|
referencedTable:
|
|
$$PlayerTableTableReferences._gameIdTable(db),
|
|
referencedColumn:
|
|
$$PlayerTableTableReferences._gameIdTable(db).id,
|
|
) as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [];
|
|
},
|
|
);
|
|
},
|
|
));
|
|
}
|
|
|
|
typedef $$PlayerTableTableProcessedTableManager = ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$PlayerTableTable,
|
|
PlayerTableData,
|
|
$$PlayerTableTableFilterComposer,
|
|
$$PlayerTableTableOrderingComposer,
|
|
$$PlayerTableTableAnnotationComposer,
|
|
$$PlayerTableTableCreateCompanionBuilder,
|
|
$$PlayerTableTableUpdateCompanionBuilder,
|
|
(PlayerTableData, $$PlayerTableTableReferences),
|
|
PlayerTableData,
|
|
PrefetchHooks Function({bool playerId, bool gameId})>;
|
|
typedef $$RoundsTableTableCreateCompanionBuilder = RoundsTableCompanion
|
|
Function({
|
|
required String roundId,
|
|
required String gameId,
|
|
required int roundNumber,
|
|
required int caboPlayerIndex,
|
|
Value<int?> kamikazePlayerIndex,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$RoundsTableTableUpdateCompanionBuilder = RoundsTableCompanion
|
|
Function({
|
|
Value<String> roundId,
|
|
Value<String> gameId,
|
|
Value<int> roundNumber,
|
|
Value<int> caboPlayerIndex,
|
|
Value<int?> kamikazePlayerIndex,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$RoundsTableTableReferences
|
|
extends BaseReferences<_$AppDatabase, $RoundsTableTable, RoundsTableData> {
|
|
$$RoundsTableTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static $GameSessionTableTable _gameIdTable(_$AppDatabase db) =>
|
|
db.gameSessionTable.createAlias(
|
|
$_aliasNameGenerator(db.roundsTable.gameId, db.gameSessionTable.id));
|
|
|
|
$$GameSessionTableTableProcessedTableManager get gameId {
|
|
final $_column = $_itemColumn<String>('game_id')!;
|
|
|
|
final manager =
|
|
$$GameSessionTableTableTableManager($_db, $_db.gameSessionTable)
|
|
.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 MultiTypedResultKey<$RoundScoresTableTable, List<RoundScoresTableData>>
|
|
_roundScoresTableRefsTable(_$AppDatabase db) =>
|
|
MultiTypedResultKey.fromTable(db.roundScoresTable,
|
|
aliasName: $_aliasNameGenerator(
|
|
db.roundsTable.roundId, db.roundScoresTable.roundId));
|
|
|
|
$$RoundScoresTableTableProcessedTableManager get roundScoresTableRefs {
|
|
final manager =
|
|
$$RoundScoresTableTableTableManager($_db, $_db.roundScoresTable).filter(
|
|
(f) =>
|
|
f.roundId.roundId.sqlEquals($_itemColumn<String>('round_id')!));
|
|
|
|
final cache =
|
|
$_typedResult.readTableOrNull(_roundScoresTableRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache));
|
|
}
|
|
}
|
|
|
|
class $$RoundsTableTableFilterComposer
|
|
extends Composer<_$AppDatabase, $RoundsTableTable> {
|
|
$$RoundsTableTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get roundId => $composableBuilder(
|
|
column: $table.roundId, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<int> get roundNumber => $composableBuilder(
|
|
column: $table.roundNumber, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<int> get caboPlayerIndex => $composableBuilder(
|
|
column: $table.caboPlayerIndex,
|
|
builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<int> get kamikazePlayerIndex => $composableBuilder(
|
|
column: $table.kamikazePlayerIndex,
|
|
builder: (column) => ColumnFilters(column));
|
|
|
|
$$GameSessionTableTableFilterComposer get gameId {
|
|
final $$GameSessionTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.gameId,
|
|
referencedTable: $db.gameSessionTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$GameSessionTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.gameSessionTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
|
|
Expression<bool> roundScoresTableRefs(
|
|
Expression<bool> Function($$RoundScoresTableTableFilterComposer f) f) {
|
|
final $$RoundScoresTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.roundId,
|
|
referencedTable: $db.roundScoresTable,
|
|
getReferencedColumn: (t) => t.roundId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$RoundScoresTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.roundScoresTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$RoundsTableTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $RoundsTableTable> {
|
|
$$RoundsTableTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get roundId => $composableBuilder(
|
|
column: $table.roundId, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<int> get roundNumber => $composableBuilder(
|
|
column: $table.roundNumber, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<int> get caboPlayerIndex => $composableBuilder(
|
|
column: $table.caboPlayerIndex,
|
|
builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<int> get kamikazePlayerIndex => $composableBuilder(
|
|
column: $table.kamikazePlayerIndex,
|
|
builder: (column) => ColumnOrderings(column));
|
|
|
|
$$GameSessionTableTableOrderingComposer get gameId {
|
|
final $$GameSessionTableTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.gameId,
|
|
referencedTable: $db.gameSessionTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$GameSessionTableTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.gameSessionTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$RoundsTableTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $RoundsTableTable> {
|
|
$$RoundsTableTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get roundId =>
|
|
$composableBuilder(column: $table.roundId, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get roundNumber => $composableBuilder(
|
|
column: $table.roundNumber, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get caboPlayerIndex => $composableBuilder(
|
|
column: $table.caboPlayerIndex, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get kamikazePlayerIndex => $composableBuilder(
|
|
column: $table.kamikazePlayerIndex, builder: (column) => column);
|
|
|
|
$$GameSessionTableTableAnnotationComposer get gameId {
|
|
final $$GameSessionTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.gameId,
|
|
referencedTable: $db.gameSessionTable,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$GameSessionTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.gameSessionTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
|
|
Expression<T> roundScoresTableRefs<T extends Object>(
|
|
Expression<T> Function($$RoundScoresTableTableAnnotationComposer a) f) {
|
|
final $$RoundScoresTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.roundId,
|
|
referencedTable: $db.roundScoresTable,
|
|
getReferencedColumn: (t) => t.roundId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$RoundScoresTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.roundScoresTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$RoundsTableTableTableManager extends RootTableManager<
|
|
_$AppDatabase,
|
|
$RoundsTableTable,
|
|
RoundsTableData,
|
|
$$RoundsTableTableFilterComposer,
|
|
$$RoundsTableTableOrderingComposer,
|
|
$$RoundsTableTableAnnotationComposer,
|
|
$$RoundsTableTableCreateCompanionBuilder,
|
|
$$RoundsTableTableUpdateCompanionBuilder,
|
|
(RoundsTableData, $$RoundsTableTableReferences),
|
|
RoundsTableData,
|
|
PrefetchHooks Function({bool gameId, bool roundScoresTableRefs})> {
|
|
$$RoundsTableTableTableManager(_$AppDatabase db, $RoundsTableTable table)
|
|
: super(TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$RoundsTableTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$RoundsTableTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$RoundsTableTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback: ({
|
|
Value<String> roundId = const Value.absent(),
|
|
Value<String> gameId = const Value.absent(),
|
|
Value<int> roundNumber = const Value.absent(),
|
|
Value<int> caboPlayerIndex = const Value.absent(),
|
|
Value<int?> kamikazePlayerIndex = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
RoundsTableCompanion(
|
|
roundId: roundId,
|
|
gameId: gameId,
|
|
roundNumber: roundNumber,
|
|
caboPlayerIndex: caboPlayerIndex,
|
|
kamikazePlayerIndex: kamikazePlayerIndex,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback: ({
|
|
required String roundId,
|
|
required String gameId,
|
|
required int roundNumber,
|
|
required int caboPlayerIndex,
|
|
Value<int?> kamikazePlayerIndex = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
RoundsTableCompanion.insert(
|
|
roundId: roundId,
|
|
gameId: gameId,
|
|
roundNumber: roundNumber,
|
|
caboPlayerIndex: caboPlayerIndex,
|
|
kamikazePlayerIndex: kamikazePlayerIndex,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (
|
|
e.readTable(table),
|
|
$$RoundsTableTableReferences(db, table, e)
|
|
))
|
|
.toList(),
|
|
prefetchHooksCallback: (
|
|
{gameId = false, roundScoresTableRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [
|
|
if (roundScoresTableRefs) db.roundScoresTable
|
|
],
|
|
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:
|
|
$$RoundsTableTableReferences._gameIdTable(db),
|
|
referencedColumn:
|
|
$$RoundsTableTableReferences._gameIdTable(db).id,
|
|
) as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (roundScoresTableRefs)
|
|
await $_getPrefetchedData<RoundsTableData,
|
|
$RoundsTableTable, RoundScoresTableData>(
|
|
currentTable: table,
|
|
referencedTable: $$RoundsTableTableReferences
|
|
._roundScoresTableRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$RoundsTableTableReferences(db, table, p0)
|
|
.roundScoresTableRefs,
|
|
referencedItemsForCurrentItem:
|
|
(item, referencedItems) => referencedItems
|
|
.where((e) => e.roundId == item.roundId),
|
|
typedResults: items)
|
|
];
|
|
},
|
|
);
|
|
},
|
|
));
|
|
}
|
|
|
|
typedef $$RoundsTableTableProcessedTableManager = ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$RoundsTableTable,
|
|
RoundsTableData,
|
|
$$RoundsTableTableFilterComposer,
|
|
$$RoundsTableTableOrderingComposer,
|
|
$$RoundsTableTableAnnotationComposer,
|
|
$$RoundsTableTableCreateCompanionBuilder,
|
|
$$RoundsTableTableUpdateCompanionBuilder,
|
|
(RoundsTableData, $$RoundsTableTableReferences),
|
|
RoundsTableData,
|
|
PrefetchHooks Function({bool gameId, bool roundScoresTableRefs})>;
|
|
typedef $$RoundScoresTableTableCreateCompanionBuilder
|
|
= RoundScoresTableCompanion Function({
|
|
required String roundId,
|
|
required String playerId,
|
|
required int score,
|
|
required int scoreUpdate,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$RoundScoresTableTableUpdateCompanionBuilder
|
|
= RoundScoresTableCompanion Function({
|
|
Value<String> roundId,
|
|
Value<String> playerId,
|
|
Value<int> score,
|
|
Value<int> scoreUpdate,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$RoundScoresTableTableReferences extends BaseReferences<
|
|
_$AppDatabase, $RoundScoresTableTable, RoundScoresTableData> {
|
|
$$RoundScoresTableTableReferences(
|
|
super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static $RoundsTableTable _roundIdTable(_$AppDatabase db) =>
|
|
db.roundsTable.createAlias($_aliasNameGenerator(
|
|
db.roundScoresTable.roundId, db.roundsTable.roundId));
|
|
|
|
$$RoundsTableTableProcessedTableManager get roundId {
|
|
final $_column = $_itemColumn<String>('round_id')!;
|
|
|
|
final manager = $$RoundsTableTableTableManager($_db, $_db.roundsTable)
|
|
.filter((f) => f.roundId.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_roundIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]));
|
|
}
|
|
}
|
|
|
|
class $$RoundScoresTableTableFilterComposer
|
|
extends Composer<_$AppDatabase, $RoundScoresTableTable> {
|
|
$$RoundScoresTableTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get playerId => $composableBuilder(
|
|
column: $table.playerId, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<int> get score => $composableBuilder(
|
|
column: $table.score, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<int> get scoreUpdate => $composableBuilder(
|
|
column: $table.scoreUpdate, builder: (column) => ColumnFilters(column));
|
|
|
|
$$RoundsTableTableFilterComposer get roundId {
|
|
final $$RoundsTableTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.roundId,
|
|
referencedTable: $db.roundsTable,
|
|
getReferencedColumn: (t) => t.roundId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$RoundsTableTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.roundsTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$RoundScoresTableTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $RoundScoresTableTable> {
|
|
$$RoundScoresTableTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get playerId => $composableBuilder(
|
|
column: $table.playerId, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<int> get score => $composableBuilder(
|
|
column: $table.score, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<int> get scoreUpdate => $composableBuilder(
|
|
column: $table.scoreUpdate, builder: (column) => ColumnOrderings(column));
|
|
|
|
$$RoundsTableTableOrderingComposer get roundId {
|
|
final $$RoundsTableTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.roundId,
|
|
referencedTable: $db.roundsTable,
|
|
getReferencedColumn: (t) => t.roundId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$RoundsTableTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.roundsTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$RoundScoresTableTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $RoundScoresTableTable> {
|
|
$$RoundScoresTableTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get playerId =>
|
|
$composableBuilder(column: $table.playerId, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get score =>
|
|
$composableBuilder(column: $table.score, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get scoreUpdate => $composableBuilder(
|
|
column: $table.scoreUpdate, builder: (column) => column);
|
|
|
|
$$RoundsTableTableAnnotationComposer get roundId {
|
|
final $$RoundsTableTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.roundId,
|
|
referencedTable: $db.roundsTable,
|
|
getReferencedColumn: (t) => t.roundId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$RoundsTableTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.roundsTable,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$RoundScoresTableTableTableManager extends RootTableManager<
|
|
_$AppDatabase,
|
|
$RoundScoresTableTable,
|
|
RoundScoresTableData,
|
|
$$RoundScoresTableTableFilterComposer,
|
|
$$RoundScoresTableTableOrderingComposer,
|
|
$$RoundScoresTableTableAnnotationComposer,
|
|
$$RoundScoresTableTableCreateCompanionBuilder,
|
|
$$RoundScoresTableTableUpdateCompanionBuilder,
|
|
(RoundScoresTableData, $$RoundScoresTableTableReferences),
|
|
RoundScoresTableData,
|
|
PrefetchHooks Function({bool roundId})> {
|
|
$$RoundScoresTableTableTableManager(
|
|
_$AppDatabase db, $RoundScoresTableTable table)
|
|
: super(TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$RoundScoresTableTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$RoundScoresTableTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$RoundScoresTableTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback: ({
|
|
Value<String> roundId = const Value.absent(),
|
|
Value<String> playerId = const Value.absent(),
|
|
Value<int> score = const Value.absent(),
|
|
Value<int> scoreUpdate = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
RoundScoresTableCompanion(
|
|
roundId: roundId,
|
|
playerId: playerId,
|
|
score: score,
|
|
scoreUpdate: scoreUpdate,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback: ({
|
|
required String roundId,
|
|
required String playerId,
|
|
required int score,
|
|
required int scoreUpdate,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
RoundScoresTableCompanion.insert(
|
|
roundId: roundId,
|
|
playerId: playerId,
|
|
score: score,
|
|
scoreUpdate: scoreUpdate,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (
|
|
e.readTable(table),
|
|
$$RoundScoresTableTableReferences(db, table, e)
|
|
))
|
|
.toList(),
|
|
prefetchHooksCallback: ({roundId = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [],
|
|
addJoins: <
|
|
T extends TableManagerState<
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic>>(state) {
|
|
if (roundId) {
|
|
state = state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.roundId,
|
|
referencedTable:
|
|
$$RoundScoresTableTableReferences._roundIdTable(db),
|
|
referencedColumn: $$RoundScoresTableTableReferences
|
|
._roundIdTable(db)
|
|
.roundId,
|
|
) as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [];
|
|
},
|
|
);
|
|
},
|
|
));
|
|
}
|
|
|
|
typedef $$RoundScoresTableTableProcessedTableManager = ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$RoundScoresTableTable,
|
|
RoundScoresTableData,
|
|
$$RoundScoresTableTableFilterComposer,
|
|
$$RoundScoresTableTableOrderingComposer,
|
|
$$RoundScoresTableTableAnnotationComposer,
|
|
$$RoundScoresTableTableCreateCompanionBuilder,
|
|
$$RoundScoresTableTableUpdateCompanionBuilder,
|
|
(RoundScoresTableData, $$RoundScoresTableTableReferences),
|
|
RoundScoresTableData,
|
|
PrefetchHooks Function({bool roundId})>;
|
|
|
|
class $AppDatabaseManager {
|
|
final _$AppDatabase _db;
|
|
$AppDatabaseManager(this._db);
|
|
$$GameSessionTableTableTableManager get gameSessionTable =>
|
|
$$GameSessionTableTableTableManager(_db, _db.gameSessionTable);
|
|
$$PlayerTableTableTableManager get playerTable =>
|
|
$$PlayerTableTableTableManager(_db, _db.playerTable);
|
|
$$RoundsTableTableTableManager get roundsTable =>
|
|
$$RoundsTableTableTableManager(_db, _db.roundsTable);
|
|
$$RoundScoresTableTableTableManager get roundScoresTable =>
|
|
$$RoundScoresTableTableTableManager(_db, _db.roundScoresTable);
|
|
}
|