2236 lines
69 KiB
Dart
2236 lines
69 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'db.dart';
|
|
|
|
// ignore_for_file: type=lint
|
|
class $TracksTable extends Tracks with TableInfo<$TracksTable, Track> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$TracksTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<int> id = GeneratedColumn<int>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
hasAutoIncrement: true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'PRIMARY KEY AUTOINCREMENT',
|
|
),
|
|
);
|
|
static const VerificationMeta _titleMeta = const VerificationMeta('title');
|
|
@override
|
|
late final GeneratedColumn<String> title = GeneratedColumn<String>(
|
|
'title',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _artistMeta = const VerificationMeta('artist');
|
|
@override
|
|
late final GeneratedColumn<String> artist = GeneratedColumn<String>(
|
|
'artist',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _albumMeta = const VerificationMeta('album');
|
|
@override
|
|
late final GeneratedColumn<String> album = GeneratedColumn<String>(
|
|
'album',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _durationMeta = const VerificationMeta(
|
|
'duration',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> duration = GeneratedColumn<int>(
|
|
'duration',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _pathMeta = const VerificationMeta('path');
|
|
@override
|
|
late final GeneratedColumn<String> path = GeneratedColumn<String>(
|
|
'path',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways('UNIQUE'),
|
|
);
|
|
static const VerificationMeta _artUriMeta = const VerificationMeta('artUri');
|
|
@override
|
|
late final GeneratedColumn<String> artUri = GeneratedColumn<String>(
|
|
'art_uri',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _lyricsMeta = const VerificationMeta('lyrics');
|
|
@override
|
|
late final GeneratedColumn<String> lyrics = GeneratedColumn<String>(
|
|
'lyrics',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _lyricsOffsetMeta = const VerificationMeta(
|
|
'lyricsOffset',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> lyricsOffset = GeneratedColumn<int>(
|
|
'lyrics_offset',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant(0),
|
|
);
|
|
static const VerificationMeta _addedAtMeta = const VerificationMeta(
|
|
'addedAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> addedAt = GeneratedColumn<DateTime>(
|
|
'added_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
defaultValue: currentDateAndTime,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
title,
|
|
artist,
|
|
album,
|
|
duration,
|
|
path,
|
|
artUri,
|
|
lyrics,
|
|
lyricsOffset,
|
|
addedAt,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'tracks';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<Track> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
}
|
|
if (data.containsKey('title')) {
|
|
context.handle(
|
|
_titleMeta,
|
|
title.isAcceptableOrUnknown(data['title']!, _titleMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_titleMeta);
|
|
}
|
|
if (data.containsKey('artist')) {
|
|
context.handle(
|
|
_artistMeta,
|
|
artist.isAcceptableOrUnknown(data['artist']!, _artistMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('album')) {
|
|
context.handle(
|
|
_albumMeta,
|
|
album.isAcceptableOrUnknown(data['album']!, _albumMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('duration')) {
|
|
context.handle(
|
|
_durationMeta,
|
|
duration.isAcceptableOrUnknown(data['duration']!, _durationMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('path')) {
|
|
context.handle(
|
|
_pathMeta,
|
|
path.isAcceptableOrUnknown(data['path']!, _pathMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_pathMeta);
|
|
}
|
|
if (data.containsKey('art_uri')) {
|
|
context.handle(
|
|
_artUriMeta,
|
|
artUri.isAcceptableOrUnknown(data['art_uri']!, _artUriMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('lyrics')) {
|
|
context.handle(
|
|
_lyricsMeta,
|
|
lyrics.isAcceptableOrUnknown(data['lyrics']!, _lyricsMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('lyrics_offset')) {
|
|
context.handle(
|
|
_lyricsOffsetMeta,
|
|
lyricsOffset.isAcceptableOrUnknown(
|
|
data['lyrics_offset']!,
|
|
_lyricsOffsetMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('added_at')) {
|
|
context.handle(
|
|
_addedAtMeta,
|
|
addedAt.isAcceptableOrUnknown(data['added_at']!, _addedAtMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
Track map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return Track(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
title: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}title'],
|
|
)!,
|
|
artist: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}artist'],
|
|
),
|
|
album: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}album'],
|
|
),
|
|
duration: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}duration'],
|
|
),
|
|
path: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}path'],
|
|
)!,
|
|
artUri: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}art_uri'],
|
|
),
|
|
lyrics: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}lyrics'],
|
|
),
|
|
lyricsOffset: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}lyrics_offset'],
|
|
)!,
|
|
addedAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}added_at'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$TracksTable createAlias(String alias) {
|
|
return $TracksTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class Track extends DataClass implements Insertable<Track> {
|
|
final int id;
|
|
final String title;
|
|
final String? artist;
|
|
final String? album;
|
|
final int? duration;
|
|
final String path;
|
|
final String? artUri;
|
|
final String? lyrics;
|
|
final int lyricsOffset;
|
|
final DateTime addedAt;
|
|
const Track({
|
|
required this.id,
|
|
required this.title,
|
|
this.artist,
|
|
this.album,
|
|
this.duration,
|
|
required this.path,
|
|
this.artUri,
|
|
this.lyrics,
|
|
required this.lyricsOffset,
|
|
required this.addedAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['title'] = Variable<String>(title);
|
|
if (!nullToAbsent || artist != null) {
|
|
map['artist'] = Variable<String>(artist);
|
|
}
|
|
if (!nullToAbsent || album != null) {
|
|
map['album'] = Variable<String>(album);
|
|
}
|
|
if (!nullToAbsent || duration != null) {
|
|
map['duration'] = Variable<int>(duration);
|
|
}
|
|
map['path'] = Variable<String>(path);
|
|
if (!nullToAbsent || artUri != null) {
|
|
map['art_uri'] = Variable<String>(artUri);
|
|
}
|
|
if (!nullToAbsent || lyrics != null) {
|
|
map['lyrics'] = Variable<String>(lyrics);
|
|
}
|
|
map['lyrics_offset'] = Variable<int>(lyricsOffset);
|
|
map['added_at'] = Variable<DateTime>(addedAt);
|
|
return map;
|
|
}
|
|
|
|
TracksCompanion toCompanion(bool nullToAbsent) {
|
|
return TracksCompanion(
|
|
id: Value(id),
|
|
title: Value(title),
|
|
artist: artist == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(artist),
|
|
album: album == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(album),
|
|
duration: duration == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(duration),
|
|
path: Value(path),
|
|
artUri: artUri == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(artUri),
|
|
lyrics: lyrics == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(lyrics),
|
|
lyricsOffset: Value(lyricsOffset),
|
|
addedAt: Value(addedAt),
|
|
);
|
|
}
|
|
|
|
factory Track.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return Track(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
title: serializer.fromJson<String>(json['title']),
|
|
artist: serializer.fromJson<String?>(json['artist']),
|
|
album: serializer.fromJson<String?>(json['album']),
|
|
duration: serializer.fromJson<int?>(json['duration']),
|
|
path: serializer.fromJson<String>(json['path']),
|
|
artUri: serializer.fromJson<String?>(json['artUri']),
|
|
lyrics: serializer.fromJson<String?>(json['lyrics']),
|
|
lyricsOffset: serializer.fromJson<int>(json['lyricsOffset']),
|
|
addedAt: serializer.fromJson<DateTime>(json['addedAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'title': serializer.toJson<String>(title),
|
|
'artist': serializer.toJson<String?>(artist),
|
|
'album': serializer.toJson<String?>(album),
|
|
'duration': serializer.toJson<int?>(duration),
|
|
'path': serializer.toJson<String>(path),
|
|
'artUri': serializer.toJson<String?>(artUri),
|
|
'lyrics': serializer.toJson<String?>(lyrics),
|
|
'lyricsOffset': serializer.toJson<int>(lyricsOffset),
|
|
'addedAt': serializer.toJson<DateTime>(addedAt),
|
|
};
|
|
}
|
|
|
|
Track copyWith({
|
|
int? id,
|
|
String? title,
|
|
Value<String?> artist = const Value.absent(),
|
|
Value<String?> album = const Value.absent(),
|
|
Value<int?> duration = const Value.absent(),
|
|
String? path,
|
|
Value<String?> artUri = const Value.absent(),
|
|
Value<String?> lyrics = const Value.absent(),
|
|
int? lyricsOffset,
|
|
DateTime? addedAt,
|
|
}) => Track(
|
|
id: id ?? this.id,
|
|
title: title ?? this.title,
|
|
artist: artist.present ? artist.value : this.artist,
|
|
album: album.present ? album.value : this.album,
|
|
duration: duration.present ? duration.value : this.duration,
|
|
path: path ?? this.path,
|
|
artUri: artUri.present ? artUri.value : this.artUri,
|
|
lyrics: lyrics.present ? lyrics.value : this.lyrics,
|
|
lyricsOffset: lyricsOffset ?? this.lyricsOffset,
|
|
addedAt: addedAt ?? this.addedAt,
|
|
);
|
|
Track copyWithCompanion(TracksCompanion data) {
|
|
return Track(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
title: data.title.present ? data.title.value : this.title,
|
|
artist: data.artist.present ? data.artist.value : this.artist,
|
|
album: data.album.present ? data.album.value : this.album,
|
|
duration: data.duration.present ? data.duration.value : this.duration,
|
|
path: data.path.present ? data.path.value : this.path,
|
|
artUri: data.artUri.present ? data.artUri.value : this.artUri,
|
|
lyrics: data.lyrics.present ? data.lyrics.value : this.lyrics,
|
|
lyricsOffset: data.lyricsOffset.present
|
|
? data.lyricsOffset.value
|
|
: this.lyricsOffset,
|
|
addedAt: data.addedAt.present ? data.addedAt.value : this.addedAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Track(')
|
|
..write('id: $id, ')
|
|
..write('title: $title, ')
|
|
..write('artist: $artist, ')
|
|
..write('album: $album, ')
|
|
..write('duration: $duration, ')
|
|
..write('path: $path, ')
|
|
..write('artUri: $artUri, ')
|
|
..write('lyrics: $lyrics, ')
|
|
..write('lyricsOffset: $lyricsOffset, ')
|
|
..write('addedAt: $addedAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(
|
|
id,
|
|
title,
|
|
artist,
|
|
album,
|
|
duration,
|
|
path,
|
|
artUri,
|
|
lyrics,
|
|
lyricsOffset,
|
|
addedAt,
|
|
);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is Track &&
|
|
other.id == this.id &&
|
|
other.title == this.title &&
|
|
other.artist == this.artist &&
|
|
other.album == this.album &&
|
|
other.duration == this.duration &&
|
|
other.path == this.path &&
|
|
other.artUri == this.artUri &&
|
|
other.lyrics == this.lyrics &&
|
|
other.lyricsOffset == this.lyricsOffset &&
|
|
other.addedAt == this.addedAt);
|
|
}
|
|
|
|
class TracksCompanion extends UpdateCompanion<Track> {
|
|
final Value<int> id;
|
|
final Value<String> title;
|
|
final Value<String?> artist;
|
|
final Value<String?> album;
|
|
final Value<int?> duration;
|
|
final Value<String> path;
|
|
final Value<String?> artUri;
|
|
final Value<String?> lyrics;
|
|
final Value<int> lyricsOffset;
|
|
final Value<DateTime> addedAt;
|
|
const TracksCompanion({
|
|
this.id = const Value.absent(),
|
|
this.title = const Value.absent(),
|
|
this.artist = const Value.absent(),
|
|
this.album = const Value.absent(),
|
|
this.duration = const Value.absent(),
|
|
this.path = const Value.absent(),
|
|
this.artUri = const Value.absent(),
|
|
this.lyrics = const Value.absent(),
|
|
this.lyricsOffset = const Value.absent(),
|
|
this.addedAt = const Value.absent(),
|
|
});
|
|
TracksCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required String title,
|
|
this.artist = const Value.absent(),
|
|
this.album = const Value.absent(),
|
|
this.duration = const Value.absent(),
|
|
required String path,
|
|
this.artUri = const Value.absent(),
|
|
this.lyrics = const Value.absent(),
|
|
this.lyricsOffset = const Value.absent(),
|
|
this.addedAt = const Value.absent(),
|
|
}) : title = Value(title),
|
|
path = Value(path);
|
|
static Insertable<Track> custom({
|
|
Expression<int>? id,
|
|
Expression<String>? title,
|
|
Expression<String>? artist,
|
|
Expression<String>? album,
|
|
Expression<int>? duration,
|
|
Expression<String>? path,
|
|
Expression<String>? artUri,
|
|
Expression<String>? lyrics,
|
|
Expression<int>? lyricsOffset,
|
|
Expression<DateTime>? addedAt,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (title != null) 'title': title,
|
|
if (artist != null) 'artist': artist,
|
|
if (album != null) 'album': album,
|
|
if (duration != null) 'duration': duration,
|
|
if (path != null) 'path': path,
|
|
if (artUri != null) 'art_uri': artUri,
|
|
if (lyrics != null) 'lyrics': lyrics,
|
|
if (lyricsOffset != null) 'lyrics_offset': lyricsOffset,
|
|
if (addedAt != null) 'added_at': addedAt,
|
|
});
|
|
}
|
|
|
|
TracksCompanion copyWith({
|
|
Value<int>? id,
|
|
Value<String>? title,
|
|
Value<String?>? artist,
|
|
Value<String?>? album,
|
|
Value<int?>? duration,
|
|
Value<String>? path,
|
|
Value<String?>? artUri,
|
|
Value<String?>? lyrics,
|
|
Value<int>? lyricsOffset,
|
|
Value<DateTime>? addedAt,
|
|
}) {
|
|
return TracksCompanion(
|
|
id: id ?? this.id,
|
|
title: title ?? this.title,
|
|
artist: artist ?? this.artist,
|
|
album: album ?? this.album,
|
|
duration: duration ?? this.duration,
|
|
path: path ?? this.path,
|
|
artUri: artUri ?? this.artUri,
|
|
lyrics: lyrics ?? this.lyrics,
|
|
lyricsOffset: lyricsOffset ?? this.lyricsOffset,
|
|
addedAt: addedAt ?? this.addedAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<int>(id.value);
|
|
}
|
|
if (title.present) {
|
|
map['title'] = Variable<String>(title.value);
|
|
}
|
|
if (artist.present) {
|
|
map['artist'] = Variable<String>(artist.value);
|
|
}
|
|
if (album.present) {
|
|
map['album'] = Variable<String>(album.value);
|
|
}
|
|
if (duration.present) {
|
|
map['duration'] = Variable<int>(duration.value);
|
|
}
|
|
if (path.present) {
|
|
map['path'] = Variable<String>(path.value);
|
|
}
|
|
if (artUri.present) {
|
|
map['art_uri'] = Variable<String>(artUri.value);
|
|
}
|
|
if (lyrics.present) {
|
|
map['lyrics'] = Variable<String>(lyrics.value);
|
|
}
|
|
if (lyricsOffset.present) {
|
|
map['lyrics_offset'] = Variable<int>(lyricsOffset.value);
|
|
}
|
|
if (addedAt.present) {
|
|
map['added_at'] = Variable<DateTime>(addedAt.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TracksCompanion(')
|
|
..write('id: $id, ')
|
|
..write('title: $title, ')
|
|
..write('artist: $artist, ')
|
|
..write('album: $album, ')
|
|
..write('duration: $duration, ')
|
|
..write('path: $path, ')
|
|
..write('artUri: $artUri, ')
|
|
..write('lyrics: $lyrics, ')
|
|
..write('lyricsOffset: $lyricsOffset, ')
|
|
..write('addedAt: $addedAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $PlaylistsTable extends Playlists
|
|
with TableInfo<$PlaylistsTable, Playlist> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$PlaylistsTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<int> id = GeneratedColumn<int>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
hasAutoIncrement: true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'PRIMARY KEY AUTOINCREMENT',
|
|
),
|
|
);
|
|
static const VerificationMeta _nameMeta = const VerificationMeta('name');
|
|
@override
|
|
late final GeneratedColumn<String> name = GeneratedColumn<String>(
|
|
'name',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _createdAtMeta = const VerificationMeta(
|
|
'createdAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
defaultValue: currentDateAndTime,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, name, createdAt];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'playlists';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<Playlist> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
}
|
|
if (data.containsKey('name')) {
|
|
context.handle(
|
|
_nameMeta,
|
|
name.isAcceptableOrUnknown(data['name']!, _nameMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_nameMeta);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(
|
|
_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
Playlist map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return Playlist(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
name: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}name'],
|
|
)!,
|
|
createdAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}created_at'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$PlaylistsTable createAlias(String alias) {
|
|
return $PlaylistsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class Playlist extends DataClass implements Insertable<Playlist> {
|
|
final int id;
|
|
final String name;
|
|
final DateTime createdAt;
|
|
const Playlist({
|
|
required this.id,
|
|
required this.name,
|
|
required this.createdAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['name'] = Variable<String>(name);
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
return map;
|
|
}
|
|
|
|
PlaylistsCompanion toCompanion(bool nullToAbsent) {
|
|
return PlaylistsCompanion(
|
|
id: Value(id),
|
|
name: Value(name),
|
|
createdAt: Value(createdAt),
|
|
);
|
|
}
|
|
|
|
factory Playlist.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return Playlist(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
name: serializer.fromJson<String>(json['name']),
|
|
createdAt: serializer.fromJson<DateTime>(json['createdAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'name': serializer.toJson<String>(name),
|
|
'createdAt': serializer.toJson<DateTime>(createdAt),
|
|
};
|
|
}
|
|
|
|
Playlist copyWith({int? id, String? name, DateTime? createdAt}) => Playlist(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
);
|
|
Playlist copyWithCompanion(PlaylistsCompanion data) {
|
|
return Playlist(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
name: data.name.present ? data.name.value : this.name,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Playlist(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, name, createdAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is Playlist &&
|
|
other.id == this.id &&
|
|
other.name == this.name &&
|
|
other.createdAt == this.createdAt);
|
|
}
|
|
|
|
class PlaylistsCompanion extends UpdateCompanion<Playlist> {
|
|
final Value<int> id;
|
|
final Value<String> name;
|
|
final Value<DateTime> createdAt;
|
|
const PlaylistsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.name = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
});
|
|
PlaylistsCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required String name,
|
|
this.createdAt = const Value.absent(),
|
|
}) : name = Value(name);
|
|
static Insertable<Playlist> custom({
|
|
Expression<int>? id,
|
|
Expression<String>? name,
|
|
Expression<DateTime>? createdAt,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (name != null) 'name': name,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
});
|
|
}
|
|
|
|
PlaylistsCompanion copyWith({
|
|
Value<int>? id,
|
|
Value<String>? name,
|
|
Value<DateTime>? createdAt,
|
|
}) {
|
|
return PlaylistsCompanion(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<int>(id.value);
|
|
}
|
|
if (name.present) {
|
|
map['name'] = Variable<String>(name.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('PlaylistsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $PlaylistEntriesTable extends PlaylistEntries
|
|
with TableInfo<$PlaylistEntriesTable, PlaylistEntry> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$PlaylistEntriesTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<int> id = GeneratedColumn<int>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
hasAutoIncrement: true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'PRIMARY KEY AUTOINCREMENT',
|
|
),
|
|
);
|
|
static const VerificationMeta _playlistIdMeta = const VerificationMeta(
|
|
'playlistId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> playlistId = GeneratedColumn<int>(
|
|
'playlist_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES playlists (id)',
|
|
),
|
|
);
|
|
static const VerificationMeta _trackIdMeta = const VerificationMeta(
|
|
'trackId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> trackId = GeneratedColumn<int>(
|
|
'track_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES tracks (id) ON DELETE CASCADE',
|
|
),
|
|
);
|
|
static const VerificationMeta _addedAtMeta = const VerificationMeta(
|
|
'addedAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> addedAt = GeneratedColumn<DateTime>(
|
|
'added_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
defaultValue: currentDateAndTime,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, playlistId, trackId, addedAt];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'playlist_entries';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<PlaylistEntry> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
}
|
|
if (data.containsKey('playlist_id')) {
|
|
context.handle(
|
|
_playlistIdMeta,
|
|
playlistId.isAcceptableOrUnknown(data['playlist_id']!, _playlistIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_playlistIdMeta);
|
|
}
|
|
if (data.containsKey('track_id')) {
|
|
context.handle(
|
|
_trackIdMeta,
|
|
trackId.isAcceptableOrUnknown(data['track_id']!, _trackIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_trackIdMeta);
|
|
}
|
|
if (data.containsKey('added_at')) {
|
|
context.handle(
|
|
_addedAtMeta,
|
|
addedAt.isAcceptableOrUnknown(data['added_at']!, _addedAtMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
PlaylistEntry map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return PlaylistEntry(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
playlistId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}playlist_id'],
|
|
)!,
|
|
trackId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}track_id'],
|
|
)!,
|
|
addedAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}added_at'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$PlaylistEntriesTable createAlias(String alias) {
|
|
return $PlaylistEntriesTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class PlaylistEntry extends DataClass implements Insertable<PlaylistEntry> {
|
|
final int id;
|
|
final int playlistId;
|
|
final int trackId;
|
|
final DateTime addedAt;
|
|
const PlaylistEntry({
|
|
required this.id,
|
|
required this.playlistId,
|
|
required this.trackId,
|
|
required this.addedAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['playlist_id'] = Variable<int>(playlistId);
|
|
map['track_id'] = Variable<int>(trackId);
|
|
map['added_at'] = Variable<DateTime>(addedAt);
|
|
return map;
|
|
}
|
|
|
|
PlaylistEntriesCompanion toCompanion(bool nullToAbsent) {
|
|
return PlaylistEntriesCompanion(
|
|
id: Value(id),
|
|
playlistId: Value(playlistId),
|
|
trackId: Value(trackId),
|
|
addedAt: Value(addedAt),
|
|
);
|
|
}
|
|
|
|
factory PlaylistEntry.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return PlaylistEntry(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
playlistId: serializer.fromJson<int>(json['playlistId']),
|
|
trackId: serializer.fromJson<int>(json['trackId']),
|
|
addedAt: serializer.fromJson<DateTime>(json['addedAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'playlistId': serializer.toJson<int>(playlistId),
|
|
'trackId': serializer.toJson<int>(trackId),
|
|
'addedAt': serializer.toJson<DateTime>(addedAt),
|
|
};
|
|
}
|
|
|
|
PlaylistEntry copyWith({
|
|
int? id,
|
|
int? playlistId,
|
|
int? trackId,
|
|
DateTime? addedAt,
|
|
}) => PlaylistEntry(
|
|
id: id ?? this.id,
|
|
playlistId: playlistId ?? this.playlistId,
|
|
trackId: trackId ?? this.trackId,
|
|
addedAt: addedAt ?? this.addedAt,
|
|
);
|
|
PlaylistEntry copyWithCompanion(PlaylistEntriesCompanion data) {
|
|
return PlaylistEntry(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
playlistId: data.playlistId.present
|
|
? data.playlistId.value
|
|
: this.playlistId,
|
|
trackId: data.trackId.present ? data.trackId.value : this.trackId,
|
|
addedAt: data.addedAt.present ? data.addedAt.value : this.addedAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('PlaylistEntry(')
|
|
..write('id: $id, ')
|
|
..write('playlistId: $playlistId, ')
|
|
..write('trackId: $trackId, ')
|
|
..write('addedAt: $addedAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, playlistId, trackId, addedAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is PlaylistEntry &&
|
|
other.id == this.id &&
|
|
other.playlistId == this.playlistId &&
|
|
other.trackId == this.trackId &&
|
|
other.addedAt == this.addedAt);
|
|
}
|
|
|
|
class PlaylistEntriesCompanion extends UpdateCompanion<PlaylistEntry> {
|
|
final Value<int> id;
|
|
final Value<int> playlistId;
|
|
final Value<int> trackId;
|
|
final Value<DateTime> addedAt;
|
|
const PlaylistEntriesCompanion({
|
|
this.id = const Value.absent(),
|
|
this.playlistId = const Value.absent(),
|
|
this.trackId = const Value.absent(),
|
|
this.addedAt = const Value.absent(),
|
|
});
|
|
PlaylistEntriesCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required int playlistId,
|
|
required int trackId,
|
|
this.addedAt = const Value.absent(),
|
|
}) : playlistId = Value(playlistId),
|
|
trackId = Value(trackId);
|
|
static Insertable<PlaylistEntry> custom({
|
|
Expression<int>? id,
|
|
Expression<int>? playlistId,
|
|
Expression<int>? trackId,
|
|
Expression<DateTime>? addedAt,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (playlistId != null) 'playlist_id': playlistId,
|
|
if (trackId != null) 'track_id': trackId,
|
|
if (addedAt != null) 'added_at': addedAt,
|
|
});
|
|
}
|
|
|
|
PlaylistEntriesCompanion copyWith({
|
|
Value<int>? id,
|
|
Value<int>? playlistId,
|
|
Value<int>? trackId,
|
|
Value<DateTime>? addedAt,
|
|
}) {
|
|
return PlaylistEntriesCompanion(
|
|
id: id ?? this.id,
|
|
playlistId: playlistId ?? this.playlistId,
|
|
trackId: trackId ?? this.trackId,
|
|
addedAt: addedAt ?? this.addedAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<int>(id.value);
|
|
}
|
|
if (playlistId.present) {
|
|
map['playlist_id'] = Variable<int>(playlistId.value);
|
|
}
|
|
if (trackId.present) {
|
|
map['track_id'] = Variable<int>(trackId.value);
|
|
}
|
|
if (addedAt.present) {
|
|
map['added_at'] = Variable<DateTime>(addedAt.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('PlaylistEntriesCompanion(')
|
|
..write('id: $id, ')
|
|
..write('playlistId: $playlistId, ')
|
|
..write('trackId: $trackId, ')
|
|
..write('addedAt: $addedAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
abstract class _$AppDatabase extends GeneratedDatabase {
|
|
_$AppDatabase(QueryExecutor e) : super(e);
|
|
$AppDatabaseManager get managers => $AppDatabaseManager(this);
|
|
late final $TracksTable tracks = $TracksTable(this);
|
|
late final $PlaylistsTable playlists = $PlaylistsTable(this);
|
|
late final $PlaylistEntriesTable playlistEntries = $PlaylistEntriesTable(
|
|
this,
|
|
);
|
|
@override
|
|
Iterable<TableInfo<Table, Object?>> get allTables =>
|
|
allSchemaEntities.whereType<TableInfo<Table, Object?>>();
|
|
@override
|
|
List<DatabaseSchemaEntity> get allSchemaEntities => [
|
|
tracks,
|
|
playlists,
|
|
playlistEntries,
|
|
];
|
|
@override
|
|
StreamQueryUpdateRules get streamUpdateRules => const StreamQueryUpdateRules([
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName(
|
|
'tracks',
|
|
limitUpdateKind: UpdateKind.delete,
|
|
),
|
|
result: [TableUpdate('playlist_entries', kind: UpdateKind.delete)],
|
|
),
|
|
]);
|
|
}
|
|
|
|
typedef $$TracksTableCreateCompanionBuilder =
|
|
TracksCompanion Function({
|
|
Value<int> id,
|
|
required String title,
|
|
Value<String?> artist,
|
|
Value<String?> album,
|
|
Value<int?> duration,
|
|
required String path,
|
|
Value<String?> artUri,
|
|
Value<String?> lyrics,
|
|
Value<int> lyricsOffset,
|
|
Value<DateTime> addedAt,
|
|
});
|
|
typedef $$TracksTableUpdateCompanionBuilder =
|
|
TracksCompanion Function({
|
|
Value<int> id,
|
|
Value<String> title,
|
|
Value<String?> artist,
|
|
Value<String?> album,
|
|
Value<int?> duration,
|
|
Value<String> path,
|
|
Value<String?> artUri,
|
|
Value<String?> lyrics,
|
|
Value<int> lyricsOffset,
|
|
Value<DateTime> addedAt,
|
|
});
|
|
|
|
final class $$TracksTableReferences
|
|
extends BaseReferences<_$AppDatabase, $TracksTable, Track> {
|
|
$$TracksTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$PlaylistEntriesTable, List<PlaylistEntry>>
|
|
_playlistEntriesRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.playlistEntries,
|
|
aliasName: $_aliasNameGenerator(db.tracks.id, db.playlistEntries.trackId),
|
|
);
|
|
|
|
$$PlaylistEntriesTableProcessedTableManager get playlistEntriesRefs {
|
|
final manager = $$PlaylistEntriesTableTableManager(
|
|
$_db,
|
|
$_db.playlistEntries,
|
|
).filter((f) => f.trackId.id.sqlEquals($_itemColumn<int>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(
|
|
_playlistEntriesRefsTable($_db),
|
|
);
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$TracksTableFilterComposer
|
|
extends Composer<_$AppDatabase, $TracksTable> {
|
|
$$TracksTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get title => $composableBuilder(
|
|
column: $table.title,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get artist => $composableBuilder(
|
|
column: $table.artist,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get album => $composableBuilder(
|
|
column: $table.album,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get duration => $composableBuilder(
|
|
column: $table.duration,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get path => $composableBuilder(
|
|
column: $table.path,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get artUri => $composableBuilder(
|
|
column: $table.artUri,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get lyrics => $composableBuilder(
|
|
column: $table.lyrics,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get lyricsOffset => $composableBuilder(
|
|
column: $table.lyricsOffset,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get addedAt => $composableBuilder(
|
|
column: $table.addedAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
Expression<bool> playlistEntriesRefs(
|
|
Expression<bool> Function($$PlaylistEntriesTableFilterComposer f) f,
|
|
) {
|
|
final $$PlaylistEntriesTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.playlistEntries,
|
|
getReferencedColumn: (t) => t.trackId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlaylistEntriesTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.playlistEntries,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$TracksTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $TracksTable> {
|
|
$$TracksTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get title => $composableBuilder(
|
|
column: $table.title,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get artist => $composableBuilder(
|
|
column: $table.artist,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get album => $composableBuilder(
|
|
column: $table.album,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get duration => $composableBuilder(
|
|
column: $table.duration,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get path => $composableBuilder(
|
|
column: $table.path,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get artUri => $composableBuilder(
|
|
column: $table.artUri,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get lyrics => $composableBuilder(
|
|
column: $table.lyrics,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get lyricsOffset => $composableBuilder(
|
|
column: $table.lyricsOffset,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get addedAt => $composableBuilder(
|
|
column: $table.addedAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$TracksTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $TracksTable> {
|
|
$$TracksTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<int> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get title =>
|
|
$composableBuilder(column: $table.title, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get artist =>
|
|
$composableBuilder(column: $table.artist, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get album =>
|
|
$composableBuilder(column: $table.album, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get duration =>
|
|
$composableBuilder(column: $table.duration, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get path =>
|
|
$composableBuilder(column: $table.path, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get artUri =>
|
|
$composableBuilder(column: $table.artUri, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get lyrics =>
|
|
$composableBuilder(column: $table.lyrics, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get lyricsOffset => $composableBuilder(
|
|
column: $table.lyricsOffset,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<DateTime> get addedAt =>
|
|
$composableBuilder(column: $table.addedAt, builder: (column) => column);
|
|
|
|
Expression<T> playlistEntriesRefs<T extends Object>(
|
|
Expression<T> Function($$PlaylistEntriesTableAnnotationComposer a) f,
|
|
) {
|
|
final $$PlaylistEntriesTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.playlistEntries,
|
|
getReferencedColumn: (t) => t.trackId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlaylistEntriesTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.playlistEntries,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$TracksTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$TracksTable,
|
|
Track,
|
|
$$TracksTableFilterComposer,
|
|
$$TracksTableOrderingComposer,
|
|
$$TracksTableAnnotationComposer,
|
|
$$TracksTableCreateCompanionBuilder,
|
|
$$TracksTableUpdateCompanionBuilder,
|
|
(Track, $$TracksTableReferences),
|
|
Track,
|
|
PrefetchHooks Function({bool playlistEntriesRefs})
|
|
> {
|
|
$$TracksTableTableManager(_$AppDatabase db, $TracksTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$TracksTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$TracksTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$TracksTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
Value<String> title = const Value.absent(),
|
|
Value<String?> artist = const Value.absent(),
|
|
Value<String?> album = const Value.absent(),
|
|
Value<int?> duration = const Value.absent(),
|
|
Value<String> path = const Value.absent(),
|
|
Value<String?> artUri = const Value.absent(),
|
|
Value<String?> lyrics = const Value.absent(),
|
|
Value<int> lyricsOffset = const Value.absent(),
|
|
Value<DateTime> addedAt = const Value.absent(),
|
|
}) => TracksCompanion(
|
|
id: id,
|
|
title: title,
|
|
artist: artist,
|
|
album: album,
|
|
duration: duration,
|
|
path: path,
|
|
artUri: artUri,
|
|
lyrics: lyrics,
|
|
lyricsOffset: lyricsOffset,
|
|
addedAt: addedAt,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
required String title,
|
|
Value<String?> artist = const Value.absent(),
|
|
Value<String?> album = const Value.absent(),
|
|
Value<int?> duration = const Value.absent(),
|
|
required String path,
|
|
Value<String?> artUri = const Value.absent(),
|
|
Value<String?> lyrics = const Value.absent(),
|
|
Value<int> lyricsOffset = const Value.absent(),
|
|
Value<DateTime> addedAt = const Value.absent(),
|
|
}) => TracksCompanion.insert(
|
|
id: id,
|
|
title: title,
|
|
artist: artist,
|
|
album: album,
|
|
duration: duration,
|
|
path: path,
|
|
artUri: artUri,
|
|
lyrics: lyrics,
|
|
lyricsOffset: lyricsOffset,
|
|
addedAt: addedAt,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) =>
|
|
(e.readTable(table), $$TracksTableReferences(db, table, e)),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({playlistEntriesRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [
|
|
if (playlistEntriesRefs) db.playlistEntries,
|
|
],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (playlistEntriesRefs)
|
|
await $_getPrefetchedData<
|
|
Track,
|
|
$TracksTable,
|
|
PlaylistEntry
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$TracksTableReferences
|
|
._playlistEntriesRefsTable(db),
|
|
managerFromTypedResult: (p0) => $$TracksTableReferences(
|
|
db,
|
|
table,
|
|
p0,
|
|
).playlistEntriesRefs,
|
|
referencedItemsForCurrentItem: (item, referencedItems) =>
|
|
referencedItems.where((e) => e.trackId == item.id),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$TracksTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$TracksTable,
|
|
Track,
|
|
$$TracksTableFilterComposer,
|
|
$$TracksTableOrderingComposer,
|
|
$$TracksTableAnnotationComposer,
|
|
$$TracksTableCreateCompanionBuilder,
|
|
$$TracksTableUpdateCompanionBuilder,
|
|
(Track, $$TracksTableReferences),
|
|
Track,
|
|
PrefetchHooks Function({bool playlistEntriesRefs})
|
|
>;
|
|
typedef $$PlaylistsTableCreateCompanionBuilder =
|
|
PlaylistsCompanion Function({
|
|
Value<int> id,
|
|
required String name,
|
|
Value<DateTime> createdAt,
|
|
});
|
|
typedef $$PlaylistsTableUpdateCompanionBuilder =
|
|
PlaylistsCompanion Function({
|
|
Value<int> id,
|
|
Value<String> name,
|
|
Value<DateTime> createdAt,
|
|
});
|
|
|
|
final class $$PlaylistsTableReferences
|
|
extends BaseReferences<_$AppDatabase, $PlaylistsTable, Playlist> {
|
|
$$PlaylistsTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$PlaylistEntriesTable, List<PlaylistEntry>>
|
|
_playlistEntriesRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.playlistEntries,
|
|
aliasName: $_aliasNameGenerator(
|
|
db.playlists.id,
|
|
db.playlistEntries.playlistId,
|
|
),
|
|
);
|
|
|
|
$$PlaylistEntriesTableProcessedTableManager get playlistEntriesRefs {
|
|
final manager = $$PlaylistEntriesTableTableManager(
|
|
$_db,
|
|
$_db.playlistEntries,
|
|
).filter((f) => f.playlistId.id.sqlEquals($_itemColumn<int>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(
|
|
_playlistEntriesRefsTable($_db),
|
|
);
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$PlaylistsTableFilterComposer
|
|
extends Composer<_$AppDatabase, $PlaylistsTable> {
|
|
$$PlaylistsTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get name => $composableBuilder(
|
|
column: $table.name,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
Expression<bool> playlistEntriesRefs(
|
|
Expression<bool> Function($$PlaylistEntriesTableFilterComposer f) f,
|
|
) {
|
|
final $$PlaylistEntriesTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.playlistEntries,
|
|
getReferencedColumn: (t) => t.playlistId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlaylistEntriesTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.playlistEntries,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$PlaylistsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $PlaylistsTable> {
|
|
$$PlaylistsTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get name => $composableBuilder(
|
|
column: $table.name,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$PlaylistsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $PlaylistsTable> {
|
|
$$PlaylistsTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<int> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get name =>
|
|
$composableBuilder(column: $table.name, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
Expression<T> playlistEntriesRefs<T extends Object>(
|
|
Expression<T> Function($$PlaylistEntriesTableAnnotationComposer a) f,
|
|
) {
|
|
final $$PlaylistEntriesTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.playlistEntries,
|
|
getReferencedColumn: (t) => t.playlistId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlaylistEntriesTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.playlistEntries,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$PlaylistsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$PlaylistsTable,
|
|
Playlist,
|
|
$$PlaylistsTableFilterComposer,
|
|
$$PlaylistsTableOrderingComposer,
|
|
$$PlaylistsTableAnnotationComposer,
|
|
$$PlaylistsTableCreateCompanionBuilder,
|
|
$$PlaylistsTableUpdateCompanionBuilder,
|
|
(Playlist, $$PlaylistsTableReferences),
|
|
Playlist,
|
|
PrefetchHooks Function({bool playlistEntriesRefs})
|
|
> {
|
|
$$PlaylistsTableTableManager(_$AppDatabase db, $PlaylistsTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$PlaylistsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$PlaylistsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$PlaylistsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
Value<String> name = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
}) =>
|
|
PlaylistsCompanion(id: id, name: name, createdAt: createdAt),
|
|
createCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
required String name,
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
}) => PlaylistsCompanion.insert(
|
|
id: id,
|
|
name: name,
|
|
createdAt: createdAt,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$PlaylistsTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({playlistEntriesRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [
|
|
if (playlistEntriesRefs) db.playlistEntries,
|
|
],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (playlistEntriesRefs)
|
|
await $_getPrefetchedData<
|
|
Playlist,
|
|
$PlaylistsTable,
|
|
PlaylistEntry
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$PlaylistsTableReferences
|
|
._playlistEntriesRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$PlaylistsTableReferences(
|
|
db,
|
|
table,
|
|
p0,
|
|
).playlistEntriesRefs,
|
|
referencedItemsForCurrentItem: (item, referencedItems) =>
|
|
referencedItems.where((e) => e.playlistId == item.id),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$PlaylistsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$PlaylistsTable,
|
|
Playlist,
|
|
$$PlaylistsTableFilterComposer,
|
|
$$PlaylistsTableOrderingComposer,
|
|
$$PlaylistsTableAnnotationComposer,
|
|
$$PlaylistsTableCreateCompanionBuilder,
|
|
$$PlaylistsTableUpdateCompanionBuilder,
|
|
(Playlist, $$PlaylistsTableReferences),
|
|
Playlist,
|
|
PrefetchHooks Function({bool playlistEntriesRefs})
|
|
>;
|
|
typedef $$PlaylistEntriesTableCreateCompanionBuilder =
|
|
PlaylistEntriesCompanion Function({
|
|
Value<int> id,
|
|
required int playlistId,
|
|
required int trackId,
|
|
Value<DateTime> addedAt,
|
|
});
|
|
typedef $$PlaylistEntriesTableUpdateCompanionBuilder =
|
|
PlaylistEntriesCompanion Function({
|
|
Value<int> id,
|
|
Value<int> playlistId,
|
|
Value<int> trackId,
|
|
Value<DateTime> addedAt,
|
|
});
|
|
|
|
final class $$PlaylistEntriesTableReferences
|
|
extends
|
|
BaseReferences<_$AppDatabase, $PlaylistEntriesTable, PlaylistEntry> {
|
|
$$PlaylistEntriesTableReferences(
|
|
super.$_db,
|
|
super.$_table,
|
|
super.$_typedResult,
|
|
);
|
|
|
|
static $PlaylistsTable _playlistIdTable(_$AppDatabase db) =>
|
|
db.playlists.createAlias(
|
|
$_aliasNameGenerator(db.playlistEntries.playlistId, db.playlists.id),
|
|
);
|
|
|
|
$$PlaylistsTableProcessedTableManager get playlistId {
|
|
final $_column = $_itemColumn<int>('playlist_id')!;
|
|
|
|
final manager = $$PlaylistsTableTableManager(
|
|
$_db,
|
|
$_db.playlists,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_playlistIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
|
|
static $TracksTable _trackIdTable(_$AppDatabase db) => db.tracks.createAlias(
|
|
$_aliasNameGenerator(db.playlistEntries.trackId, db.tracks.id),
|
|
);
|
|
|
|
$$TracksTableProcessedTableManager get trackId {
|
|
final $_column = $_itemColumn<int>('track_id')!;
|
|
|
|
final manager = $$TracksTableTableManager(
|
|
$_db,
|
|
$_db.tracks,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_trackIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$PlaylistEntriesTableFilterComposer
|
|
extends Composer<_$AppDatabase, $PlaylistEntriesTable> {
|
|
$$PlaylistEntriesTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get addedAt => $composableBuilder(
|
|
column: $table.addedAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
$$PlaylistsTableFilterComposer get playlistId {
|
|
final $$PlaylistsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.playlistId,
|
|
referencedTable: $db.playlists,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlaylistsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.playlists,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$TracksTableFilterComposer get trackId {
|
|
final $$TracksTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.trackId,
|
|
referencedTable: $db.tracks,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TracksTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.tracks,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$PlaylistEntriesTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $PlaylistEntriesTable> {
|
|
$$PlaylistEntriesTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get addedAt => $composableBuilder(
|
|
column: $table.addedAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
$$PlaylistsTableOrderingComposer get playlistId {
|
|
final $$PlaylistsTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.playlistId,
|
|
referencedTable: $db.playlists,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlaylistsTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.playlists,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$TracksTableOrderingComposer get trackId {
|
|
final $$TracksTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.trackId,
|
|
referencedTable: $db.tracks,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TracksTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.tracks,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$PlaylistEntriesTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $PlaylistEntriesTable> {
|
|
$$PlaylistEntriesTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<int> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get addedAt =>
|
|
$composableBuilder(column: $table.addedAt, builder: (column) => column);
|
|
|
|
$$PlaylistsTableAnnotationComposer get playlistId {
|
|
final $$PlaylistsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.playlistId,
|
|
referencedTable: $db.playlists,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$PlaylistsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.playlists,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$TracksTableAnnotationComposer get trackId {
|
|
final $$TracksTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.trackId,
|
|
referencedTable: $db.tracks,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TracksTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.tracks,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$PlaylistEntriesTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$PlaylistEntriesTable,
|
|
PlaylistEntry,
|
|
$$PlaylistEntriesTableFilterComposer,
|
|
$$PlaylistEntriesTableOrderingComposer,
|
|
$$PlaylistEntriesTableAnnotationComposer,
|
|
$$PlaylistEntriesTableCreateCompanionBuilder,
|
|
$$PlaylistEntriesTableUpdateCompanionBuilder,
|
|
(PlaylistEntry, $$PlaylistEntriesTableReferences),
|
|
PlaylistEntry,
|
|
PrefetchHooks Function({bool playlistId, bool trackId})
|
|
> {
|
|
$$PlaylistEntriesTableTableManager(
|
|
_$AppDatabase db,
|
|
$PlaylistEntriesTable table,
|
|
) : super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$PlaylistEntriesTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$PlaylistEntriesTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$PlaylistEntriesTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
Value<int> playlistId = const Value.absent(),
|
|
Value<int> trackId = const Value.absent(),
|
|
Value<DateTime> addedAt = const Value.absent(),
|
|
}) => PlaylistEntriesCompanion(
|
|
id: id,
|
|
playlistId: playlistId,
|
|
trackId: trackId,
|
|
addedAt: addedAt,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
required int playlistId,
|
|
required int trackId,
|
|
Value<DateTime> addedAt = const Value.absent(),
|
|
}) => PlaylistEntriesCompanion.insert(
|
|
id: id,
|
|
playlistId: playlistId,
|
|
trackId: trackId,
|
|
addedAt: addedAt,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$PlaylistEntriesTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({playlistId = false, trackId = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [],
|
|
addJoins:
|
|
<
|
|
T extends TableManagerState<
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic
|
|
>
|
|
>(state) {
|
|
if (playlistId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.playlistId,
|
|
referencedTable:
|
|
$$PlaylistEntriesTableReferences
|
|
._playlistIdTable(db),
|
|
referencedColumn:
|
|
$$PlaylistEntriesTableReferences
|
|
._playlistIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
if (trackId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.trackId,
|
|
referencedTable:
|
|
$$PlaylistEntriesTableReferences
|
|
._trackIdTable(db),
|
|
referencedColumn:
|
|
$$PlaylistEntriesTableReferences
|
|
._trackIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$PlaylistEntriesTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$PlaylistEntriesTable,
|
|
PlaylistEntry,
|
|
$$PlaylistEntriesTableFilterComposer,
|
|
$$PlaylistEntriesTableOrderingComposer,
|
|
$$PlaylistEntriesTableAnnotationComposer,
|
|
$$PlaylistEntriesTableCreateCompanionBuilder,
|
|
$$PlaylistEntriesTableUpdateCompanionBuilder,
|
|
(PlaylistEntry, $$PlaylistEntriesTableReferences),
|
|
PlaylistEntry,
|
|
PrefetchHooks Function({bool playlistId, bool trackId})
|
|
>;
|
|
|
|
class $AppDatabaseManager {
|
|
final _$AppDatabase _db;
|
|
$AppDatabaseManager(this._db);
|
|
$$TracksTableTableManager get tracks =>
|
|
$$TracksTableTableManager(_db, _db.tracks);
|
|
$$PlaylistsTableTableManager get playlists =>
|
|
$$PlaylistsTableTableManager(_db, _db.playlists);
|
|
$$PlaylistEntriesTableTableManager get playlistEntries =>
|
|
$$PlaylistEntriesTableTableManager(_db, _db.playlistEntries);
|
|
}
|