1310 lines
46 KiB
Dart
1310 lines
46 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'database.dart';
|
|
|
|
// ignore_for_file: type=lint
|
|
class BangTable extends Table with TableInfo<BangTable, Bang> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
BangTable(this.attachedDatabase, [this._alias]);
|
|
late final GeneratedColumn<String> trigger = GeneratedColumn<String>(
|
|
'trigger', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: 'PRIMARY KEY NOT NULL');
|
|
late final GeneratedColumnWithTypeConverter<BangGroup?, int> group =
|
|
GeneratedColumn<int>('group', aliasedName, true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: '')
|
|
.withConverter<BangGroup?>(BangTable.$convertergroupn);
|
|
late final GeneratedColumn<String> websiteName = GeneratedColumn<String>(
|
|
'website_name', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: 'NOT NULL');
|
|
late final GeneratedColumn<String> domain = GeneratedColumn<String>(
|
|
'domain', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: 'NOT NULL');
|
|
late final GeneratedColumn<String> urlTemplate = GeneratedColumn<String>(
|
|
'url_template', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: 'NOT NULL');
|
|
late final GeneratedColumn<String> category = GeneratedColumn<String>(
|
|
'category', aliasedName, true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: '');
|
|
late final GeneratedColumn<String> subCategory = GeneratedColumn<String>(
|
|
'sub_category', aliasedName, true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: '');
|
|
late final GeneratedColumnWithTypeConverter<Set<BangFormat>?, String> format =
|
|
GeneratedColumn<String>('format', aliasedName, true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: '')
|
|
.withConverter<Set<BangFormat>?>(BangTable.$converterformat);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
trigger,
|
|
group,
|
|
websiteName,
|
|
domain,
|
|
urlTemplate,
|
|
category,
|
|
subCategory,
|
|
format
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'bang';
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {trigger};
|
|
@override
|
|
Bang map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return Bang(
|
|
websiteName: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}website_name'])!,
|
|
domain: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}domain'])!,
|
|
trigger: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}trigger'])!,
|
|
urlTemplate: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}url_template'])!,
|
|
group: BangTable.$convertergroupn.fromSql(attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}group'])),
|
|
category: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}category']),
|
|
subCategory: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}sub_category']),
|
|
format: BangTable.$converterformat.fromSql(attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}format'])),
|
|
);
|
|
}
|
|
|
|
@override
|
|
BangTable createAlias(String alias) {
|
|
return BangTable(attachedDatabase, alias);
|
|
}
|
|
|
|
static JsonTypeConverter2<BangGroup, int, int> $convertergroup =
|
|
const EnumIndexConverter<BangGroup>(BangGroup.values);
|
|
static JsonTypeConverter2<BangGroup?, int?, int?> $convertergroupn =
|
|
JsonTypeConverter2.asNullable($convertergroup);
|
|
static TypeConverter<Set<BangFormat>?, String?> $converterformat =
|
|
const BangFormatConverter();
|
|
@override
|
|
bool get dontWriteConstraints => true;
|
|
}
|
|
|
|
class BangCompanion extends UpdateCompanion<Bang> {
|
|
final Value<String> trigger;
|
|
final Value<BangGroup?> group;
|
|
final Value<String> websiteName;
|
|
final Value<String> domain;
|
|
final Value<String> urlTemplate;
|
|
final Value<String?> category;
|
|
final Value<String?> subCategory;
|
|
final Value<Set<BangFormat>?> format;
|
|
final Value<int> rowid;
|
|
const BangCompanion({
|
|
this.trigger = const Value.absent(),
|
|
this.group = const Value.absent(),
|
|
this.websiteName = const Value.absent(),
|
|
this.domain = const Value.absent(),
|
|
this.urlTemplate = const Value.absent(),
|
|
this.category = const Value.absent(),
|
|
this.subCategory = const Value.absent(),
|
|
this.format = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
BangCompanion.insert({
|
|
required String trigger,
|
|
this.group = const Value.absent(),
|
|
required String websiteName,
|
|
required String domain,
|
|
required String urlTemplate,
|
|
this.category = const Value.absent(),
|
|
this.subCategory = const Value.absent(),
|
|
this.format = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
}) : trigger = Value(trigger),
|
|
websiteName = Value(websiteName),
|
|
domain = Value(domain),
|
|
urlTemplate = Value(urlTemplate);
|
|
static Insertable<Bang> custom({
|
|
Expression<String>? trigger,
|
|
Expression<int>? group,
|
|
Expression<String>? websiteName,
|
|
Expression<String>? domain,
|
|
Expression<String>? urlTemplate,
|
|
Expression<String>? category,
|
|
Expression<String>? subCategory,
|
|
Expression<String>? format,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (trigger != null) 'trigger': trigger,
|
|
if (group != null) 'group': group,
|
|
if (websiteName != null) 'website_name': websiteName,
|
|
if (domain != null) 'domain': domain,
|
|
if (urlTemplate != null) 'url_template': urlTemplate,
|
|
if (category != null) 'category': category,
|
|
if (subCategory != null) 'sub_category': subCategory,
|
|
if (format != null) 'format': format,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
BangCompanion copyWith(
|
|
{Value<String>? trigger,
|
|
Value<BangGroup?>? group,
|
|
Value<String>? websiteName,
|
|
Value<String>? domain,
|
|
Value<String>? urlTemplate,
|
|
Value<String?>? category,
|
|
Value<String?>? subCategory,
|
|
Value<Set<BangFormat>?>? format,
|
|
Value<int>? rowid}) {
|
|
return BangCompanion(
|
|
trigger: trigger ?? this.trigger,
|
|
group: group ?? this.group,
|
|
websiteName: websiteName ?? this.websiteName,
|
|
domain: domain ?? this.domain,
|
|
urlTemplate: urlTemplate ?? this.urlTemplate,
|
|
category: category ?? this.category,
|
|
subCategory: subCategory ?? this.subCategory,
|
|
format: format ?? this.format,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (trigger.present) {
|
|
map['trigger'] = Variable<String>(trigger.value);
|
|
}
|
|
if (group.present) {
|
|
map['group'] =
|
|
Variable<int>(BangTable.$convertergroupn.toSql(group.value));
|
|
}
|
|
if (websiteName.present) {
|
|
map['website_name'] = Variable<String>(websiteName.value);
|
|
}
|
|
if (domain.present) {
|
|
map['domain'] = Variable<String>(domain.value);
|
|
}
|
|
if (urlTemplate.present) {
|
|
map['url_template'] = Variable<String>(urlTemplate.value);
|
|
}
|
|
if (category.present) {
|
|
map['category'] = Variable<String>(category.value);
|
|
}
|
|
if (subCategory.present) {
|
|
map['sub_category'] = Variable<String>(subCategory.value);
|
|
}
|
|
if (format.present) {
|
|
map['format'] =
|
|
Variable<String>(BangTable.$converterformat.toSql(format.value));
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('BangCompanion(')
|
|
..write('trigger: $trigger, ')
|
|
..write('group: $group, ')
|
|
..write('websiteName: $websiteName, ')
|
|
..write('domain: $domain, ')
|
|
..write('urlTemplate: $urlTemplate, ')
|
|
..write('category: $category, ')
|
|
..write('subCategory: $subCategory, ')
|
|
..write('format: $format, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class BangFrequency extends Table
|
|
with TableInfo<BangFrequency, BangFrequencyData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
BangFrequency(this.attachedDatabase, [this._alias]);
|
|
late final GeneratedColumn<String> trigger = GeneratedColumn<String>(
|
|
'trigger', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
$customConstraints:
|
|
'PRIMARY KEY NOT NULL REFERENCES bang("trigger")ON DELETE CASCADE');
|
|
late final GeneratedColumn<int> frequency = GeneratedColumn<int>(
|
|
'frequency', aliasedName, false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: 'NOT NULL');
|
|
late final GeneratedColumn<DateTime> lastUsed = GeneratedColumn<DateTime>(
|
|
'last_used', aliasedName, false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: 'NOT NULL');
|
|
@override
|
|
List<GeneratedColumn> get $columns => [trigger, frequency, lastUsed];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'bang_frequency';
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {trigger};
|
|
@override
|
|
BangFrequencyData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return BangFrequencyData(
|
|
trigger: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}trigger'])!,
|
|
frequency: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}frequency'])!,
|
|
lastUsed: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.dateTime, data['${effectivePrefix}last_used'])!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
BangFrequency createAlias(String alias) {
|
|
return BangFrequency(attachedDatabase, alias);
|
|
}
|
|
|
|
@override
|
|
bool get dontWriteConstraints => true;
|
|
}
|
|
|
|
class BangFrequencyData extends DataClass
|
|
implements Insertable<BangFrequencyData> {
|
|
final String trigger;
|
|
final int frequency;
|
|
final DateTime lastUsed;
|
|
const BangFrequencyData(
|
|
{required this.trigger, required this.frequency, required this.lastUsed});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['trigger'] = Variable<String>(trigger);
|
|
map['frequency'] = Variable<int>(frequency);
|
|
map['last_used'] = Variable<DateTime>(lastUsed);
|
|
return map;
|
|
}
|
|
|
|
factory BangFrequencyData.fromJson(Map<String, dynamic> json,
|
|
{ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return BangFrequencyData(
|
|
trigger: serializer.fromJson<String>(json['trigger']),
|
|
frequency: serializer.fromJson<int>(json['frequency']),
|
|
lastUsed: serializer.fromJson<DateTime>(json['last_used']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'trigger': serializer.toJson<String>(trigger),
|
|
'frequency': serializer.toJson<int>(frequency),
|
|
'last_used': serializer.toJson<DateTime>(lastUsed),
|
|
};
|
|
}
|
|
|
|
BangFrequencyData copyWith(
|
|
{String? trigger, int? frequency, DateTime? lastUsed}) =>
|
|
BangFrequencyData(
|
|
trigger: trigger ?? this.trigger,
|
|
frequency: frequency ?? this.frequency,
|
|
lastUsed: lastUsed ?? this.lastUsed,
|
|
);
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('BangFrequencyData(')
|
|
..write('trigger: $trigger, ')
|
|
..write('frequency: $frequency, ')
|
|
..write('lastUsed: $lastUsed')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(trigger, frequency, lastUsed);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is BangFrequencyData &&
|
|
other.trigger == this.trigger &&
|
|
other.frequency == this.frequency &&
|
|
other.lastUsed == this.lastUsed);
|
|
}
|
|
|
|
class BangFrequencyCompanion extends UpdateCompanion<BangFrequencyData> {
|
|
final Value<String> trigger;
|
|
final Value<int> frequency;
|
|
final Value<DateTime> lastUsed;
|
|
final Value<int> rowid;
|
|
const BangFrequencyCompanion({
|
|
this.trigger = const Value.absent(),
|
|
this.frequency = const Value.absent(),
|
|
this.lastUsed = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
BangFrequencyCompanion.insert({
|
|
required String trigger,
|
|
required int frequency,
|
|
required DateTime lastUsed,
|
|
this.rowid = const Value.absent(),
|
|
}) : trigger = Value(trigger),
|
|
frequency = Value(frequency),
|
|
lastUsed = Value(lastUsed);
|
|
static Insertable<BangFrequencyData> custom({
|
|
Expression<String>? trigger,
|
|
Expression<int>? frequency,
|
|
Expression<DateTime>? lastUsed,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (trigger != null) 'trigger': trigger,
|
|
if (frequency != null) 'frequency': frequency,
|
|
if (lastUsed != null) 'last_used': lastUsed,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
BangFrequencyCompanion copyWith(
|
|
{Value<String>? trigger,
|
|
Value<int>? frequency,
|
|
Value<DateTime>? lastUsed,
|
|
Value<int>? rowid}) {
|
|
return BangFrequencyCompanion(
|
|
trigger: trigger ?? this.trigger,
|
|
frequency: frequency ?? this.frequency,
|
|
lastUsed: lastUsed ?? this.lastUsed,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (trigger.present) {
|
|
map['trigger'] = Variable<String>(trigger.value);
|
|
}
|
|
if (frequency.present) {
|
|
map['frequency'] = Variable<int>(frequency.value);
|
|
}
|
|
if (lastUsed.present) {
|
|
map['last_used'] = Variable<DateTime>(lastUsed.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('BangFrequencyCompanion(')
|
|
..write('trigger: $trigger, ')
|
|
..write('frequency: $frequency, ')
|
|
..write('lastUsed: $lastUsed, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class BangIcon extends Table with TableInfo<BangIcon, BangIconData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
BangIcon(this.attachedDatabase, [this._alias]);
|
|
late final GeneratedColumn<String> trigger = GeneratedColumn<String>(
|
|
'trigger', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
$customConstraints:
|
|
'PRIMARY KEY NOT NULL REFERENCES bang("trigger")ON DELETE CASCADE');
|
|
late final GeneratedColumn<Uint8List> iconData = GeneratedColumn<Uint8List>(
|
|
'icon_data', aliasedName, false,
|
|
type: DriftSqlType.blob,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: 'NOT NULL');
|
|
late final GeneratedColumn<DateTime> fetchDate = GeneratedColumn<DateTime>(
|
|
'fetch_date', aliasedName, false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: 'NOT NULL');
|
|
@override
|
|
List<GeneratedColumn> get $columns => [trigger, iconData, fetchDate];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'bang_icon';
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {trigger};
|
|
@override
|
|
BangIconData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return BangIconData(
|
|
trigger: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}trigger'])!,
|
|
iconData: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.blob, data['${effectivePrefix}icon_data'])!,
|
|
fetchDate: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.dateTime, data['${effectivePrefix}fetch_date'])!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
BangIcon createAlias(String alias) {
|
|
return BangIcon(attachedDatabase, alias);
|
|
}
|
|
|
|
@override
|
|
bool get dontWriteConstraints => true;
|
|
}
|
|
|
|
class BangIconData extends DataClass implements Insertable<BangIconData> {
|
|
final String trigger;
|
|
final Uint8List iconData;
|
|
final DateTime fetchDate;
|
|
const BangIconData(
|
|
{required this.trigger, required this.iconData, required this.fetchDate});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['trigger'] = Variable<String>(trigger);
|
|
map['icon_data'] = Variable<Uint8List>(iconData);
|
|
map['fetch_date'] = Variable<DateTime>(fetchDate);
|
|
return map;
|
|
}
|
|
|
|
factory BangIconData.fromJson(Map<String, dynamic> json,
|
|
{ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return BangIconData(
|
|
trigger: serializer.fromJson<String>(json['trigger']),
|
|
iconData: serializer.fromJson<Uint8List>(json['icon_data']),
|
|
fetchDate: serializer.fromJson<DateTime>(json['fetch_date']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'trigger': serializer.toJson<String>(trigger),
|
|
'icon_data': serializer.toJson<Uint8List>(iconData),
|
|
'fetch_date': serializer.toJson<DateTime>(fetchDate),
|
|
};
|
|
}
|
|
|
|
BangIconData copyWith(
|
|
{String? trigger, Uint8List? iconData, DateTime? fetchDate}) =>
|
|
BangIconData(
|
|
trigger: trigger ?? this.trigger,
|
|
iconData: iconData ?? this.iconData,
|
|
fetchDate: fetchDate ?? this.fetchDate,
|
|
);
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('BangIconData(')
|
|
..write('trigger: $trigger, ')
|
|
..write('iconData: $iconData, ')
|
|
..write('fetchDate: $fetchDate')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode =>
|
|
Object.hash(trigger, $driftBlobEquality.hash(iconData), fetchDate);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is BangIconData &&
|
|
other.trigger == this.trigger &&
|
|
$driftBlobEquality.equals(other.iconData, this.iconData) &&
|
|
other.fetchDate == this.fetchDate);
|
|
}
|
|
|
|
class BangIconCompanion extends UpdateCompanion<BangIconData> {
|
|
final Value<String> trigger;
|
|
final Value<Uint8List> iconData;
|
|
final Value<DateTime> fetchDate;
|
|
final Value<int> rowid;
|
|
const BangIconCompanion({
|
|
this.trigger = const Value.absent(),
|
|
this.iconData = const Value.absent(),
|
|
this.fetchDate = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
BangIconCompanion.insert({
|
|
required String trigger,
|
|
required Uint8List iconData,
|
|
required DateTime fetchDate,
|
|
this.rowid = const Value.absent(),
|
|
}) : trigger = Value(trigger),
|
|
iconData = Value(iconData),
|
|
fetchDate = Value(fetchDate);
|
|
static Insertable<BangIconData> custom({
|
|
Expression<String>? trigger,
|
|
Expression<Uint8List>? iconData,
|
|
Expression<DateTime>? fetchDate,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (trigger != null) 'trigger': trigger,
|
|
if (iconData != null) 'icon_data': iconData,
|
|
if (fetchDate != null) 'fetch_date': fetchDate,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
BangIconCompanion copyWith(
|
|
{Value<String>? trigger,
|
|
Value<Uint8List>? iconData,
|
|
Value<DateTime>? fetchDate,
|
|
Value<int>? rowid}) {
|
|
return BangIconCompanion(
|
|
trigger: trigger ?? this.trigger,
|
|
iconData: iconData ?? this.iconData,
|
|
fetchDate: fetchDate ?? this.fetchDate,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (trigger.present) {
|
|
map['trigger'] = Variable<String>(trigger.value);
|
|
}
|
|
if (iconData.present) {
|
|
map['icon_data'] = Variable<Uint8List>(iconData.value);
|
|
}
|
|
if (fetchDate.present) {
|
|
map['fetch_date'] = Variable<DateTime>(fetchDate.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('BangIconCompanion(')
|
|
..write('trigger: $trigger, ')
|
|
..write('iconData: $iconData, ')
|
|
..write('fetchDate: $fetchDate, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class BangFts extends Table
|
|
with TableInfo<BangFts, BangFt>, VirtualTableInfo<BangFts, BangFt> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
BangFts(this.attachedDatabase, [this._alias]);
|
|
late final GeneratedColumn<String> trigger = GeneratedColumn<String>(
|
|
'trigger', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: '');
|
|
late final GeneratedColumn<String> websiteName = GeneratedColumn<String>(
|
|
'website_name', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: '');
|
|
@override
|
|
List<GeneratedColumn> get $columns => [trigger, websiteName];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'bang_fts';
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => const {};
|
|
@override
|
|
BangFt map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return BangFt(
|
|
trigger: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}trigger'])!,
|
|
websiteName: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}website_name'])!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
BangFts createAlias(String alias) {
|
|
return BangFts(attachedDatabase, alias);
|
|
}
|
|
|
|
@override
|
|
bool get dontWriteConstraints => true;
|
|
@override
|
|
String get moduleAndArgs =>
|
|
'fts5(trigger, website_name, content=bang, prefix=\'2 3\')';
|
|
}
|
|
|
|
class BangFt extends DataClass implements Insertable<BangFt> {
|
|
final String trigger;
|
|
final String websiteName;
|
|
const BangFt({required this.trigger, required this.websiteName});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['trigger'] = Variable<String>(trigger);
|
|
map['website_name'] = Variable<String>(websiteName);
|
|
return map;
|
|
}
|
|
|
|
factory BangFt.fromJson(Map<String, dynamic> json,
|
|
{ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return BangFt(
|
|
trigger: serializer.fromJson<String>(json['trigger']),
|
|
websiteName: serializer.fromJson<String>(json['website_name']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'trigger': serializer.toJson<String>(trigger),
|
|
'website_name': serializer.toJson<String>(websiteName),
|
|
};
|
|
}
|
|
|
|
BangFt copyWith({String? trigger, String? websiteName}) => BangFt(
|
|
trigger: trigger ?? this.trigger,
|
|
websiteName: websiteName ?? this.websiteName,
|
|
);
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('BangFt(')
|
|
..write('trigger: $trigger, ')
|
|
..write('websiteName: $websiteName')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(trigger, websiteName);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is BangFt &&
|
|
other.trigger == this.trigger &&
|
|
other.websiteName == this.websiteName);
|
|
}
|
|
|
|
class BangFtsCompanion extends UpdateCompanion<BangFt> {
|
|
final Value<String> trigger;
|
|
final Value<String> websiteName;
|
|
final Value<int> rowid;
|
|
const BangFtsCompanion({
|
|
this.trigger = const Value.absent(),
|
|
this.websiteName = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
BangFtsCompanion.insert({
|
|
required String trigger,
|
|
required String websiteName,
|
|
this.rowid = const Value.absent(),
|
|
}) : trigger = Value(trigger),
|
|
websiteName = Value(websiteName);
|
|
static Insertable<BangFt> custom({
|
|
Expression<String>? trigger,
|
|
Expression<String>? websiteName,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (trigger != null) 'trigger': trigger,
|
|
if (websiteName != null) 'website_name': websiteName,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
BangFtsCompanion copyWith(
|
|
{Value<String>? trigger, Value<String>? websiteName, Value<int>? rowid}) {
|
|
return BangFtsCompanion(
|
|
trigger: trigger ?? this.trigger,
|
|
websiteName: websiteName ?? this.websiteName,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (trigger.present) {
|
|
map['trigger'] = Variable<String>(trigger.value);
|
|
}
|
|
if (websiteName.present) {
|
|
map['website_name'] = Variable<String>(websiteName.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('BangFtsCompanion(')
|
|
..write('trigger: $trigger, ')
|
|
..write('websiteName: $websiteName, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class BangDataView extends ViewInfo<BangDataView, BangData>
|
|
implements HasResultSet {
|
|
final String? _alias;
|
|
@override
|
|
final _$BangDatabase attachedDatabase;
|
|
BangDataView(this.attachedDatabase, [this._alias]);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
trigger,
|
|
group,
|
|
websiteName,
|
|
domain,
|
|
urlTemplate,
|
|
category,
|
|
subCategory,
|
|
format,
|
|
frequency,
|
|
lastUsed,
|
|
iconData
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? entityName;
|
|
@override
|
|
String get entityName => 'bang_data_view';
|
|
@override
|
|
Map<SqlDialect, String> get createViewStatements => {
|
|
SqlDialect.sqlite:
|
|
'CREATE VIEW bang_data_view WITH BangData AS SELECT b.*, bf.frequency, bf.last_used, bi.icon_data FROM bang AS b LEFT JOIN bang_frequency AS bf ON b."trigger" = bf."trigger" LEFT JOIN bang_icon AS bi ON b."trigger" = bi."trigger"',
|
|
};
|
|
@override
|
|
BangDataView get asDslTable => this;
|
|
@override
|
|
BangData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return BangData(
|
|
websiteName: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}website_name'])!,
|
|
domain: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}domain'])!,
|
|
trigger: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}trigger'])!,
|
|
urlTemplate: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}url_template'])!,
|
|
category: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}category']),
|
|
subCategory: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}sub_category']),
|
|
format: BangTable.$converterformat.fromSql(attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}format'])),
|
|
frequency: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}frequency']),
|
|
lastUsed: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.dateTime, data['${effectivePrefix}last_used']),
|
|
iconData: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.blob, data['${effectivePrefix}icon_data']),
|
|
);
|
|
}
|
|
|
|
late final GeneratedColumn<String> trigger = GeneratedColumn<String>(
|
|
'trigger', aliasedName, false,
|
|
type: DriftSqlType.string);
|
|
late final GeneratedColumnWithTypeConverter<BangGroup?, int> group =
|
|
GeneratedColumn<int>('group', aliasedName, true, type: DriftSqlType.int)
|
|
.withConverter<BangGroup?>(BangTable.$convertergroupn);
|
|
late final GeneratedColumn<String> websiteName = GeneratedColumn<String>(
|
|
'website_name', aliasedName, false,
|
|
type: DriftSqlType.string);
|
|
late final GeneratedColumn<String> domain = GeneratedColumn<String>(
|
|
'domain', aliasedName, false,
|
|
type: DriftSqlType.string);
|
|
late final GeneratedColumn<String> urlTemplate = GeneratedColumn<String>(
|
|
'url_template', aliasedName, false,
|
|
type: DriftSqlType.string);
|
|
late final GeneratedColumn<String> category = GeneratedColumn<String>(
|
|
'category', aliasedName, true,
|
|
type: DriftSqlType.string);
|
|
late final GeneratedColumn<String> subCategory = GeneratedColumn<String>(
|
|
'sub_category', aliasedName, true,
|
|
type: DriftSqlType.string);
|
|
late final GeneratedColumnWithTypeConverter<Set<BangFormat>?, String> format =
|
|
GeneratedColumn<String>('format', aliasedName, true,
|
|
type: DriftSqlType.string)
|
|
.withConverter<Set<BangFormat>?>(BangTable.$converterformat);
|
|
late final GeneratedColumn<int> frequency = GeneratedColumn<int>(
|
|
'frequency', aliasedName, true,
|
|
type: DriftSqlType.int);
|
|
late final GeneratedColumn<DateTime> lastUsed = GeneratedColumn<DateTime>(
|
|
'last_used', aliasedName, true,
|
|
type: DriftSqlType.dateTime);
|
|
late final GeneratedColumn<Uint8List> iconData = GeneratedColumn<Uint8List>(
|
|
'icon_data', aliasedName, true,
|
|
type: DriftSqlType.blob);
|
|
@override
|
|
BangDataView createAlias(String alias) {
|
|
return BangDataView(attachedDatabase, alias);
|
|
}
|
|
|
|
@override
|
|
Query? get query => null;
|
|
@override
|
|
Set<String> get readTables => const {'bang', 'bang_frequency', 'bang_icon'};
|
|
}
|
|
|
|
abstract class _$BangDatabase extends GeneratedDatabase {
|
|
_$BangDatabase(QueryExecutor e) : super(e);
|
|
_$BangDatabaseManager get managers => _$BangDatabaseManager(this);
|
|
late final BangTable bang = BangTable(this);
|
|
late final BangFrequency bangFrequency = BangFrequency(this);
|
|
late final BangIcon bangIcon = BangIcon(this);
|
|
late final BangFts bangFts = BangFts(this);
|
|
late final BangDataView bangDataView = BangDataView(this);
|
|
late final Trigger bangAfterInsert = Trigger(
|
|
'CREATE TRIGGER bang_after_insert AFTER INSERT ON bang BEGIN INSERT INTO bang_fts ("rowid", "trigger", website_name) VALUES (new."rowid", new."trigger", new.website_name);END',
|
|
'bang_after_insert');
|
|
late final Trigger bangAfterDelete = Trigger(
|
|
'CREATE TRIGGER bang_after_delete AFTER DELETE ON bang BEGIN INSERT INTO bang_fts (bang_fts, "rowid", "trigger", website_name) VALUES (\'delete\', old."rowid", old."trigger", old.website_name);END',
|
|
'bang_after_delete');
|
|
late final Trigger bangAfterUpdate = Trigger(
|
|
'CREATE TRIGGER bang_after_update AFTER UPDATE ON bang BEGIN INSERT INTO bang_fts (bang_fts, "rowid", "trigger", website_name) VALUES (\'delete\', old."rowid", old."trigger", old.website_name);INSERT INTO bang_fts ("rowid", "trigger", website_name) VALUES (new."rowid", new."trigger", new.website_name);END',
|
|
'bang_after_update');
|
|
late final BangDao bangDao = BangDao(this as BangDatabase);
|
|
Future<int> optimizeFtsIndex() {
|
|
return customInsert(
|
|
'INSERT INTO bang_fts (bang_fts) VALUES (\'optimize\')',
|
|
variables: [],
|
|
updates: {bangFts},
|
|
);
|
|
}
|
|
|
|
Selectable<BangData> bangQuery({required String query}) {
|
|
return customSelect(
|
|
'SELECT b.*, bf.frequency, bf.last_used, bi.icon_data FROM bang_fts(?1)AS fts INNER JOIN bang AS b ON b."rowid" = fts."rowid" LEFT JOIN bang_frequency AS bf ON b."trigger" = bf."trigger" LEFT JOIN bang_icon AS bi ON b."trigger" = bi."trigger" ORDER BY RANK, bf.frequency NULLS LAST',
|
|
variables: [
|
|
Variable<String>(query)
|
|
],
|
|
readsFrom: {
|
|
bangFrequency,
|
|
bangIcon,
|
|
bang,
|
|
bangFts,
|
|
}).map((QueryRow row) => BangData(
|
|
websiteName: row.read<String>('website_name'),
|
|
domain: row.read<String>('domain'),
|
|
trigger: row.read<String>('trigger'),
|
|
urlTemplate: row.read<String>('url_template'),
|
|
category: row.readNullable<String>('category'),
|
|
subCategory: row.readNullable<String>('sub_category'),
|
|
format: BangTable.$converterformat
|
|
.fromSql(row.readNullable<String>('format')),
|
|
frequency: row.readNullable<int>('frequency'),
|
|
lastUsed: row.readNullable<DateTime>('last_used'),
|
|
iconData: row.readNullable<Uint8List>('icon_data'),
|
|
));
|
|
}
|
|
|
|
@override
|
|
Iterable<TableInfo<Table, Object?>> get allTables =>
|
|
allSchemaEntities.whereType<TableInfo<Table, Object?>>();
|
|
@override
|
|
List<DatabaseSchemaEntity> get allSchemaEntities => [
|
|
bang,
|
|
bangFrequency,
|
|
bangIcon,
|
|
bangFts,
|
|
bangDataView,
|
|
bangAfterInsert,
|
|
bangAfterDelete,
|
|
bangAfterUpdate
|
|
];
|
|
@override
|
|
StreamQueryUpdateRules get streamUpdateRules => const StreamQueryUpdateRules(
|
|
[
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName('bang',
|
|
limitUpdateKind: UpdateKind.delete),
|
|
result: [
|
|
TableUpdate('bang_frequency', kind: UpdateKind.delete),
|
|
],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName('bang',
|
|
limitUpdateKind: UpdateKind.delete),
|
|
result: [
|
|
TableUpdate('bang_icon', kind: UpdateKind.delete),
|
|
],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName('bang',
|
|
limitUpdateKind: UpdateKind.insert),
|
|
result: [
|
|
TableUpdate('bang_fts', kind: UpdateKind.insert),
|
|
],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName('bang',
|
|
limitUpdateKind: UpdateKind.delete),
|
|
result: [
|
|
TableUpdate('bang_fts', kind: UpdateKind.insert),
|
|
],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName('bang',
|
|
limitUpdateKind: UpdateKind.update),
|
|
result: [
|
|
TableUpdate('bang_fts', kind: UpdateKind.insert),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
typedef $BangFrequencyInsertCompanionBuilder = BangFrequencyCompanion Function({
|
|
required String trigger,
|
|
required int frequency,
|
|
required DateTime lastUsed,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $BangFrequencyUpdateCompanionBuilder = BangFrequencyCompanion Function({
|
|
Value<String> trigger,
|
|
Value<int> frequency,
|
|
Value<DateTime> lastUsed,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
class $BangFrequencyTableManager extends RootTableManager<
|
|
_$BangDatabase,
|
|
BangFrequency,
|
|
BangFrequencyData,
|
|
$BangFrequencyFilterComposer,
|
|
$BangFrequencyOrderingComposer,
|
|
$BangFrequencyProcessedTableManager,
|
|
$BangFrequencyInsertCompanionBuilder,
|
|
$BangFrequencyUpdateCompanionBuilder> {
|
|
$BangFrequencyTableManager(_$BangDatabase db, BangFrequency table)
|
|
: super(TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
filteringComposer:
|
|
$BangFrequencyFilterComposer(ComposerState(db, table)),
|
|
orderingComposer:
|
|
$BangFrequencyOrderingComposer(ComposerState(db, table)),
|
|
getChildManagerBuilder: (p) => $BangFrequencyProcessedTableManager(p),
|
|
getUpdateCompanionBuilder: ({
|
|
Value<String> trigger = const Value.absent(),
|
|
Value<int> frequency = const Value.absent(),
|
|
Value<DateTime> lastUsed = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
BangFrequencyCompanion(
|
|
trigger: trigger,
|
|
frequency: frequency,
|
|
lastUsed: lastUsed,
|
|
rowid: rowid,
|
|
),
|
|
getInsertCompanionBuilder: ({
|
|
required String trigger,
|
|
required int frequency,
|
|
required DateTime lastUsed,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
BangFrequencyCompanion.insert(
|
|
trigger: trigger,
|
|
frequency: frequency,
|
|
lastUsed: lastUsed,
|
|
rowid: rowid,
|
|
),
|
|
));
|
|
}
|
|
|
|
class $BangFrequencyProcessedTableManager extends ProcessedTableManager<
|
|
_$BangDatabase,
|
|
BangFrequency,
|
|
BangFrequencyData,
|
|
$BangFrequencyFilterComposer,
|
|
$BangFrequencyOrderingComposer,
|
|
$BangFrequencyProcessedTableManager,
|
|
$BangFrequencyInsertCompanionBuilder,
|
|
$BangFrequencyUpdateCompanionBuilder> {
|
|
$BangFrequencyProcessedTableManager(super.$state);
|
|
}
|
|
|
|
class $BangFrequencyFilterComposer
|
|
extends FilterComposer<_$BangDatabase, BangFrequency> {
|
|
$BangFrequencyFilterComposer(super.$state);
|
|
ColumnFilters<String> get trigger => $state.composableBuilder(
|
|
column: $state.table.trigger,
|
|
builder: (column, joinBuilders) =>
|
|
ColumnFilters(column, joinBuilders: joinBuilders));
|
|
|
|
ColumnFilters<int> get frequency => $state.composableBuilder(
|
|
column: $state.table.frequency,
|
|
builder: (column, joinBuilders) =>
|
|
ColumnFilters(column, joinBuilders: joinBuilders));
|
|
|
|
ColumnFilters<DateTime> get lastUsed => $state.composableBuilder(
|
|
column: $state.table.lastUsed,
|
|
builder: (column, joinBuilders) =>
|
|
ColumnFilters(column, joinBuilders: joinBuilders));
|
|
}
|
|
|
|
class $BangFrequencyOrderingComposer
|
|
extends OrderingComposer<_$BangDatabase, BangFrequency> {
|
|
$BangFrequencyOrderingComposer(super.$state);
|
|
ColumnOrderings<String> get trigger => $state.composableBuilder(
|
|
column: $state.table.trigger,
|
|
builder: (column, joinBuilders) =>
|
|
ColumnOrderings(column, joinBuilders: joinBuilders));
|
|
|
|
ColumnOrderings<int> get frequency => $state.composableBuilder(
|
|
column: $state.table.frequency,
|
|
builder: (column, joinBuilders) =>
|
|
ColumnOrderings(column, joinBuilders: joinBuilders));
|
|
|
|
ColumnOrderings<DateTime> get lastUsed => $state.composableBuilder(
|
|
column: $state.table.lastUsed,
|
|
builder: (column, joinBuilders) =>
|
|
ColumnOrderings(column, joinBuilders: joinBuilders));
|
|
}
|
|
|
|
typedef $BangIconInsertCompanionBuilder = BangIconCompanion Function({
|
|
required String trigger,
|
|
required Uint8List iconData,
|
|
required DateTime fetchDate,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $BangIconUpdateCompanionBuilder = BangIconCompanion Function({
|
|
Value<String> trigger,
|
|
Value<Uint8List> iconData,
|
|
Value<DateTime> fetchDate,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
class $BangIconTableManager extends RootTableManager<
|
|
_$BangDatabase,
|
|
BangIcon,
|
|
BangIconData,
|
|
$BangIconFilterComposer,
|
|
$BangIconOrderingComposer,
|
|
$BangIconProcessedTableManager,
|
|
$BangIconInsertCompanionBuilder,
|
|
$BangIconUpdateCompanionBuilder> {
|
|
$BangIconTableManager(_$BangDatabase db, BangIcon table)
|
|
: super(TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
filteringComposer: $BangIconFilterComposer(ComposerState(db, table)),
|
|
orderingComposer: $BangIconOrderingComposer(ComposerState(db, table)),
|
|
getChildManagerBuilder: (p) => $BangIconProcessedTableManager(p),
|
|
getUpdateCompanionBuilder: ({
|
|
Value<String> trigger = const Value.absent(),
|
|
Value<Uint8List> iconData = const Value.absent(),
|
|
Value<DateTime> fetchDate = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
BangIconCompanion(
|
|
trigger: trigger,
|
|
iconData: iconData,
|
|
fetchDate: fetchDate,
|
|
rowid: rowid,
|
|
),
|
|
getInsertCompanionBuilder: ({
|
|
required String trigger,
|
|
required Uint8List iconData,
|
|
required DateTime fetchDate,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
BangIconCompanion.insert(
|
|
trigger: trigger,
|
|
iconData: iconData,
|
|
fetchDate: fetchDate,
|
|
rowid: rowid,
|
|
),
|
|
));
|
|
}
|
|
|
|
class $BangIconProcessedTableManager extends ProcessedTableManager<
|
|
_$BangDatabase,
|
|
BangIcon,
|
|
BangIconData,
|
|
$BangIconFilterComposer,
|
|
$BangIconOrderingComposer,
|
|
$BangIconProcessedTableManager,
|
|
$BangIconInsertCompanionBuilder,
|
|
$BangIconUpdateCompanionBuilder> {
|
|
$BangIconProcessedTableManager(super.$state);
|
|
}
|
|
|
|
class $BangIconFilterComposer extends FilterComposer<_$BangDatabase, BangIcon> {
|
|
$BangIconFilterComposer(super.$state);
|
|
ColumnFilters<String> get trigger => $state.composableBuilder(
|
|
column: $state.table.trigger,
|
|
builder: (column, joinBuilders) =>
|
|
ColumnFilters(column, joinBuilders: joinBuilders));
|
|
|
|
ColumnFilters<Uint8List> get iconData => $state.composableBuilder(
|
|
column: $state.table.iconData,
|
|
builder: (column, joinBuilders) =>
|
|
ColumnFilters(column, joinBuilders: joinBuilders));
|
|
|
|
ColumnFilters<DateTime> get fetchDate => $state.composableBuilder(
|
|
column: $state.table.fetchDate,
|
|
builder: (column, joinBuilders) =>
|
|
ColumnFilters(column, joinBuilders: joinBuilders));
|
|
}
|
|
|
|
class $BangIconOrderingComposer
|
|
extends OrderingComposer<_$BangDatabase, BangIcon> {
|
|
$BangIconOrderingComposer(super.$state);
|
|
ColumnOrderings<String> get trigger => $state.composableBuilder(
|
|
column: $state.table.trigger,
|
|
builder: (column, joinBuilders) =>
|
|
ColumnOrderings(column, joinBuilders: joinBuilders));
|
|
|
|
ColumnOrderings<Uint8List> get iconData => $state.composableBuilder(
|
|
column: $state.table.iconData,
|
|
builder: (column, joinBuilders) =>
|
|
ColumnOrderings(column, joinBuilders: joinBuilders));
|
|
|
|
ColumnOrderings<DateTime> get fetchDate => $state.composableBuilder(
|
|
column: $state.table.fetchDate,
|
|
builder: (column, joinBuilders) =>
|
|
ColumnOrderings(column, joinBuilders: joinBuilders));
|
|
}
|
|
|
|
typedef $BangFtsInsertCompanionBuilder = BangFtsCompanion Function({
|
|
required String trigger,
|
|
required String websiteName,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $BangFtsUpdateCompanionBuilder = BangFtsCompanion Function({
|
|
Value<String> trigger,
|
|
Value<String> websiteName,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
class $BangFtsTableManager extends RootTableManager<
|
|
_$BangDatabase,
|
|
BangFts,
|
|
BangFt,
|
|
$BangFtsFilterComposer,
|
|
$BangFtsOrderingComposer,
|
|
$BangFtsProcessedTableManager,
|
|
$BangFtsInsertCompanionBuilder,
|
|
$BangFtsUpdateCompanionBuilder> {
|
|
$BangFtsTableManager(_$BangDatabase db, BangFts table)
|
|
: super(TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
filteringComposer: $BangFtsFilterComposer(ComposerState(db, table)),
|
|
orderingComposer: $BangFtsOrderingComposer(ComposerState(db, table)),
|
|
getChildManagerBuilder: (p) => $BangFtsProcessedTableManager(p),
|
|
getUpdateCompanionBuilder: ({
|
|
Value<String> trigger = const Value.absent(),
|
|
Value<String> websiteName = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
BangFtsCompanion(
|
|
trigger: trigger,
|
|
websiteName: websiteName,
|
|
rowid: rowid,
|
|
),
|
|
getInsertCompanionBuilder: ({
|
|
required String trigger,
|
|
required String websiteName,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
BangFtsCompanion.insert(
|
|
trigger: trigger,
|
|
websiteName: websiteName,
|
|
rowid: rowid,
|
|
),
|
|
));
|
|
}
|
|
|
|
class $BangFtsProcessedTableManager extends ProcessedTableManager<
|
|
_$BangDatabase,
|
|
BangFts,
|
|
BangFt,
|
|
$BangFtsFilterComposer,
|
|
$BangFtsOrderingComposer,
|
|
$BangFtsProcessedTableManager,
|
|
$BangFtsInsertCompanionBuilder,
|
|
$BangFtsUpdateCompanionBuilder> {
|
|
$BangFtsProcessedTableManager(super.$state);
|
|
}
|
|
|
|
class $BangFtsFilterComposer extends FilterComposer<_$BangDatabase, BangFts> {
|
|
$BangFtsFilterComposer(super.$state);
|
|
ColumnFilters<String> get trigger => $state.composableBuilder(
|
|
column: $state.table.trigger,
|
|
builder: (column, joinBuilders) =>
|
|
ColumnFilters(column, joinBuilders: joinBuilders));
|
|
|
|
ColumnFilters<String> get websiteName => $state.composableBuilder(
|
|
column: $state.table.websiteName,
|
|
builder: (column, joinBuilders) =>
|
|
ColumnFilters(column, joinBuilders: joinBuilders));
|
|
}
|
|
|
|
class $BangFtsOrderingComposer
|
|
extends OrderingComposer<_$BangDatabase, BangFts> {
|
|
$BangFtsOrderingComposer(super.$state);
|
|
ColumnOrderings<String> get trigger => $state.composableBuilder(
|
|
column: $state.table.trigger,
|
|
builder: (column, joinBuilders) =>
|
|
ColumnOrderings(column, joinBuilders: joinBuilders));
|
|
|
|
ColumnOrderings<String> get websiteName => $state.composableBuilder(
|
|
column: $state.table.websiteName,
|
|
builder: (column, joinBuilders) =>
|
|
ColumnOrderings(column, joinBuilders: joinBuilders));
|
|
}
|
|
|
|
class _$BangDatabaseManager {
|
|
final _$BangDatabase _db;
|
|
_$BangDatabaseManager(this._db);
|
|
$BangFrequencyTableManager get bangFrequency =>
|
|
$BangFrequencyTableManager(_db, _db.bangFrequency);
|
|
$BangIconTableManager get bangIcon =>
|
|
$BangIconTableManager(_db, _db.bangIcon);
|
|
$BangFtsTableManager get bangFts => $BangFtsTableManager(_db, _db.bangFts);
|
|
}
|