3793 lines
115 KiB
Dart
3793 lines
115 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'database.dart';
|
|
|
|
// ignore_for_file: type=lint
|
|
class $HistoryItemsTable extends HistoryItems
|
|
with TableInfo<$HistoryItemsTable, HistoryItem> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$HistoryItemsTable(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 _urlMeta = const VerificationMeta('url');
|
|
@override
|
|
late final GeneratedColumn<String> url = GeneratedColumn<String>(
|
|
'url',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _titleMeta = const VerificationMeta('title');
|
|
@override
|
|
late final GeneratedColumn<String> title = GeneratedColumn<String>(
|
|
'title',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _visitedAtMeta = const VerificationMeta(
|
|
'visitedAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> visitedAt = GeneratedColumn<DateTime>(
|
|
'visited_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
defaultValue: currentDateAndTime,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, url, title, visitedAt];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'history_items';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<HistoryItem> 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('url')) {
|
|
context.handle(
|
|
_urlMeta,
|
|
url.isAcceptableOrUnknown(data['url']!, _urlMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_urlMeta);
|
|
}
|
|
if (data.containsKey('title')) {
|
|
context.handle(
|
|
_titleMeta,
|
|
title.isAcceptableOrUnknown(data['title']!, _titleMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('visited_at')) {
|
|
context.handle(
|
|
_visitedAtMeta,
|
|
visitedAt.isAcceptableOrUnknown(data['visited_at']!, _visitedAtMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
HistoryItem map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return HistoryItem(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
url: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}url'],
|
|
)!,
|
|
title: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}title'],
|
|
),
|
|
visitedAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}visited_at'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$HistoryItemsTable createAlias(String alias) {
|
|
return $HistoryItemsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class HistoryItem extends DataClass implements Insertable<HistoryItem> {
|
|
final int id;
|
|
final String url;
|
|
final String? title;
|
|
final DateTime visitedAt;
|
|
const HistoryItem({
|
|
required this.id,
|
|
required this.url,
|
|
this.title,
|
|
required this.visitedAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['url'] = Variable<String>(url);
|
|
if (!nullToAbsent || title != null) {
|
|
map['title'] = Variable<String>(title);
|
|
}
|
|
map['visited_at'] = Variable<DateTime>(visitedAt);
|
|
return map;
|
|
}
|
|
|
|
HistoryItemsCompanion toCompanion(bool nullToAbsent) {
|
|
return HistoryItemsCompanion(
|
|
id: Value(id),
|
|
url: Value(url),
|
|
title: title == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(title),
|
|
visitedAt: Value(visitedAt),
|
|
);
|
|
}
|
|
|
|
factory HistoryItem.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return HistoryItem(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
url: serializer.fromJson<String>(json['url']),
|
|
title: serializer.fromJson<String?>(json['title']),
|
|
visitedAt: serializer.fromJson<DateTime>(json['visitedAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'url': serializer.toJson<String>(url),
|
|
'title': serializer.toJson<String?>(title),
|
|
'visitedAt': serializer.toJson<DateTime>(visitedAt),
|
|
};
|
|
}
|
|
|
|
HistoryItem copyWith({
|
|
int? id,
|
|
String? url,
|
|
Value<String?> title = const Value.absent(),
|
|
DateTime? visitedAt,
|
|
}) => HistoryItem(
|
|
id: id ?? this.id,
|
|
url: url ?? this.url,
|
|
title: title.present ? title.value : this.title,
|
|
visitedAt: visitedAt ?? this.visitedAt,
|
|
);
|
|
HistoryItem copyWithCompanion(HistoryItemsCompanion data) {
|
|
return HistoryItem(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
url: data.url.present ? data.url.value : this.url,
|
|
title: data.title.present ? data.title.value : this.title,
|
|
visitedAt: data.visitedAt.present ? data.visitedAt.value : this.visitedAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('HistoryItem(')
|
|
..write('id: $id, ')
|
|
..write('url: $url, ')
|
|
..write('title: $title, ')
|
|
..write('visitedAt: $visitedAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, url, title, visitedAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is HistoryItem &&
|
|
other.id == this.id &&
|
|
other.url == this.url &&
|
|
other.title == this.title &&
|
|
other.visitedAt == this.visitedAt);
|
|
}
|
|
|
|
class HistoryItemsCompanion extends UpdateCompanion<HistoryItem> {
|
|
final Value<int> id;
|
|
final Value<String> url;
|
|
final Value<String?> title;
|
|
final Value<DateTime> visitedAt;
|
|
const HistoryItemsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.url = const Value.absent(),
|
|
this.title = const Value.absent(),
|
|
this.visitedAt = const Value.absent(),
|
|
});
|
|
HistoryItemsCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required String url,
|
|
this.title = const Value.absent(),
|
|
this.visitedAt = const Value.absent(),
|
|
}) : url = Value(url);
|
|
static Insertable<HistoryItem> custom({
|
|
Expression<int>? id,
|
|
Expression<String>? url,
|
|
Expression<String>? title,
|
|
Expression<DateTime>? visitedAt,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (url != null) 'url': url,
|
|
if (title != null) 'title': title,
|
|
if (visitedAt != null) 'visited_at': visitedAt,
|
|
});
|
|
}
|
|
|
|
HistoryItemsCompanion copyWith({
|
|
Value<int>? id,
|
|
Value<String>? url,
|
|
Value<String?>? title,
|
|
Value<DateTime>? visitedAt,
|
|
}) {
|
|
return HistoryItemsCompanion(
|
|
id: id ?? this.id,
|
|
url: url ?? this.url,
|
|
title: title ?? this.title,
|
|
visitedAt: visitedAt ?? this.visitedAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<int>(id.value);
|
|
}
|
|
if (url.present) {
|
|
map['url'] = Variable<String>(url.value);
|
|
}
|
|
if (title.present) {
|
|
map['title'] = Variable<String>(title.value);
|
|
}
|
|
if (visitedAt.present) {
|
|
map['visited_at'] = Variable<DateTime>(visitedAt.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('HistoryItemsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('url: $url, ')
|
|
..write('title: $title, ')
|
|
..write('visitedAt: $visitedAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $BookmarksTable extends Bookmarks
|
|
with TableInfo<$BookmarksTable, Bookmark> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$BookmarksTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _urlMeta = const VerificationMeta('url');
|
|
@override
|
|
late final GeneratedColumn<String> url = GeneratedColumn<String>(
|
|
'url',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _titleMeta = const VerificationMeta('title');
|
|
@override
|
|
late final GeneratedColumn<String> title = GeneratedColumn<String>(
|
|
'title',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _createdAtMeta = const VerificationMeta(
|
|
'createdAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
defaultValue: currentDateAndTime,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [url, title, createdAt];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'bookmarks';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<Bookmark> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('url')) {
|
|
context.handle(
|
|
_urlMeta,
|
|
url.isAcceptableOrUnknown(data['url']!, _urlMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_urlMeta);
|
|
}
|
|
if (data.containsKey('title')) {
|
|
context.handle(
|
|
_titleMeta,
|
|
title.isAcceptableOrUnknown(data['title']!, _titleMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(
|
|
_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {url};
|
|
@override
|
|
Bookmark map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return Bookmark(
|
|
url: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}url'],
|
|
)!,
|
|
title: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}title'],
|
|
),
|
|
createdAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}created_at'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$BookmarksTable createAlias(String alias) {
|
|
return $BookmarksTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class Bookmark extends DataClass implements Insertable<Bookmark> {
|
|
final String url;
|
|
final String? title;
|
|
final DateTime createdAt;
|
|
const Bookmark({required this.url, this.title, required this.createdAt});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['url'] = Variable<String>(url);
|
|
if (!nullToAbsent || title != null) {
|
|
map['title'] = Variable<String>(title);
|
|
}
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
return map;
|
|
}
|
|
|
|
BookmarksCompanion toCompanion(bool nullToAbsent) {
|
|
return BookmarksCompanion(
|
|
url: Value(url),
|
|
title: title == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(title),
|
|
createdAt: Value(createdAt),
|
|
);
|
|
}
|
|
|
|
factory Bookmark.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return Bookmark(
|
|
url: serializer.fromJson<String>(json['url']),
|
|
title: serializer.fromJson<String?>(json['title']),
|
|
createdAt: serializer.fromJson<DateTime>(json['createdAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'url': serializer.toJson<String>(url),
|
|
'title': serializer.toJson<String?>(title),
|
|
'createdAt': serializer.toJson<DateTime>(createdAt),
|
|
};
|
|
}
|
|
|
|
Bookmark copyWith({
|
|
String? url,
|
|
Value<String?> title = const Value.absent(),
|
|
DateTime? createdAt,
|
|
}) => Bookmark(
|
|
url: url ?? this.url,
|
|
title: title.present ? title.value : this.title,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
);
|
|
Bookmark copyWithCompanion(BookmarksCompanion data) {
|
|
return Bookmark(
|
|
url: data.url.present ? data.url.value : this.url,
|
|
title: data.title.present ? data.title.value : this.title,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Bookmark(')
|
|
..write('url: $url, ')
|
|
..write('title: $title, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(url, title, createdAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is Bookmark &&
|
|
other.url == this.url &&
|
|
other.title == this.title &&
|
|
other.createdAt == this.createdAt);
|
|
}
|
|
|
|
class BookmarksCompanion extends UpdateCompanion<Bookmark> {
|
|
final Value<String> url;
|
|
final Value<String?> title;
|
|
final Value<DateTime> createdAt;
|
|
final Value<int> rowid;
|
|
const BookmarksCompanion({
|
|
this.url = const Value.absent(),
|
|
this.title = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
BookmarksCompanion.insert({
|
|
required String url,
|
|
this.title = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
}) : url = Value(url);
|
|
static Insertable<Bookmark> custom({
|
|
Expression<String>? url,
|
|
Expression<String>? title,
|
|
Expression<DateTime>? createdAt,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (url != null) 'url': url,
|
|
if (title != null) 'title': title,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
BookmarksCompanion copyWith({
|
|
Value<String>? url,
|
|
Value<String?>? title,
|
|
Value<DateTime>? createdAt,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return BookmarksCompanion(
|
|
url: url ?? this.url,
|
|
title: title ?? this.title,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (url.present) {
|
|
map['url'] = Variable<String>(url.value);
|
|
}
|
|
if (title.present) {
|
|
map['title'] = Variable<String>(title.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('BookmarksCompanion(')
|
|
..write('url: $url, ')
|
|
..write('title: $title, ')
|
|
..write('createdAt: $createdAt, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $SubscriptionsTable extends Subscriptions
|
|
with TableInfo<$SubscriptionsTable, Subscription> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$SubscriptionsTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _urlMeta = const VerificationMeta('url');
|
|
@override
|
|
late final GeneratedColumn<String> url = GeneratedColumn<String>(
|
|
'url',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _titleMeta = const VerificationMeta('title');
|
|
@override
|
|
late final GeneratedColumn<String> title = GeneratedColumn<String>(
|
|
'title',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _atomHrefMeta = const VerificationMeta(
|
|
'atomHref',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> atomHref = GeneratedColumn<String>(
|
|
'atom_href',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _createdAtMeta = const VerificationMeta(
|
|
'createdAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
defaultValue: currentDateAndTime,
|
|
);
|
|
static const VerificationMeta _lastCheckedAtMeta = const VerificationMeta(
|
|
'lastCheckedAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> lastCheckedAt =
|
|
GeneratedColumn<DateTime>(
|
|
'last_checked_at',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
url,
|
|
title,
|
|
atomHref,
|
|
createdAt,
|
|
lastCheckedAt,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'subscriptions';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<Subscription> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('url')) {
|
|
context.handle(
|
|
_urlMeta,
|
|
url.isAcceptableOrUnknown(data['url']!, _urlMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_urlMeta);
|
|
}
|
|
if (data.containsKey('title')) {
|
|
context.handle(
|
|
_titleMeta,
|
|
title.isAcceptableOrUnknown(data['title']!, _titleMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('atom_href')) {
|
|
context.handle(
|
|
_atomHrefMeta,
|
|
atomHref.isAcceptableOrUnknown(data['atom_href']!, _atomHrefMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(
|
|
_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('last_checked_at')) {
|
|
context.handle(
|
|
_lastCheckedAtMeta,
|
|
lastCheckedAt.isAcceptableOrUnknown(
|
|
data['last_checked_at']!,
|
|
_lastCheckedAtMeta,
|
|
),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {url};
|
|
@override
|
|
Subscription map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return Subscription(
|
|
url: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}url'],
|
|
)!,
|
|
title: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}title'],
|
|
),
|
|
atomHref: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}atom_href'],
|
|
),
|
|
createdAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}created_at'],
|
|
)!,
|
|
lastCheckedAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}last_checked_at'],
|
|
),
|
|
);
|
|
}
|
|
|
|
@override
|
|
$SubscriptionsTable createAlias(String alias) {
|
|
return $SubscriptionsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class Subscription extends DataClass implements Insertable<Subscription> {
|
|
final String url;
|
|
final String? title;
|
|
|
|
/// The page's Atom feed, resolved absolute, when it declares one (spec 6.2).
|
|
final String? atomHref;
|
|
final DateTime createdAt;
|
|
final DateTime? lastCheckedAt;
|
|
const Subscription({
|
|
required this.url,
|
|
this.title,
|
|
this.atomHref,
|
|
required this.createdAt,
|
|
this.lastCheckedAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['url'] = Variable<String>(url);
|
|
if (!nullToAbsent || title != null) {
|
|
map['title'] = Variable<String>(title);
|
|
}
|
|
if (!nullToAbsent || atomHref != null) {
|
|
map['atom_href'] = Variable<String>(atomHref);
|
|
}
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
if (!nullToAbsent || lastCheckedAt != null) {
|
|
map['last_checked_at'] = Variable<DateTime>(lastCheckedAt);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
SubscriptionsCompanion toCompanion(bool nullToAbsent) {
|
|
return SubscriptionsCompanion(
|
|
url: Value(url),
|
|
title: title == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(title),
|
|
atomHref: atomHref == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(atomHref),
|
|
createdAt: Value(createdAt),
|
|
lastCheckedAt: lastCheckedAt == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(lastCheckedAt),
|
|
);
|
|
}
|
|
|
|
factory Subscription.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return Subscription(
|
|
url: serializer.fromJson<String>(json['url']),
|
|
title: serializer.fromJson<String?>(json['title']),
|
|
atomHref: serializer.fromJson<String?>(json['atomHref']),
|
|
createdAt: serializer.fromJson<DateTime>(json['createdAt']),
|
|
lastCheckedAt: serializer.fromJson<DateTime?>(json['lastCheckedAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'url': serializer.toJson<String>(url),
|
|
'title': serializer.toJson<String?>(title),
|
|
'atomHref': serializer.toJson<String?>(atomHref),
|
|
'createdAt': serializer.toJson<DateTime>(createdAt),
|
|
'lastCheckedAt': serializer.toJson<DateTime?>(lastCheckedAt),
|
|
};
|
|
}
|
|
|
|
Subscription copyWith({
|
|
String? url,
|
|
Value<String?> title = const Value.absent(),
|
|
Value<String?> atomHref = const Value.absent(),
|
|
DateTime? createdAt,
|
|
Value<DateTime?> lastCheckedAt = const Value.absent(),
|
|
}) => Subscription(
|
|
url: url ?? this.url,
|
|
title: title.present ? title.value : this.title,
|
|
atomHref: atomHref.present ? atomHref.value : this.atomHref,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
lastCheckedAt: lastCheckedAt.present
|
|
? lastCheckedAt.value
|
|
: this.lastCheckedAt,
|
|
);
|
|
Subscription copyWithCompanion(SubscriptionsCompanion data) {
|
|
return Subscription(
|
|
url: data.url.present ? data.url.value : this.url,
|
|
title: data.title.present ? data.title.value : this.title,
|
|
atomHref: data.atomHref.present ? data.atomHref.value : this.atomHref,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
lastCheckedAt: data.lastCheckedAt.present
|
|
? data.lastCheckedAt.value
|
|
: this.lastCheckedAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Subscription(')
|
|
..write('url: $url, ')
|
|
..write('title: $title, ')
|
|
..write('atomHref: $atomHref, ')
|
|
..write('createdAt: $createdAt, ')
|
|
..write('lastCheckedAt: $lastCheckedAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode =>
|
|
Object.hash(url, title, atomHref, createdAt, lastCheckedAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is Subscription &&
|
|
other.url == this.url &&
|
|
other.title == this.title &&
|
|
other.atomHref == this.atomHref &&
|
|
other.createdAt == this.createdAt &&
|
|
other.lastCheckedAt == this.lastCheckedAt);
|
|
}
|
|
|
|
class SubscriptionsCompanion extends UpdateCompanion<Subscription> {
|
|
final Value<String> url;
|
|
final Value<String?> title;
|
|
final Value<String?> atomHref;
|
|
final Value<DateTime> createdAt;
|
|
final Value<DateTime?> lastCheckedAt;
|
|
final Value<int> rowid;
|
|
const SubscriptionsCompanion({
|
|
this.url = const Value.absent(),
|
|
this.title = const Value.absent(),
|
|
this.atomHref = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
this.lastCheckedAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
SubscriptionsCompanion.insert({
|
|
required String url,
|
|
this.title = const Value.absent(),
|
|
this.atomHref = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
this.lastCheckedAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
}) : url = Value(url);
|
|
static Insertable<Subscription> custom({
|
|
Expression<String>? url,
|
|
Expression<String>? title,
|
|
Expression<String>? atomHref,
|
|
Expression<DateTime>? createdAt,
|
|
Expression<DateTime>? lastCheckedAt,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (url != null) 'url': url,
|
|
if (title != null) 'title': title,
|
|
if (atomHref != null) 'atom_href': atomHref,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
if (lastCheckedAt != null) 'last_checked_at': lastCheckedAt,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
SubscriptionsCompanion copyWith({
|
|
Value<String>? url,
|
|
Value<String?>? title,
|
|
Value<String?>? atomHref,
|
|
Value<DateTime>? createdAt,
|
|
Value<DateTime?>? lastCheckedAt,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return SubscriptionsCompanion(
|
|
url: url ?? this.url,
|
|
title: title ?? this.title,
|
|
atomHref: atomHref ?? this.atomHref,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
lastCheckedAt: lastCheckedAt ?? this.lastCheckedAt,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (url.present) {
|
|
map['url'] = Variable<String>(url.value);
|
|
}
|
|
if (title.present) {
|
|
map['title'] = Variable<String>(title.value);
|
|
}
|
|
if (atomHref.present) {
|
|
map['atom_href'] = Variable<String>(atomHref.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
if (lastCheckedAt.present) {
|
|
map['last_checked_at'] = Variable<DateTime>(lastCheckedAt.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('SubscriptionsCompanion(')
|
|
..write('url: $url, ')
|
|
..write('title: $title, ')
|
|
..write('atomHref: $atomHref, ')
|
|
..write('createdAt: $createdAt, ')
|
|
..write('lastCheckedAt: $lastCheckedAt, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $FeedEntriesTable extends FeedEntries
|
|
with TableInfo<$FeedEntriesTable, FeedEntry> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$FeedEntriesTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _siteUrlMeta = const VerificationMeta(
|
|
'siteUrl',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> siteUrl = GeneratedColumn<String>(
|
|
'site_url',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _urlMeta = const VerificationMeta('url');
|
|
@override
|
|
late final GeneratedColumn<String> url = GeneratedColumn<String>(
|
|
'url',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
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 _dateMeta = const VerificationMeta('date');
|
|
@override
|
|
late final GeneratedColumn<DateTime> date = GeneratedColumn<DateTime>(
|
|
'date',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _foundAtMeta = const VerificationMeta(
|
|
'foundAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> foundAt = GeneratedColumn<DateTime>(
|
|
'found_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
defaultValue: currentDateAndTime,
|
|
);
|
|
static const VerificationMeta _readAtMeta = const VerificationMeta('readAt');
|
|
@override
|
|
late final GeneratedColumn<DateTime> readAt = GeneratedColumn<DateTime>(
|
|
'read_at',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
siteUrl,
|
|
url,
|
|
title,
|
|
date,
|
|
foundAt,
|
|
readAt,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'feed_entries';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<FeedEntry> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('site_url')) {
|
|
context.handle(
|
|
_siteUrlMeta,
|
|
siteUrl.isAcceptableOrUnknown(data['site_url']!, _siteUrlMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_siteUrlMeta);
|
|
}
|
|
if (data.containsKey('url')) {
|
|
context.handle(
|
|
_urlMeta,
|
|
url.isAcceptableOrUnknown(data['url']!, _urlMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_urlMeta);
|
|
}
|
|
if (data.containsKey('title')) {
|
|
context.handle(
|
|
_titleMeta,
|
|
title.isAcceptableOrUnknown(data['title']!, _titleMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_titleMeta);
|
|
}
|
|
if (data.containsKey('date')) {
|
|
context.handle(
|
|
_dateMeta,
|
|
date.isAcceptableOrUnknown(data['date']!, _dateMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_dateMeta);
|
|
}
|
|
if (data.containsKey('found_at')) {
|
|
context.handle(
|
|
_foundAtMeta,
|
|
foundAt.isAcceptableOrUnknown(data['found_at']!, _foundAtMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('read_at')) {
|
|
context.handle(
|
|
_readAtMeta,
|
|
readAt.isAcceptableOrUnknown(data['read_at']!, _readAtMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {siteUrl, url};
|
|
@override
|
|
FeedEntry map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return FeedEntry(
|
|
siteUrl: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}site_url'],
|
|
)!,
|
|
url: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}url'],
|
|
)!,
|
|
title: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}title'],
|
|
)!,
|
|
date: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}date'],
|
|
)!,
|
|
foundAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}found_at'],
|
|
)!,
|
|
readAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}read_at'],
|
|
),
|
|
);
|
|
}
|
|
|
|
@override
|
|
$FeedEntriesTable createAlias(String alias) {
|
|
return $FeedEntriesTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class FeedEntry extends DataClass implements Insertable<FeedEntry> {
|
|
final String siteUrl;
|
|
final String url;
|
|
final String title;
|
|
final DateTime date;
|
|
final DateTime foundAt;
|
|
final DateTime? readAt;
|
|
const FeedEntry({
|
|
required this.siteUrl,
|
|
required this.url,
|
|
required this.title,
|
|
required this.date,
|
|
required this.foundAt,
|
|
this.readAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['site_url'] = Variable<String>(siteUrl);
|
|
map['url'] = Variable<String>(url);
|
|
map['title'] = Variable<String>(title);
|
|
map['date'] = Variable<DateTime>(date);
|
|
map['found_at'] = Variable<DateTime>(foundAt);
|
|
if (!nullToAbsent || readAt != null) {
|
|
map['read_at'] = Variable<DateTime>(readAt);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
FeedEntriesCompanion toCompanion(bool nullToAbsent) {
|
|
return FeedEntriesCompanion(
|
|
siteUrl: Value(siteUrl),
|
|
url: Value(url),
|
|
title: Value(title),
|
|
date: Value(date),
|
|
foundAt: Value(foundAt),
|
|
readAt: readAt == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(readAt),
|
|
);
|
|
}
|
|
|
|
factory FeedEntry.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return FeedEntry(
|
|
siteUrl: serializer.fromJson<String>(json['siteUrl']),
|
|
url: serializer.fromJson<String>(json['url']),
|
|
title: serializer.fromJson<String>(json['title']),
|
|
date: serializer.fromJson<DateTime>(json['date']),
|
|
foundAt: serializer.fromJson<DateTime>(json['foundAt']),
|
|
readAt: serializer.fromJson<DateTime?>(json['readAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'siteUrl': serializer.toJson<String>(siteUrl),
|
|
'url': serializer.toJson<String>(url),
|
|
'title': serializer.toJson<String>(title),
|
|
'date': serializer.toJson<DateTime>(date),
|
|
'foundAt': serializer.toJson<DateTime>(foundAt),
|
|
'readAt': serializer.toJson<DateTime?>(readAt),
|
|
};
|
|
}
|
|
|
|
FeedEntry copyWith({
|
|
String? siteUrl,
|
|
String? url,
|
|
String? title,
|
|
DateTime? date,
|
|
DateTime? foundAt,
|
|
Value<DateTime?> readAt = const Value.absent(),
|
|
}) => FeedEntry(
|
|
siteUrl: siteUrl ?? this.siteUrl,
|
|
url: url ?? this.url,
|
|
title: title ?? this.title,
|
|
date: date ?? this.date,
|
|
foundAt: foundAt ?? this.foundAt,
|
|
readAt: readAt.present ? readAt.value : this.readAt,
|
|
);
|
|
FeedEntry copyWithCompanion(FeedEntriesCompanion data) {
|
|
return FeedEntry(
|
|
siteUrl: data.siteUrl.present ? data.siteUrl.value : this.siteUrl,
|
|
url: data.url.present ? data.url.value : this.url,
|
|
title: data.title.present ? data.title.value : this.title,
|
|
date: data.date.present ? data.date.value : this.date,
|
|
foundAt: data.foundAt.present ? data.foundAt.value : this.foundAt,
|
|
readAt: data.readAt.present ? data.readAt.value : this.readAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('FeedEntry(')
|
|
..write('siteUrl: $siteUrl, ')
|
|
..write('url: $url, ')
|
|
..write('title: $title, ')
|
|
..write('date: $date, ')
|
|
..write('foundAt: $foundAt, ')
|
|
..write('readAt: $readAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(siteUrl, url, title, date, foundAt, readAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is FeedEntry &&
|
|
other.siteUrl == this.siteUrl &&
|
|
other.url == this.url &&
|
|
other.title == this.title &&
|
|
other.date == this.date &&
|
|
other.foundAt == this.foundAt &&
|
|
other.readAt == this.readAt);
|
|
}
|
|
|
|
class FeedEntriesCompanion extends UpdateCompanion<FeedEntry> {
|
|
final Value<String> siteUrl;
|
|
final Value<String> url;
|
|
final Value<String> title;
|
|
final Value<DateTime> date;
|
|
final Value<DateTime> foundAt;
|
|
final Value<DateTime?> readAt;
|
|
final Value<int> rowid;
|
|
const FeedEntriesCompanion({
|
|
this.siteUrl = const Value.absent(),
|
|
this.url = const Value.absent(),
|
|
this.title = const Value.absent(),
|
|
this.date = const Value.absent(),
|
|
this.foundAt = const Value.absent(),
|
|
this.readAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
FeedEntriesCompanion.insert({
|
|
required String siteUrl,
|
|
required String url,
|
|
required String title,
|
|
required DateTime date,
|
|
this.foundAt = const Value.absent(),
|
|
this.readAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
}) : siteUrl = Value(siteUrl),
|
|
url = Value(url),
|
|
title = Value(title),
|
|
date = Value(date);
|
|
static Insertable<FeedEntry> custom({
|
|
Expression<String>? siteUrl,
|
|
Expression<String>? url,
|
|
Expression<String>? title,
|
|
Expression<DateTime>? date,
|
|
Expression<DateTime>? foundAt,
|
|
Expression<DateTime>? readAt,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (siteUrl != null) 'site_url': siteUrl,
|
|
if (url != null) 'url': url,
|
|
if (title != null) 'title': title,
|
|
if (date != null) 'date': date,
|
|
if (foundAt != null) 'found_at': foundAt,
|
|
if (readAt != null) 'read_at': readAt,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
FeedEntriesCompanion copyWith({
|
|
Value<String>? siteUrl,
|
|
Value<String>? url,
|
|
Value<String>? title,
|
|
Value<DateTime>? date,
|
|
Value<DateTime>? foundAt,
|
|
Value<DateTime?>? readAt,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return FeedEntriesCompanion(
|
|
siteUrl: siteUrl ?? this.siteUrl,
|
|
url: url ?? this.url,
|
|
title: title ?? this.title,
|
|
date: date ?? this.date,
|
|
foundAt: foundAt ?? this.foundAt,
|
|
readAt: readAt ?? this.readAt,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (siteUrl.present) {
|
|
map['site_url'] = Variable<String>(siteUrl.value);
|
|
}
|
|
if (url.present) {
|
|
map['url'] = Variable<String>(url.value);
|
|
}
|
|
if (title.present) {
|
|
map['title'] = Variable<String>(title.value);
|
|
}
|
|
if (date.present) {
|
|
map['date'] = Variable<DateTime>(date.value);
|
|
}
|
|
if (foundAt.present) {
|
|
map['found_at'] = Variable<DateTime>(foundAt.value);
|
|
}
|
|
if (readAt.present) {
|
|
map['read_at'] = Variable<DateTime>(readAt.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('FeedEntriesCompanion(')
|
|
..write('siteUrl: $siteUrl, ')
|
|
..write('url: $url, ')
|
|
..write('title: $title, ')
|
|
..write('date: $date, ')
|
|
..write('foundAt: $foundAt, ')
|
|
..write('readAt: $readAt, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $ItemTagsTable extends ItemTags with TableInfo<$ItemTagsTable, ItemTag> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$ItemTagsTable(this.attachedDatabase, [this._alias]);
|
|
@override
|
|
late final GeneratedColumnWithTypeConverter<TagKind, String> kind =
|
|
GeneratedColumn<String>(
|
|
'kind',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
).withConverter<TagKind>($ItemTagsTable.$converterkind);
|
|
static const VerificationMeta _urlMeta = const VerificationMeta('url');
|
|
@override
|
|
late final GeneratedColumn<String> url = GeneratedColumn<String>(
|
|
'url',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _tagMeta = const VerificationMeta('tag');
|
|
@override
|
|
late final GeneratedColumn<String> tag = GeneratedColumn<String>(
|
|
'tag',
|
|
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 => [kind, url, tag, createdAt];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'item_tags';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<ItemTag> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('url')) {
|
|
context.handle(
|
|
_urlMeta,
|
|
url.isAcceptableOrUnknown(data['url']!, _urlMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_urlMeta);
|
|
}
|
|
if (data.containsKey('tag')) {
|
|
context.handle(
|
|
_tagMeta,
|
|
tag.isAcceptableOrUnknown(data['tag']!, _tagMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_tagMeta);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(
|
|
_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {kind, url, tag};
|
|
@override
|
|
ItemTag map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return ItemTag(
|
|
kind: $ItemTagsTable.$converterkind.fromSql(
|
|
attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}kind'],
|
|
)!,
|
|
),
|
|
url: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}url'],
|
|
)!,
|
|
tag: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}tag'],
|
|
)!,
|
|
createdAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}created_at'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$ItemTagsTable createAlias(String alias) {
|
|
return $ItemTagsTable(attachedDatabase, alias);
|
|
}
|
|
|
|
static JsonTypeConverter2<TagKind, String, String> $converterkind =
|
|
const EnumNameConverter<TagKind>(TagKind.values);
|
|
}
|
|
|
|
class ItemTag extends DataClass implements Insertable<ItemTag> {
|
|
final TagKind kind;
|
|
final String url;
|
|
final String tag;
|
|
final DateTime createdAt;
|
|
const ItemTag({
|
|
required this.kind,
|
|
required this.url,
|
|
required this.tag,
|
|
required this.createdAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
{
|
|
map['kind'] = Variable<String>($ItemTagsTable.$converterkind.toSql(kind));
|
|
}
|
|
map['url'] = Variable<String>(url);
|
|
map['tag'] = Variable<String>(tag);
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
return map;
|
|
}
|
|
|
|
ItemTagsCompanion toCompanion(bool nullToAbsent) {
|
|
return ItemTagsCompanion(
|
|
kind: Value(kind),
|
|
url: Value(url),
|
|
tag: Value(tag),
|
|
createdAt: Value(createdAt),
|
|
);
|
|
}
|
|
|
|
factory ItemTag.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return ItemTag(
|
|
kind: $ItemTagsTable.$converterkind.fromJson(
|
|
serializer.fromJson<String>(json['kind']),
|
|
),
|
|
url: serializer.fromJson<String>(json['url']),
|
|
tag: serializer.fromJson<String>(json['tag']),
|
|
createdAt: serializer.fromJson<DateTime>(json['createdAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'kind': serializer.toJson<String>(
|
|
$ItemTagsTable.$converterkind.toJson(kind),
|
|
),
|
|
'url': serializer.toJson<String>(url),
|
|
'tag': serializer.toJson<String>(tag),
|
|
'createdAt': serializer.toJson<DateTime>(createdAt),
|
|
};
|
|
}
|
|
|
|
ItemTag copyWith({
|
|
TagKind? kind,
|
|
String? url,
|
|
String? tag,
|
|
DateTime? createdAt,
|
|
}) => ItemTag(
|
|
kind: kind ?? this.kind,
|
|
url: url ?? this.url,
|
|
tag: tag ?? this.tag,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
);
|
|
ItemTag copyWithCompanion(ItemTagsCompanion data) {
|
|
return ItemTag(
|
|
kind: data.kind.present ? data.kind.value : this.kind,
|
|
url: data.url.present ? data.url.value : this.url,
|
|
tag: data.tag.present ? data.tag.value : this.tag,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ItemTag(')
|
|
..write('kind: $kind, ')
|
|
..write('url: $url, ')
|
|
..write('tag: $tag, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(kind, url, tag, createdAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is ItemTag &&
|
|
other.kind == this.kind &&
|
|
other.url == this.url &&
|
|
other.tag == this.tag &&
|
|
other.createdAt == this.createdAt);
|
|
}
|
|
|
|
class ItemTagsCompanion extends UpdateCompanion<ItemTag> {
|
|
final Value<TagKind> kind;
|
|
final Value<String> url;
|
|
final Value<String> tag;
|
|
final Value<DateTime> createdAt;
|
|
final Value<int> rowid;
|
|
const ItemTagsCompanion({
|
|
this.kind = const Value.absent(),
|
|
this.url = const Value.absent(),
|
|
this.tag = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
ItemTagsCompanion.insert({
|
|
required TagKind kind,
|
|
required String url,
|
|
required String tag,
|
|
this.createdAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
}) : kind = Value(kind),
|
|
url = Value(url),
|
|
tag = Value(tag);
|
|
static Insertable<ItemTag> custom({
|
|
Expression<String>? kind,
|
|
Expression<String>? url,
|
|
Expression<String>? tag,
|
|
Expression<DateTime>? createdAt,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (kind != null) 'kind': kind,
|
|
if (url != null) 'url': url,
|
|
if (tag != null) 'tag': tag,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
ItemTagsCompanion copyWith({
|
|
Value<TagKind>? kind,
|
|
Value<String>? url,
|
|
Value<String>? tag,
|
|
Value<DateTime>? createdAt,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return ItemTagsCompanion(
|
|
kind: kind ?? this.kind,
|
|
url: url ?? this.url,
|
|
tag: tag ?? this.tag,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (kind.present) {
|
|
map['kind'] = Variable<String>(
|
|
$ItemTagsTable.$converterkind.toSql(kind.value),
|
|
);
|
|
}
|
|
if (url.present) {
|
|
map['url'] = Variable<String>(url.value);
|
|
}
|
|
if (tag.present) {
|
|
map['tag'] = Variable<String>(tag.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ItemTagsCompanion(')
|
|
..write('kind: $kind, ')
|
|
..write('url: $url, ')
|
|
..write('tag: $tag, ')
|
|
..write('createdAt: $createdAt, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $ReaderSettingsTable extends ReaderSettings
|
|
with TableInfo<$ReaderSettingsTable, ReaderSetting> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$ReaderSettingsTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<int> id = GeneratedColumn<int>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant(0),
|
|
);
|
|
static const VerificationMeta _fontMeta = const VerificationMeta('font');
|
|
@override
|
|
late final GeneratedColumn<String> font = GeneratedColumn<String>(
|
|
'font',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant('Atkinson Hyperlegible'),
|
|
);
|
|
static const VerificationMeta _fontScaleMeta = const VerificationMeta(
|
|
'fontScale',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<double> fontScale = GeneratedColumn<double>(
|
|
'font_scale',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.double,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant(1.0),
|
|
);
|
|
static const VerificationMeta _themeModeMeta = const VerificationMeta(
|
|
'themeMode',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> themeMode = GeneratedColumn<String>(
|
|
'theme_mode',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant('system'),
|
|
);
|
|
static const VerificationMeta _variantMeta = const VerificationMeta(
|
|
'variant',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> variant = GeneratedColumn<String>(
|
|
'variant',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant('site'),
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
font,
|
|
fontScale,
|
|
themeMode,
|
|
variant,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'reader_settings';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<ReaderSetting> 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('font')) {
|
|
context.handle(
|
|
_fontMeta,
|
|
font.isAcceptableOrUnknown(data['font']!, _fontMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('font_scale')) {
|
|
context.handle(
|
|
_fontScaleMeta,
|
|
fontScale.isAcceptableOrUnknown(data['font_scale']!, _fontScaleMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('theme_mode')) {
|
|
context.handle(
|
|
_themeModeMeta,
|
|
themeMode.isAcceptableOrUnknown(data['theme_mode']!, _themeModeMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('variant')) {
|
|
context.handle(
|
|
_variantMeta,
|
|
variant.isAcceptableOrUnknown(data['variant']!, _variantMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
ReaderSetting map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return ReaderSetting(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
font: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}font'],
|
|
)!,
|
|
fontScale: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.double,
|
|
data['${effectivePrefix}font_scale'],
|
|
)!,
|
|
themeMode: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}theme_mode'],
|
|
)!,
|
|
variant: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}variant'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$ReaderSettingsTable createAlias(String alias) {
|
|
return $ReaderSettingsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class ReaderSetting extends DataClass implements Insertable<ReaderSetting> {
|
|
final int id;
|
|
final String font;
|
|
final double fontScale;
|
|
final String themeMode;
|
|
final String variant;
|
|
const ReaderSetting({
|
|
required this.id,
|
|
required this.font,
|
|
required this.fontScale,
|
|
required this.themeMode,
|
|
required this.variant,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['font'] = Variable<String>(font);
|
|
map['font_scale'] = Variable<double>(fontScale);
|
|
map['theme_mode'] = Variable<String>(themeMode);
|
|
map['variant'] = Variable<String>(variant);
|
|
return map;
|
|
}
|
|
|
|
ReaderSettingsCompanion toCompanion(bool nullToAbsent) {
|
|
return ReaderSettingsCompanion(
|
|
id: Value(id),
|
|
font: Value(font),
|
|
fontScale: Value(fontScale),
|
|
themeMode: Value(themeMode),
|
|
variant: Value(variant),
|
|
);
|
|
}
|
|
|
|
factory ReaderSetting.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return ReaderSetting(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
font: serializer.fromJson<String>(json['font']),
|
|
fontScale: serializer.fromJson<double>(json['fontScale']),
|
|
themeMode: serializer.fromJson<String>(json['themeMode']),
|
|
variant: serializer.fromJson<String>(json['variant']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'font': serializer.toJson<String>(font),
|
|
'fontScale': serializer.toJson<double>(fontScale),
|
|
'themeMode': serializer.toJson<String>(themeMode),
|
|
'variant': serializer.toJson<String>(variant),
|
|
};
|
|
}
|
|
|
|
ReaderSetting copyWith({
|
|
int? id,
|
|
String? font,
|
|
double? fontScale,
|
|
String? themeMode,
|
|
String? variant,
|
|
}) => ReaderSetting(
|
|
id: id ?? this.id,
|
|
font: font ?? this.font,
|
|
fontScale: fontScale ?? this.fontScale,
|
|
themeMode: themeMode ?? this.themeMode,
|
|
variant: variant ?? this.variant,
|
|
);
|
|
ReaderSetting copyWithCompanion(ReaderSettingsCompanion data) {
|
|
return ReaderSetting(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
font: data.font.present ? data.font.value : this.font,
|
|
fontScale: data.fontScale.present ? data.fontScale.value : this.fontScale,
|
|
themeMode: data.themeMode.present ? data.themeMode.value : this.themeMode,
|
|
variant: data.variant.present ? data.variant.value : this.variant,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ReaderSetting(')
|
|
..write('id: $id, ')
|
|
..write('font: $font, ')
|
|
..write('fontScale: $fontScale, ')
|
|
..write('themeMode: $themeMode, ')
|
|
..write('variant: $variant')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, font, fontScale, themeMode, variant);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is ReaderSetting &&
|
|
other.id == this.id &&
|
|
other.font == this.font &&
|
|
other.fontScale == this.fontScale &&
|
|
other.themeMode == this.themeMode &&
|
|
other.variant == this.variant);
|
|
}
|
|
|
|
class ReaderSettingsCompanion extends UpdateCompanion<ReaderSetting> {
|
|
final Value<int> id;
|
|
final Value<String> font;
|
|
final Value<double> fontScale;
|
|
final Value<String> themeMode;
|
|
final Value<String> variant;
|
|
const ReaderSettingsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.font = const Value.absent(),
|
|
this.fontScale = const Value.absent(),
|
|
this.themeMode = const Value.absent(),
|
|
this.variant = const Value.absent(),
|
|
});
|
|
ReaderSettingsCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
this.font = const Value.absent(),
|
|
this.fontScale = const Value.absent(),
|
|
this.themeMode = const Value.absent(),
|
|
this.variant = const Value.absent(),
|
|
});
|
|
static Insertable<ReaderSetting> custom({
|
|
Expression<int>? id,
|
|
Expression<String>? font,
|
|
Expression<double>? fontScale,
|
|
Expression<String>? themeMode,
|
|
Expression<String>? variant,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (font != null) 'font': font,
|
|
if (fontScale != null) 'font_scale': fontScale,
|
|
if (themeMode != null) 'theme_mode': themeMode,
|
|
if (variant != null) 'variant': variant,
|
|
});
|
|
}
|
|
|
|
ReaderSettingsCompanion copyWith({
|
|
Value<int>? id,
|
|
Value<String>? font,
|
|
Value<double>? fontScale,
|
|
Value<String>? themeMode,
|
|
Value<String>? variant,
|
|
}) {
|
|
return ReaderSettingsCompanion(
|
|
id: id ?? this.id,
|
|
font: font ?? this.font,
|
|
fontScale: fontScale ?? this.fontScale,
|
|
themeMode: themeMode ?? this.themeMode,
|
|
variant: variant ?? this.variant,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<int>(id.value);
|
|
}
|
|
if (font.present) {
|
|
map['font'] = Variable<String>(font.value);
|
|
}
|
|
if (fontScale.present) {
|
|
map['font_scale'] = Variable<double>(fontScale.value);
|
|
}
|
|
if (themeMode.present) {
|
|
map['theme_mode'] = Variable<String>(themeMode.value);
|
|
}
|
|
if (variant.present) {
|
|
map['variant'] = Variable<String>(variant.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ReaderSettingsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('font: $font, ')
|
|
..write('fontScale: $fontScale, ')
|
|
..write('themeMode: $themeMode, ')
|
|
..write('variant: $variant')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $CachedPagesTable extends CachedPages
|
|
with TableInfo<$CachedPagesTable, CachedPage> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$CachedPagesTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _urlMeta = const VerificationMeta('url');
|
|
@override
|
|
late final GeneratedColumn<String> url = GeneratedColumn<String>(
|
|
'url',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _titleMeta = const VerificationMeta('title');
|
|
@override
|
|
late final GeneratedColumn<String> title = GeneratedColumn<String>(
|
|
'title',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _sourceMeta = const VerificationMeta('source');
|
|
@override
|
|
late final GeneratedColumn<String> source = GeneratedColumn<String>(
|
|
'source',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _etagMeta = const VerificationMeta('etag');
|
|
@override
|
|
late final GeneratedColumn<String> etag = GeneratedColumn<String>(
|
|
'etag',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _lastModifiedMeta = const VerificationMeta(
|
|
'lastModified',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> lastModified = GeneratedColumn<String>(
|
|
'last_modified',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _cachedAtMeta = const VerificationMeta(
|
|
'cachedAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> cachedAt = GeneratedColumn<DateTime>(
|
|
'cached_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
defaultValue: currentDateAndTime,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
url,
|
|
title,
|
|
source,
|
|
etag,
|
|
lastModified,
|
|
cachedAt,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'cached_pages';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<CachedPage> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('url')) {
|
|
context.handle(
|
|
_urlMeta,
|
|
url.isAcceptableOrUnknown(data['url']!, _urlMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_urlMeta);
|
|
}
|
|
if (data.containsKey('title')) {
|
|
context.handle(
|
|
_titleMeta,
|
|
title.isAcceptableOrUnknown(data['title']!, _titleMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('source')) {
|
|
context.handle(
|
|
_sourceMeta,
|
|
source.isAcceptableOrUnknown(data['source']!, _sourceMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_sourceMeta);
|
|
}
|
|
if (data.containsKey('etag')) {
|
|
context.handle(
|
|
_etagMeta,
|
|
etag.isAcceptableOrUnknown(data['etag']!, _etagMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('last_modified')) {
|
|
context.handle(
|
|
_lastModifiedMeta,
|
|
lastModified.isAcceptableOrUnknown(
|
|
data['last_modified']!,
|
|
_lastModifiedMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('cached_at')) {
|
|
context.handle(
|
|
_cachedAtMeta,
|
|
cachedAt.isAcceptableOrUnknown(data['cached_at']!, _cachedAtMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {url};
|
|
@override
|
|
CachedPage map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return CachedPage(
|
|
url: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}url'],
|
|
)!,
|
|
title: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}title'],
|
|
),
|
|
source: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}source'],
|
|
)!,
|
|
etag: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}etag'],
|
|
),
|
|
lastModified: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}last_modified'],
|
|
),
|
|
cachedAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}cached_at'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$CachedPagesTable createAlias(String alias) {
|
|
return $CachedPagesTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class CachedPage extends DataClass implements Insertable<CachedPage> {
|
|
final String url;
|
|
final String? title;
|
|
final String source;
|
|
final String? etag;
|
|
final String? lastModified;
|
|
final DateTime cachedAt;
|
|
const CachedPage({
|
|
required this.url,
|
|
this.title,
|
|
required this.source,
|
|
this.etag,
|
|
this.lastModified,
|
|
required this.cachedAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['url'] = Variable<String>(url);
|
|
if (!nullToAbsent || title != null) {
|
|
map['title'] = Variable<String>(title);
|
|
}
|
|
map['source'] = Variable<String>(source);
|
|
if (!nullToAbsent || etag != null) {
|
|
map['etag'] = Variable<String>(etag);
|
|
}
|
|
if (!nullToAbsent || lastModified != null) {
|
|
map['last_modified'] = Variable<String>(lastModified);
|
|
}
|
|
map['cached_at'] = Variable<DateTime>(cachedAt);
|
|
return map;
|
|
}
|
|
|
|
CachedPagesCompanion toCompanion(bool nullToAbsent) {
|
|
return CachedPagesCompanion(
|
|
url: Value(url),
|
|
title: title == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(title),
|
|
source: Value(source),
|
|
etag: etag == null && nullToAbsent ? const Value.absent() : Value(etag),
|
|
lastModified: lastModified == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(lastModified),
|
|
cachedAt: Value(cachedAt),
|
|
);
|
|
}
|
|
|
|
factory CachedPage.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return CachedPage(
|
|
url: serializer.fromJson<String>(json['url']),
|
|
title: serializer.fromJson<String?>(json['title']),
|
|
source: serializer.fromJson<String>(json['source']),
|
|
etag: serializer.fromJson<String?>(json['etag']),
|
|
lastModified: serializer.fromJson<String?>(json['lastModified']),
|
|
cachedAt: serializer.fromJson<DateTime>(json['cachedAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'url': serializer.toJson<String>(url),
|
|
'title': serializer.toJson<String?>(title),
|
|
'source': serializer.toJson<String>(source),
|
|
'etag': serializer.toJson<String?>(etag),
|
|
'lastModified': serializer.toJson<String?>(lastModified),
|
|
'cachedAt': serializer.toJson<DateTime>(cachedAt),
|
|
};
|
|
}
|
|
|
|
CachedPage copyWith({
|
|
String? url,
|
|
Value<String?> title = const Value.absent(),
|
|
String? source,
|
|
Value<String?> etag = const Value.absent(),
|
|
Value<String?> lastModified = const Value.absent(),
|
|
DateTime? cachedAt,
|
|
}) => CachedPage(
|
|
url: url ?? this.url,
|
|
title: title.present ? title.value : this.title,
|
|
source: source ?? this.source,
|
|
etag: etag.present ? etag.value : this.etag,
|
|
lastModified: lastModified.present ? lastModified.value : this.lastModified,
|
|
cachedAt: cachedAt ?? this.cachedAt,
|
|
);
|
|
CachedPage copyWithCompanion(CachedPagesCompanion data) {
|
|
return CachedPage(
|
|
url: data.url.present ? data.url.value : this.url,
|
|
title: data.title.present ? data.title.value : this.title,
|
|
source: data.source.present ? data.source.value : this.source,
|
|
etag: data.etag.present ? data.etag.value : this.etag,
|
|
lastModified: data.lastModified.present
|
|
? data.lastModified.value
|
|
: this.lastModified,
|
|
cachedAt: data.cachedAt.present ? data.cachedAt.value : this.cachedAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('CachedPage(')
|
|
..write('url: $url, ')
|
|
..write('title: $title, ')
|
|
..write('source: $source, ')
|
|
..write('etag: $etag, ')
|
|
..write('lastModified: $lastModified, ')
|
|
..write('cachedAt: $cachedAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode =>
|
|
Object.hash(url, title, source, etag, lastModified, cachedAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is CachedPage &&
|
|
other.url == this.url &&
|
|
other.title == this.title &&
|
|
other.source == this.source &&
|
|
other.etag == this.etag &&
|
|
other.lastModified == this.lastModified &&
|
|
other.cachedAt == this.cachedAt);
|
|
}
|
|
|
|
class CachedPagesCompanion extends UpdateCompanion<CachedPage> {
|
|
final Value<String> url;
|
|
final Value<String?> title;
|
|
final Value<String> source;
|
|
final Value<String?> etag;
|
|
final Value<String?> lastModified;
|
|
final Value<DateTime> cachedAt;
|
|
final Value<int> rowid;
|
|
const CachedPagesCompanion({
|
|
this.url = const Value.absent(),
|
|
this.title = const Value.absent(),
|
|
this.source = const Value.absent(),
|
|
this.etag = const Value.absent(),
|
|
this.lastModified = const Value.absent(),
|
|
this.cachedAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
CachedPagesCompanion.insert({
|
|
required String url,
|
|
this.title = const Value.absent(),
|
|
required String source,
|
|
this.etag = const Value.absent(),
|
|
this.lastModified = const Value.absent(),
|
|
this.cachedAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
}) : url = Value(url),
|
|
source = Value(source);
|
|
static Insertable<CachedPage> custom({
|
|
Expression<String>? url,
|
|
Expression<String>? title,
|
|
Expression<String>? source,
|
|
Expression<String>? etag,
|
|
Expression<String>? lastModified,
|
|
Expression<DateTime>? cachedAt,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (url != null) 'url': url,
|
|
if (title != null) 'title': title,
|
|
if (source != null) 'source': source,
|
|
if (etag != null) 'etag': etag,
|
|
if (lastModified != null) 'last_modified': lastModified,
|
|
if (cachedAt != null) 'cached_at': cachedAt,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
CachedPagesCompanion copyWith({
|
|
Value<String>? url,
|
|
Value<String?>? title,
|
|
Value<String>? source,
|
|
Value<String?>? etag,
|
|
Value<String?>? lastModified,
|
|
Value<DateTime>? cachedAt,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return CachedPagesCompanion(
|
|
url: url ?? this.url,
|
|
title: title ?? this.title,
|
|
source: source ?? this.source,
|
|
etag: etag ?? this.etag,
|
|
lastModified: lastModified ?? this.lastModified,
|
|
cachedAt: cachedAt ?? this.cachedAt,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (url.present) {
|
|
map['url'] = Variable<String>(url.value);
|
|
}
|
|
if (title.present) {
|
|
map['title'] = Variable<String>(title.value);
|
|
}
|
|
if (source.present) {
|
|
map['source'] = Variable<String>(source.value);
|
|
}
|
|
if (etag.present) {
|
|
map['etag'] = Variable<String>(etag.value);
|
|
}
|
|
if (lastModified.present) {
|
|
map['last_modified'] = Variable<String>(lastModified.value);
|
|
}
|
|
if (cachedAt.present) {
|
|
map['cached_at'] = Variable<DateTime>(cachedAt.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('CachedPagesCompanion(')
|
|
..write('url: $url, ')
|
|
..write('title: $title, ')
|
|
..write('source: $source, ')
|
|
..write('etag: $etag, ')
|
|
..write('lastModified: $lastModified, ')
|
|
..write('cachedAt: $cachedAt, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
abstract class _$MewsDatabase extends GeneratedDatabase {
|
|
_$MewsDatabase(QueryExecutor e) : super(e);
|
|
$MewsDatabaseManager get managers => $MewsDatabaseManager(this);
|
|
late final $HistoryItemsTable historyItems = $HistoryItemsTable(this);
|
|
late final $BookmarksTable bookmarks = $BookmarksTable(this);
|
|
late final $SubscriptionsTable subscriptions = $SubscriptionsTable(this);
|
|
late final $FeedEntriesTable feedEntries = $FeedEntriesTable(this);
|
|
late final $ItemTagsTable itemTags = $ItemTagsTable(this);
|
|
late final $ReaderSettingsTable readerSettings = $ReaderSettingsTable(this);
|
|
late final $CachedPagesTable cachedPages = $CachedPagesTable(this);
|
|
late final Index historyItemsUrl = Index(
|
|
'history_items_url',
|
|
'CREATE INDEX history_items_url ON history_items (url)',
|
|
);
|
|
@override
|
|
Iterable<TableInfo<Table, Object?>> get allTables =>
|
|
allSchemaEntities.whereType<TableInfo<Table, Object?>>();
|
|
@override
|
|
List<DatabaseSchemaEntity> get allSchemaEntities => [
|
|
historyItems,
|
|
bookmarks,
|
|
subscriptions,
|
|
feedEntries,
|
|
itemTags,
|
|
readerSettings,
|
|
cachedPages,
|
|
historyItemsUrl,
|
|
];
|
|
}
|
|
|
|
typedef $$HistoryItemsTableCreateCompanionBuilder =
|
|
HistoryItemsCompanion Function({
|
|
Value<int> id,
|
|
required String url,
|
|
Value<String?> title,
|
|
Value<DateTime> visitedAt,
|
|
});
|
|
typedef $$HistoryItemsTableUpdateCompanionBuilder =
|
|
HistoryItemsCompanion Function({
|
|
Value<int> id,
|
|
Value<String> url,
|
|
Value<String?> title,
|
|
Value<DateTime> visitedAt,
|
|
});
|
|
|
|
class $$HistoryItemsTableFilterComposer
|
|
extends Composer<_$MewsDatabase, $HistoryItemsTable> {
|
|
$$HistoryItemsTableFilterComposer({
|
|
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 url => $composableBuilder(
|
|
column: $table.url,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get title => $composableBuilder(
|
|
column: $table.title,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get visitedAt => $composableBuilder(
|
|
column: $table.visitedAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
}
|
|
|
|
class $$HistoryItemsTableOrderingComposer
|
|
extends Composer<_$MewsDatabase, $HistoryItemsTable> {
|
|
$$HistoryItemsTableOrderingComposer({
|
|
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 url => $composableBuilder(
|
|
column: $table.url,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get title => $composableBuilder(
|
|
column: $table.title,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get visitedAt => $composableBuilder(
|
|
column: $table.visitedAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$HistoryItemsTableAnnotationComposer
|
|
extends Composer<_$MewsDatabase, $HistoryItemsTable> {
|
|
$$HistoryItemsTableAnnotationComposer({
|
|
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 url =>
|
|
$composableBuilder(column: $table.url, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get title =>
|
|
$composableBuilder(column: $table.title, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get visitedAt =>
|
|
$composableBuilder(column: $table.visitedAt, builder: (column) => column);
|
|
}
|
|
|
|
class $$HistoryItemsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$MewsDatabase,
|
|
$HistoryItemsTable,
|
|
HistoryItem,
|
|
$$HistoryItemsTableFilterComposer,
|
|
$$HistoryItemsTableOrderingComposer,
|
|
$$HistoryItemsTableAnnotationComposer,
|
|
$$HistoryItemsTableCreateCompanionBuilder,
|
|
$$HistoryItemsTableUpdateCompanionBuilder,
|
|
(
|
|
HistoryItem,
|
|
BaseReferences<_$MewsDatabase, $HistoryItemsTable, HistoryItem>,
|
|
),
|
|
HistoryItem,
|
|
PrefetchHooks Function()
|
|
> {
|
|
$$HistoryItemsTableTableManager(_$MewsDatabase db, $HistoryItemsTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$HistoryItemsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$HistoryItemsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$HistoryItemsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
Value<String> url = const Value.absent(),
|
|
Value<String?> title = const Value.absent(),
|
|
Value<DateTime> visitedAt = const Value.absent(),
|
|
}) => HistoryItemsCompanion(
|
|
id: id,
|
|
url: url,
|
|
title: title,
|
|
visitedAt: visitedAt,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
required String url,
|
|
Value<String?> title = const Value.absent(),
|
|
Value<DateTime> visitedAt = const Value.absent(),
|
|
}) => HistoryItemsCompanion.insert(
|
|
id: id,
|
|
url: url,
|
|
title: title,
|
|
visitedAt: visitedAt,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$HistoryItemsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$MewsDatabase,
|
|
$HistoryItemsTable,
|
|
HistoryItem,
|
|
$$HistoryItemsTableFilterComposer,
|
|
$$HistoryItemsTableOrderingComposer,
|
|
$$HistoryItemsTableAnnotationComposer,
|
|
$$HistoryItemsTableCreateCompanionBuilder,
|
|
$$HistoryItemsTableUpdateCompanionBuilder,
|
|
(
|
|
HistoryItem,
|
|
BaseReferences<_$MewsDatabase, $HistoryItemsTable, HistoryItem>,
|
|
),
|
|
HistoryItem,
|
|
PrefetchHooks Function()
|
|
>;
|
|
typedef $$BookmarksTableCreateCompanionBuilder =
|
|
BookmarksCompanion Function({
|
|
required String url,
|
|
Value<String?> title,
|
|
Value<DateTime> createdAt,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$BookmarksTableUpdateCompanionBuilder =
|
|
BookmarksCompanion Function({
|
|
Value<String> url,
|
|
Value<String?> title,
|
|
Value<DateTime> createdAt,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
class $$BookmarksTableFilterComposer
|
|
extends Composer<_$MewsDatabase, $BookmarksTable> {
|
|
$$BookmarksTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get url => $composableBuilder(
|
|
column: $table.url,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get title => $composableBuilder(
|
|
column: $table.title,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
}
|
|
|
|
class $$BookmarksTableOrderingComposer
|
|
extends Composer<_$MewsDatabase, $BookmarksTable> {
|
|
$$BookmarksTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get url => $composableBuilder(
|
|
column: $table.url,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get title => $composableBuilder(
|
|
column: $table.title,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$BookmarksTableAnnotationComposer
|
|
extends Composer<_$MewsDatabase, $BookmarksTable> {
|
|
$$BookmarksTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get url =>
|
|
$composableBuilder(column: $table.url, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get title =>
|
|
$composableBuilder(column: $table.title, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
}
|
|
|
|
class $$BookmarksTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$MewsDatabase,
|
|
$BookmarksTable,
|
|
Bookmark,
|
|
$$BookmarksTableFilterComposer,
|
|
$$BookmarksTableOrderingComposer,
|
|
$$BookmarksTableAnnotationComposer,
|
|
$$BookmarksTableCreateCompanionBuilder,
|
|
$$BookmarksTableUpdateCompanionBuilder,
|
|
(Bookmark, BaseReferences<_$MewsDatabase, $BookmarksTable, Bookmark>),
|
|
Bookmark,
|
|
PrefetchHooks Function()
|
|
> {
|
|
$$BookmarksTableTableManager(_$MewsDatabase db, $BookmarksTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$BookmarksTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$BookmarksTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$BookmarksTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> url = const Value.absent(),
|
|
Value<String?> title = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => BookmarksCompanion(
|
|
url: url,
|
|
title: title,
|
|
createdAt: createdAt,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String url,
|
|
Value<String?> title = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => BookmarksCompanion.insert(
|
|
url: url,
|
|
title: title,
|
|
createdAt: createdAt,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$BookmarksTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$MewsDatabase,
|
|
$BookmarksTable,
|
|
Bookmark,
|
|
$$BookmarksTableFilterComposer,
|
|
$$BookmarksTableOrderingComposer,
|
|
$$BookmarksTableAnnotationComposer,
|
|
$$BookmarksTableCreateCompanionBuilder,
|
|
$$BookmarksTableUpdateCompanionBuilder,
|
|
(Bookmark, BaseReferences<_$MewsDatabase, $BookmarksTable, Bookmark>),
|
|
Bookmark,
|
|
PrefetchHooks Function()
|
|
>;
|
|
typedef $$SubscriptionsTableCreateCompanionBuilder =
|
|
SubscriptionsCompanion Function({
|
|
required String url,
|
|
Value<String?> title,
|
|
Value<String?> atomHref,
|
|
Value<DateTime> createdAt,
|
|
Value<DateTime?> lastCheckedAt,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$SubscriptionsTableUpdateCompanionBuilder =
|
|
SubscriptionsCompanion Function({
|
|
Value<String> url,
|
|
Value<String?> title,
|
|
Value<String?> atomHref,
|
|
Value<DateTime> createdAt,
|
|
Value<DateTime?> lastCheckedAt,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
class $$SubscriptionsTableFilterComposer
|
|
extends Composer<_$MewsDatabase, $SubscriptionsTable> {
|
|
$$SubscriptionsTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get url => $composableBuilder(
|
|
column: $table.url,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get title => $composableBuilder(
|
|
column: $table.title,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get atomHref => $composableBuilder(
|
|
column: $table.atomHref,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get lastCheckedAt => $composableBuilder(
|
|
column: $table.lastCheckedAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
}
|
|
|
|
class $$SubscriptionsTableOrderingComposer
|
|
extends Composer<_$MewsDatabase, $SubscriptionsTable> {
|
|
$$SubscriptionsTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get url => $composableBuilder(
|
|
column: $table.url,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get title => $composableBuilder(
|
|
column: $table.title,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get atomHref => $composableBuilder(
|
|
column: $table.atomHref,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get lastCheckedAt => $composableBuilder(
|
|
column: $table.lastCheckedAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$SubscriptionsTableAnnotationComposer
|
|
extends Composer<_$MewsDatabase, $SubscriptionsTable> {
|
|
$$SubscriptionsTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get url =>
|
|
$composableBuilder(column: $table.url, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get title =>
|
|
$composableBuilder(column: $table.title, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get atomHref =>
|
|
$composableBuilder(column: $table.atomHref, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get lastCheckedAt => $composableBuilder(
|
|
column: $table.lastCheckedAt,
|
|
builder: (column) => column,
|
|
);
|
|
}
|
|
|
|
class $$SubscriptionsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$MewsDatabase,
|
|
$SubscriptionsTable,
|
|
Subscription,
|
|
$$SubscriptionsTableFilterComposer,
|
|
$$SubscriptionsTableOrderingComposer,
|
|
$$SubscriptionsTableAnnotationComposer,
|
|
$$SubscriptionsTableCreateCompanionBuilder,
|
|
$$SubscriptionsTableUpdateCompanionBuilder,
|
|
(
|
|
Subscription,
|
|
BaseReferences<_$MewsDatabase, $SubscriptionsTable, Subscription>,
|
|
),
|
|
Subscription,
|
|
PrefetchHooks Function()
|
|
> {
|
|
$$SubscriptionsTableTableManager(_$MewsDatabase db, $SubscriptionsTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$SubscriptionsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$SubscriptionsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$SubscriptionsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> url = const Value.absent(),
|
|
Value<String?> title = const Value.absent(),
|
|
Value<String?> atomHref = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
Value<DateTime?> lastCheckedAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => SubscriptionsCompanion(
|
|
url: url,
|
|
title: title,
|
|
atomHref: atomHref,
|
|
createdAt: createdAt,
|
|
lastCheckedAt: lastCheckedAt,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String url,
|
|
Value<String?> title = const Value.absent(),
|
|
Value<String?> atomHref = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
Value<DateTime?> lastCheckedAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => SubscriptionsCompanion.insert(
|
|
url: url,
|
|
title: title,
|
|
atomHref: atomHref,
|
|
createdAt: createdAt,
|
|
lastCheckedAt: lastCheckedAt,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$SubscriptionsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$MewsDatabase,
|
|
$SubscriptionsTable,
|
|
Subscription,
|
|
$$SubscriptionsTableFilterComposer,
|
|
$$SubscriptionsTableOrderingComposer,
|
|
$$SubscriptionsTableAnnotationComposer,
|
|
$$SubscriptionsTableCreateCompanionBuilder,
|
|
$$SubscriptionsTableUpdateCompanionBuilder,
|
|
(
|
|
Subscription,
|
|
BaseReferences<_$MewsDatabase, $SubscriptionsTable, Subscription>,
|
|
),
|
|
Subscription,
|
|
PrefetchHooks Function()
|
|
>;
|
|
typedef $$FeedEntriesTableCreateCompanionBuilder =
|
|
FeedEntriesCompanion Function({
|
|
required String siteUrl,
|
|
required String url,
|
|
required String title,
|
|
required DateTime date,
|
|
Value<DateTime> foundAt,
|
|
Value<DateTime?> readAt,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$FeedEntriesTableUpdateCompanionBuilder =
|
|
FeedEntriesCompanion Function({
|
|
Value<String> siteUrl,
|
|
Value<String> url,
|
|
Value<String> title,
|
|
Value<DateTime> date,
|
|
Value<DateTime> foundAt,
|
|
Value<DateTime?> readAt,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
class $$FeedEntriesTableFilterComposer
|
|
extends Composer<_$MewsDatabase, $FeedEntriesTable> {
|
|
$$FeedEntriesTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get siteUrl => $composableBuilder(
|
|
column: $table.siteUrl,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get url => $composableBuilder(
|
|
column: $table.url,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get title => $composableBuilder(
|
|
column: $table.title,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get date => $composableBuilder(
|
|
column: $table.date,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get foundAt => $composableBuilder(
|
|
column: $table.foundAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get readAt => $composableBuilder(
|
|
column: $table.readAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
}
|
|
|
|
class $$FeedEntriesTableOrderingComposer
|
|
extends Composer<_$MewsDatabase, $FeedEntriesTable> {
|
|
$$FeedEntriesTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get siteUrl => $composableBuilder(
|
|
column: $table.siteUrl,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get url => $composableBuilder(
|
|
column: $table.url,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get title => $composableBuilder(
|
|
column: $table.title,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get date => $composableBuilder(
|
|
column: $table.date,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get foundAt => $composableBuilder(
|
|
column: $table.foundAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get readAt => $composableBuilder(
|
|
column: $table.readAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$FeedEntriesTableAnnotationComposer
|
|
extends Composer<_$MewsDatabase, $FeedEntriesTable> {
|
|
$$FeedEntriesTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get siteUrl =>
|
|
$composableBuilder(column: $table.siteUrl, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get url =>
|
|
$composableBuilder(column: $table.url, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get title =>
|
|
$composableBuilder(column: $table.title, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get date =>
|
|
$composableBuilder(column: $table.date, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get foundAt =>
|
|
$composableBuilder(column: $table.foundAt, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get readAt =>
|
|
$composableBuilder(column: $table.readAt, builder: (column) => column);
|
|
}
|
|
|
|
class $$FeedEntriesTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$MewsDatabase,
|
|
$FeedEntriesTable,
|
|
FeedEntry,
|
|
$$FeedEntriesTableFilterComposer,
|
|
$$FeedEntriesTableOrderingComposer,
|
|
$$FeedEntriesTableAnnotationComposer,
|
|
$$FeedEntriesTableCreateCompanionBuilder,
|
|
$$FeedEntriesTableUpdateCompanionBuilder,
|
|
(
|
|
FeedEntry,
|
|
BaseReferences<_$MewsDatabase, $FeedEntriesTable, FeedEntry>,
|
|
),
|
|
FeedEntry,
|
|
PrefetchHooks Function()
|
|
> {
|
|
$$FeedEntriesTableTableManager(_$MewsDatabase db, $FeedEntriesTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$FeedEntriesTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$FeedEntriesTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$FeedEntriesTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> siteUrl = const Value.absent(),
|
|
Value<String> url = const Value.absent(),
|
|
Value<String> title = const Value.absent(),
|
|
Value<DateTime> date = const Value.absent(),
|
|
Value<DateTime> foundAt = const Value.absent(),
|
|
Value<DateTime?> readAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => FeedEntriesCompanion(
|
|
siteUrl: siteUrl,
|
|
url: url,
|
|
title: title,
|
|
date: date,
|
|
foundAt: foundAt,
|
|
readAt: readAt,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String siteUrl,
|
|
required String url,
|
|
required String title,
|
|
required DateTime date,
|
|
Value<DateTime> foundAt = const Value.absent(),
|
|
Value<DateTime?> readAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => FeedEntriesCompanion.insert(
|
|
siteUrl: siteUrl,
|
|
url: url,
|
|
title: title,
|
|
date: date,
|
|
foundAt: foundAt,
|
|
readAt: readAt,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$FeedEntriesTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$MewsDatabase,
|
|
$FeedEntriesTable,
|
|
FeedEntry,
|
|
$$FeedEntriesTableFilterComposer,
|
|
$$FeedEntriesTableOrderingComposer,
|
|
$$FeedEntriesTableAnnotationComposer,
|
|
$$FeedEntriesTableCreateCompanionBuilder,
|
|
$$FeedEntriesTableUpdateCompanionBuilder,
|
|
(FeedEntry, BaseReferences<_$MewsDatabase, $FeedEntriesTable, FeedEntry>),
|
|
FeedEntry,
|
|
PrefetchHooks Function()
|
|
>;
|
|
typedef $$ItemTagsTableCreateCompanionBuilder =
|
|
ItemTagsCompanion Function({
|
|
required TagKind kind,
|
|
required String url,
|
|
required String tag,
|
|
Value<DateTime> createdAt,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$ItemTagsTableUpdateCompanionBuilder =
|
|
ItemTagsCompanion Function({
|
|
Value<TagKind> kind,
|
|
Value<String> url,
|
|
Value<String> tag,
|
|
Value<DateTime> createdAt,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
class $$ItemTagsTableFilterComposer
|
|
extends Composer<_$MewsDatabase, $ItemTagsTable> {
|
|
$$ItemTagsTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnWithTypeConverterFilters<TagKind, TagKind, String> get kind =>
|
|
$composableBuilder(
|
|
column: $table.kind,
|
|
builder: (column) => ColumnWithTypeConverterFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get url => $composableBuilder(
|
|
column: $table.url,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get tag => $composableBuilder(
|
|
column: $table.tag,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
}
|
|
|
|
class $$ItemTagsTableOrderingComposer
|
|
extends Composer<_$MewsDatabase, $ItemTagsTable> {
|
|
$$ItemTagsTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get kind => $composableBuilder(
|
|
column: $table.kind,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get url => $composableBuilder(
|
|
column: $table.url,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get tag => $composableBuilder(
|
|
column: $table.tag,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$ItemTagsTableAnnotationComposer
|
|
extends Composer<_$MewsDatabase, $ItemTagsTable> {
|
|
$$ItemTagsTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumnWithTypeConverter<TagKind, String> get kind =>
|
|
$composableBuilder(column: $table.kind, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get url =>
|
|
$composableBuilder(column: $table.url, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get tag =>
|
|
$composableBuilder(column: $table.tag, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
}
|
|
|
|
class $$ItemTagsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$MewsDatabase,
|
|
$ItemTagsTable,
|
|
ItemTag,
|
|
$$ItemTagsTableFilterComposer,
|
|
$$ItemTagsTableOrderingComposer,
|
|
$$ItemTagsTableAnnotationComposer,
|
|
$$ItemTagsTableCreateCompanionBuilder,
|
|
$$ItemTagsTableUpdateCompanionBuilder,
|
|
(ItemTag, BaseReferences<_$MewsDatabase, $ItemTagsTable, ItemTag>),
|
|
ItemTag,
|
|
PrefetchHooks Function()
|
|
> {
|
|
$$ItemTagsTableTableManager(_$MewsDatabase db, $ItemTagsTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$ItemTagsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$ItemTagsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$ItemTagsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<TagKind> kind = const Value.absent(),
|
|
Value<String> url = const Value.absent(),
|
|
Value<String> tag = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => ItemTagsCompanion(
|
|
kind: kind,
|
|
url: url,
|
|
tag: tag,
|
|
createdAt: createdAt,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required TagKind kind,
|
|
required String url,
|
|
required String tag,
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => ItemTagsCompanion.insert(
|
|
kind: kind,
|
|
url: url,
|
|
tag: tag,
|
|
createdAt: createdAt,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$ItemTagsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$MewsDatabase,
|
|
$ItemTagsTable,
|
|
ItemTag,
|
|
$$ItemTagsTableFilterComposer,
|
|
$$ItemTagsTableOrderingComposer,
|
|
$$ItemTagsTableAnnotationComposer,
|
|
$$ItemTagsTableCreateCompanionBuilder,
|
|
$$ItemTagsTableUpdateCompanionBuilder,
|
|
(ItemTag, BaseReferences<_$MewsDatabase, $ItemTagsTable, ItemTag>),
|
|
ItemTag,
|
|
PrefetchHooks Function()
|
|
>;
|
|
typedef $$ReaderSettingsTableCreateCompanionBuilder =
|
|
ReaderSettingsCompanion Function({
|
|
Value<int> id,
|
|
Value<String> font,
|
|
Value<double> fontScale,
|
|
Value<String> themeMode,
|
|
Value<String> variant,
|
|
});
|
|
typedef $$ReaderSettingsTableUpdateCompanionBuilder =
|
|
ReaderSettingsCompanion Function({
|
|
Value<int> id,
|
|
Value<String> font,
|
|
Value<double> fontScale,
|
|
Value<String> themeMode,
|
|
Value<String> variant,
|
|
});
|
|
|
|
class $$ReaderSettingsTableFilterComposer
|
|
extends Composer<_$MewsDatabase, $ReaderSettingsTable> {
|
|
$$ReaderSettingsTableFilterComposer({
|
|
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 font => $composableBuilder(
|
|
column: $table.font,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<double> get fontScale => $composableBuilder(
|
|
column: $table.fontScale,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get themeMode => $composableBuilder(
|
|
column: $table.themeMode,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get variant => $composableBuilder(
|
|
column: $table.variant,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
}
|
|
|
|
class $$ReaderSettingsTableOrderingComposer
|
|
extends Composer<_$MewsDatabase, $ReaderSettingsTable> {
|
|
$$ReaderSettingsTableOrderingComposer({
|
|
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 font => $composableBuilder(
|
|
column: $table.font,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<double> get fontScale => $composableBuilder(
|
|
column: $table.fontScale,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get themeMode => $composableBuilder(
|
|
column: $table.themeMode,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get variant => $composableBuilder(
|
|
column: $table.variant,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$ReaderSettingsTableAnnotationComposer
|
|
extends Composer<_$MewsDatabase, $ReaderSettingsTable> {
|
|
$$ReaderSettingsTableAnnotationComposer({
|
|
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 font =>
|
|
$composableBuilder(column: $table.font, builder: (column) => column);
|
|
|
|
GeneratedColumn<double> get fontScale =>
|
|
$composableBuilder(column: $table.fontScale, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get themeMode =>
|
|
$composableBuilder(column: $table.themeMode, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get variant =>
|
|
$composableBuilder(column: $table.variant, builder: (column) => column);
|
|
}
|
|
|
|
class $$ReaderSettingsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$MewsDatabase,
|
|
$ReaderSettingsTable,
|
|
ReaderSetting,
|
|
$$ReaderSettingsTableFilterComposer,
|
|
$$ReaderSettingsTableOrderingComposer,
|
|
$$ReaderSettingsTableAnnotationComposer,
|
|
$$ReaderSettingsTableCreateCompanionBuilder,
|
|
$$ReaderSettingsTableUpdateCompanionBuilder,
|
|
(
|
|
ReaderSetting,
|
|
BaseReferences<_$MewsDatabase, $ReaderSettingsTable, ReaderSetting>,
|
|
),
|
|
ReaderSetting,
|
|
PrefetchHooks Function()
|
|
> {
|
|
$$ReaderSettingsTableTableManager(
|
|
_$MewsDatabase db,
|
|
$ReaderSettingsTable table,
|
|
) : super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$ReaderSettingsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$ReaderSettingsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$ReaderSettingsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
Value<String> font = const Value.absent(),
|
|
Value<double> fontScale = const Value.absent(),
|
|
Value<String> themeMode = const Value.absent(),
|
|
Value<String> variant = const Value.absent(),
|
|
}) => ReaderSettingsCompanion(
|
|
id: id,
|
|
font: font,
|
|
fontScale: fontScale,
|
|
themeMode: themeMode,
|
|
variant: variant,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
Value<String> font = const Value.absent(),
|
|
Value<double> fontScale = const Value.absent(),
|
|
Value<String> themeMode = const Value.absent(),
|
|
Value<String> variant = const Value.absent(),
|
|
}) => ReaderSettingsCompanion.insert(
|
|
id: id,
|
|
font: font,
|
|
fontScale: fontScale,
|
|
themeMode: themeMode,
|
|
variant: variant,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$ReaderSettingsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$MewsDatabase,
|
|
$ReaderSettingsTable,
|
|
ReaderSetting,
|
|
$$ReaderSettingsTableFilterComposer,
|
|
$$ReaderSettingsTableOrderingComposer,
|
|
$$ReaderSettingsTableAnnotationComposer,
|
|
$$ReaderSettingsTableCreateCompanionBuilder,
|
|
$$ReaderSettingsTableUpdateCompanionBuilder,
|
|
(
|
|
ReaderSetting,
|
|
BaseReferences<_$MewsDatabase, $ReaderSettingsTable, ReaderSetting>,
|
|
),
|
|
ReaderSetting,
|
|
PrefetchHooks Function()
|
|
>;
|
|
typedef $$CachedPagesTableCreateCompanionBuilder =
|
|
CachedPagesCompanion Function({
|
|
required String url,
|
|
Value<String?> title,
|
|
required String source,
|
|
Value<String?> etag,
|
|
Value<String?> lastModified,
|
|
Value<DateTime> cachedAt,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$CachedPagesTableUpdateCompanionBuilder =
|
|
CachedPagesCompanion Function({
|
|
Value<String> url,
|
|
Value<String?> title,
|
|
Value<String> source,
|
|
Value<String?> etag,
|
|
Value<String?> lastModified,
|
|
Value<DateTime> cachedAt,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
class $$CachedPagesTableFilterComposer
|
|
extends Composer<_$MewsDatabase, $CachedPagesTable> {
|
|
$$CachedPagesTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get url => $composableBuilder(
|
|
column: $table.url,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get title => $composableBuilder(
|
|
column: $table.title,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get source => $composableBuilder(
|
|
column: $table.source,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get etag => $composableBuilder(
|
|
column: $table.etag,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get lastModified => $composableBuilder(
|
|
column: $table.lastModified,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get cachedAt => $composableBuilder(
|
|
column: $table.cachedAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
}
|
|
|
|
class $$CachedPagesTableOrderingComposer
|
|
extends Composer<_$MewsDatabase, $CachedPagesTable> {
|
|
$$CachedPagesTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get url => $composableBuilder(
|
|
column: $table.url,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get title => $composableBuilder(
|
|
column: $table.title,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get source => $composableBuilder(
|
|
column: $table.source,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get etag => $composableBuilder(
|
|
column: $table.etag,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get lastModified => $composableBuilder(
|
|
column: $table.lastModified,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get cachedAt => $composableBuilder(
|
|
column: $table.cachedAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$CachedPagesTableAnnotationComposer
|
|
extends Composer<_$MewsDatabase, $CachedPagesTable> {
|
|
$$CachedPagesTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get url =>
|
|
$composableBuilder(column: $table.url, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get title =>
|
|
$composableBuilder(column: $table.title, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get source =>
|
|
$composableBuilder(column: $table.source, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get etag =>
|
|
$composableBuilder(column: $table.etag, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get lastModified => $composableBuilder(
|
|
column: $table.lastModified,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<DateTime> get cachedAt =>
|
|
$composableBuilder(column: $table.cachedAt, builder: (column) => column);
|
|
}
|
|
|
|
class $$CachedPagesTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$MewsDatabase,
|
|
$CachedPagesTable,
|
|
CachedPage,
|
|
$$CachedPagesTableFilterComposer,
|
|
$$CachedPagesTableOrderingComposer,
|
|
$$CachedPagesTableAnnotationComposer,
|
|
$$CachedPagesTableCreateCompanionBuilder,
|
|
$$CachedPagesTableUpdateCompanionBuilder,
|
|
(
|
|
CachedPage,
|
|
BaseReferences<_$MewsDatabase, $CachedPagesTable, CachedPage>,
|
|
),
|
|
CachedPage,
|
|
PrefetchHooks Function()
|
|
> {
|
|
$$CachedPagesTableTableManager(_$MewsDatabase db, $CachedPagesTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$CachedPagesTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$CachedPagesTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$CachedPagesTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> url = const Value.absent(),
|
|
Value<String?> title = const Value.absent(),
|
|
Value<String> source = const Value.absent(),
|
|
Value<String?> etag = const Value.absent(),
|
|
Value<String?> lastModified = const Value.absent(),
|
|
Value<DateTime> cachedAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => CachedPagesCompanion(
|
|
url: url,
|
|
title: title,
|
|
source: source,
|
|
etag: etag,
|
|
lastModified: lastModified,
|
|
cachedAt: cachedAt,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String url,
|
|
Value<String?> title = const Value.absent(),
|
|
required String source,
|
|
Value<String?> etag = const Value.absent(),
|
|
Value<String?> lastModified = const Value.absent(),
|
|
Value<DateTime> cachedAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => CachedPagesCompanion.insert(
|
|
url: url,
|
|
title: title,
|
|
source: source,
|
|
etag: etag,
|
|
lastModified: lastModified,
|
|
cachedAt: cachedAt,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$CachedPagesTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$MewsDatabase,
|
|
$CachedPagesTable,
|
|
CachedPage,
|
|
$$CachedPagesTableFilterComposer,
|
|
$$CachedPagesTableOrderingComposer,
|
|
$$CachedPagesTableAnnotationComposer,
|
|
$$CachedPagesTableCreateCompanionBuilder,
|
|
$$CachedPagesTableUpdateCompanionBuilder,
|
|
(
|
|
CachedPage,
|
|
BaseReferences<_$MewsDatabase, $CachedPagesTable, CachedPage>,
|
|
),
|
|
CachedPage,
|
|
PrefetchHooks Function()
|
|
>;
|
|
|
|
class $MewsDatabaseManager {
|
|
final _$MewsDatabase _db;
|
|
$MewsDatabaseManager(this._db);
|
|
$$HistoryItemsTableTableManager get historyItems =>
|
|
$$HistoryItemsTableTableManager(_db, _db.historyItems);
|
|
$$BookmarksTableTableManager get bookmarks =>
|
|
$$BookmarksTableTableManager(_db, _db.bookmarks);
|
|
$$SubscriptionsTableTableManager get subscriptions =>
|
|
$$SubscriptionsTableTableManager(_db, _db.subscriptions);
|
|
$$FeedEntriesTableTableManager get feedEntries =>
|
|
$$FeedEntriesTableTableManager(_db, _db.feedEntries);
|
|
$$ItemTagsTableTableManager get itemTags =>
|
|
$$ItemTagsTableTableManager(_db, _db.itemTags);
|
|
$$ReaderSettingsTableTableManager get readerSettings =>
|
|
$$ReaderSettingsTableTableManager(_db, _db.readerSettings);
|
|
$$CachedPagesTableTableManager get cachedPages =>
|
|
$$CachedPagesTableTableManager(_db, _db.cachedPages);
|
|
}
|