2945 lines
109 KiB
Dart
2945 lines
109 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'database.dart';
|
|
|
|
// ignore_for_file: type=lint
|
|
class Container extends Table with TableInfo<Container, ContainerData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
Container(this.attachedDatabase, [this._alias]);
|
|
late final GeneratedColumn<String> id = GeneratedColumn<String>(
|
|
'id', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: 'PRIMARY KEY NOT NULL');
|
|
late final GeneratedColumn<String> name = GeneratedColumn<String>(
|
|
'name', aliasedName, true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: '');
|
|
late final GeneratedColumnWithTypeConverter<Color, int> color =
|
|
GeneratedColumn<int>('color', aliasedName, false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: 'NOT NULL')
|
|
.withConverter<Color>(Container.$convertercolor);
|
|
late final GeneratedColumnWithTypeConverter<ContainerMetadata?, String>
|
|
metadata = GeneratedColumn<String>('metadata', aliasedName, true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: '')
|
|
.withConverter<ContainerMetadata?>(Container.$convertermetadatan);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, name, color, metadata];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'container';
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
ContainerData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return ContainerData(
|
|
id: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}id'])!,
|
|
name: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}name']),
|
|
color: Container.$convertercolor.fromSql(attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}color'])!),
|
|
metadata: Container.$convertermetadatan.fromSql(attachedDatabase
|
|
.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}metadata'])),
|
|
);
|
|
}
|
|
|
|
@override
|
|
Container createAlias(String alias) {
|
|
return Container(attachedDatabase, alias);
|
|
}
|
|
|
|
static TypeConverter<Color, int> $convertercolor = const ColorConverter();
|
|
static TypeConverter<ContainerMetadata, String> $convertermetadata =
|
|
const ContainerMetadataConverter();
|
|
static TypeConverter<ContainerMetadata?, String?> $convertermetadatan =
|
|
NullAwareTypeConverter.wrap($convertermetadata);
|
|
@override
|
|
bool get dontWriteConstraints => true;
|
|
}
|
|
|
|
class ContainerCompanion extends UpdateCompanion<ContainerData> {
|
|
final Value<String> id;
|
|
final Value<String?> name;
|
|
final Value<Color> color;
|
|
final Value<ContainerMetadata?> metadata;
|
|
final Value<int> rowid;
|
|
const ContainerCompanion({
|
|
this.id = const Value.absent(),
|
|
this.name = const Value.absent(),
|
|
this.color = const Value.absent(),
|
|
this.metadata = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
ContainerCompanion.insert({
|
|
required String id,
|
|
this.name = const Value.absent(),
|
|
required Color color,
|
|
this.metadata = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id),
|
|
color = Value(color);
|
|
static Insertable<ContainerData> custom({
|
|
Expression<String>? id,
|
|
Expression<String>? name,
|
|
Expression<int>? color,
|
|
Expression<String>? metadata,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (name != null) 'name': name,
|
|
if (color != null) 'color': color,
|
|
if (metadata != null) 'metadata': metadata,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
ContainerCompanion copyWith(
|
|
{Value<String>? id,
|
|
Value<String?>? name,
|
|
Value<Color>? color,
|
|
Value<ContainerMetadata?>? metadata,
|
|
Value<int>? rowid}) {
|
|
return ContainerCompanion(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
color: color ?? this.color,
|
|
metadata: metadata ?? this.metadata,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<String>(id.value);
|
|
}
|
|
if (name.present) {
|
|
map['name'] = Variable<String>(name.value);
|
|
}
|
|
if (color.present) {
|
|
map['color'] =
|
|
Variable<int>(Container.$convertercolor.toSql(color.value));
|
|
}
|
|
if (metadata.present) {
|
|
map['metadata'] =
|
|
Variable<String>(Container.$convertermetadatan.toSql(metadata.value));
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ContainerCompanion(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('color: $color, ')
|
|
..write('metadata: $metadata, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class Tab extends Table with TableInfo<Tab, TabData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
Tab(this.attachedDatabase, [this._alias]);
|
|
late final GeneratedColumn<String> id = GeneratedColumn<String>(
|
|
'id', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: 'PRIMARY KEY NOT NULL');
|
|
late final GeneratedColumn<String> containerId = GeneratedColumn<String>(
|
|
'container_id', aliasedName, true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: 'REFERENCES container(id)ON DELETE CASCADE');
|
|
late final GeneratedColumn<String> orderKey = GeneratedColumn<String>(
|
|
'order_key', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: 'NOT NULL');
|
|
late final GeneratedColumn<String> url = GeneratedColumn<String>(
|
|
'url', aliasedName, true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: '');
|
|
late final GeneratedColumn<String> title = GeneratedColumn<String>(
|
|
'title', aliasedName, true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: '');
|
|
late final GeneratedColumn<bool> isProbablyReaderable = GeneratedColumn<bool>(
|
|
'is_probably_readerable', aliasedName, true,
|
|
type: DriftSqlType.bool,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: '');
|
|
late final GeneratedColumn<String> extractedContentMarkdown =
|
|
GeneratedColumn<String>('extracted_content_markdown', aliasedName, true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: '');
|
|
late final GeneratedColumn<String> extractedContentPlain =
|
|
GeneratedColumn<String>('extracted_content_plain', aliasedName, true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: '');
|
|
late final GeneratedColumn<String> fullContentMarkdown =
|
|
GeneratedColumn<String>('full_content_markdown', aliasedName, true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: '');
|
|
late final GeneratedColumn<String> fullContentPlain = GeneratedColumn<String>(
|
|
'full_content_plain', aliasedName, true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: '');
|
|
late final GeneratedColumn<DateTime> timestamp = GeneratedColumn<DateTime>(
|
|
'timestamp', aliasedName, false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: 'NOT NULL');
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
containerId,
|
|
orderKey,
|
|
url,
|
|
title,
|
|
isProbablyReaderable,
|
|
extractedContentMarkdown,
|
|
extractedContentPlain,
|
|
fullContentMarkdown,
|
|
fullContentPlain,
|
|
timestamp
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'tab';
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
TabData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return TabData(
|
|
id: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}id'])!,
|
|
containerId: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}container_id']),
|
|
orderKey: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}order_key'])!,
|
|
url: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}url']),
|
|
title: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}title']),
|
|
isProbablyReaderable: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.bool, data['${effectivePrefix}is_probably_readerable']),
|
|
extractedContentMarkdown: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}extracted_content_markdown']),
|
|
extractedContentPlain: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}extracted_content_plain']),
|
|
fullContentMarkdown: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string, data['${effectivePrefix}full_content_markdown']),
|
|
fullContentPlain: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string, data['${effectivePrefix}full_content_plain']),
|
|
timestamp: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.dateTime, data['${effectivePrefix}timestamp'])!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Tab createAlias(String alias) {
|
|
return Tab(attachedDatabase, alias);
|
|
}
|
|
|
|
@override
|
|
bool get dontWriteConstraints => true;
|
|
}
|
|
|
|
class TabData extends DataClass implements Insertable<TabData> {
|
|
final String id;
|
|
final String? containerId;
|
|
final String orderKey;
|
|
final String? url;
|
|
final String? title;
|
|
final bool? isProbablyReaderable;
|
|
final String? extractedContentMarkdown;
|
|
final String? extractedContentPlain;
|
|
final String? fullContentMarkdown;
|
|
final String? fullContentPlain;
|
|
final DateTime timestamp;
|
|
const TabData(
|
|
{required this.id,
|
|
this.containerId,
|
|
required this.orderKey,
|
|
this.url,
|
|
this.title,
|
|
this.isProbablyReaderable,
|
|
this.extractedContentMarkdown,
|
|
this.extractedContentPlain,
|
|
this.fullContentMarkdown,
|
|
this.fullContentPlain,
|
|
required this.timestamp});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<String>(id);
|
|
if (!nullToAbsent || containerId != null) {
|
|
map['container_id'] = Variable<String>(containerId);
|
|
}
|
|
map['order_key'] = Variable<String>(orderKey);
|
|
if (!nullToAbsent || url != null) {
|
|
map['url'] = Variable<String>(url);
|
|
}
|
|
if (!nullToAbsent || title != null) {
|
|
map['title'] = Variable<String>(title);
|
|
}
|
|
if (!nullToAbsent || isProbablyReaderable != null) {
|
|
map['is_probably_readerable'] = Variable<bool>(isProbablyReaderable);
|
|
}
|
|
if (!nullToAbsent || extractedContentMarkdown != null) {
|
|
map['extracted_content_markdown'] =
|
|
Variable<String>(extractedContentMarkdown);
|
|
}
|
|
if (!nullToAbsent || extractedContentPlain != null) {
|
|
map['extracted_content_plain'] = Variable<String>(extractedContentPlain);
|
|
}
|
|
if (!nullToAbsent || fullContentMarkdown != null) {
|
|
map['full_content_markdown'] = Variable<String>(fullContentMarkdown);
|
|
}
|
|
if (!nullToAbsent || fullContentPlain != null) {
|
|
map['full_content_plain'] = Variable<String>(fullContentPlain);
|
|
}
|
|
map['timestamp'] = Variable<DateTime>(timestamp);
|
|
return map;
|
|
}
|
|
|
|
factory TabData.fromJson(Map<String, dynamic> json,
|
|
{ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return TabData(
|
|
id: serializer.fromJson<String>(json['id']),
|
|
containerId: serializer.fromJson<String?>(json['container_id']),
|
|
orderKey: serializer.fromJson<String>(json['order_key']),
|
|
url: serializer.fromJson<String?>(json['url']),
|
|
title: serializer.fromJson<String?>(json['title']),
|
|
isProbablyReaderable:
|
|
serializer.fromJson<bool?>(json['is_probably_readerable']),
|
|
extractedContentMarkdown:
|
|
serializer.fromJson<String?>(json['extracted_content_markdown']),
|
|
extractedContentPlain:
|
|
serializer.fromJson<String?>(json['extracted_content_plain']),
|
|
fullContentMarkdown:
|
|
serializer.fromJson<String?>(json['full_content_markdown']),
|
|
fullContentPlain:
|
|
serializer.fromJson<String?>(json['full_content_plain']),
|
|
timestamp: serializer.fromJson<DateTime>(json['timestamp']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<String>(id),
|
|
'container_id': serializer.toJson<String?>(containerId),
|
|
'order_key': serializer.toJson<String>(orderKey),
|
|
'url': serializer.toJson<String?>(url),
|
|
'title': serializer.toJson<String?>(title),
|
|
'is_probably_readerable': serializer.toJson<bool?>(isProbablyReaderable),
|
|
'extracted_content_markdown':
|
|
serializer.toJson<String?>(extractedContentMarkdown),
|
|
'extracted_content_plain':
|
|
serializer.toJson<String?>(extractedContentPlain),
|
|
'full_content_markdown': serializer.toJson<String?>(fullContentMarkdown),
|
|
'full_content_plain': serializer.toJson<String?>(fullContentPlain),
|
|
'timestamp': serializer.toJson<DateTime>(timestamp),
|
|
};
|
|
}
|
|
|
|
TabData copyWith(
|
|
{String? id,
|
|
Value<String?> containerId = const Value.absent(),
|
|
String? orderKey,
|
|
Value<String?> url = const Value.absent(),
|
|
Value<String?> title = const Value.absent(),
|
|
Value<bool?> isProbablyReaderable = const Value.absent(),
|
|
Value<String?> extractedContentMarkdown = const Value.absent(),
|
|
Value<String?> extractedContentPlain = const Value.absent(),
|
|
Value<String?> fullContentMarkdown = const Value.absent(),
|
|
Value<String?> fullContentPlain = const Value.absent(),
|
|
DateTime? timestamp}) =>
|
|
TabData(
|
|
id: id ?? this.id,
|
|
containerId: containerId.present ? containerId.value : this.containerId,
|
|
orderKey: orderKey ?? this.orderKey,
|
|
url: url.present ? url.value : this.url,
|
|
title: title.present ? title.value : this.title,
|
|
isProbablyReaderable: isProbablyReaderable.present
|
|
? isProbablyReaderable.value
|
|
: this.isProbablyReaderable,
|
|
extractedContentMarkdown: extractedContentMarkdown.present
|
|
? extractedContentMarkdown.value
|
|
: this.extractedContentMarkdown,
|
|
extractedContentPlain: extractedContentPlain.present
|
|
? extractedContentPlain.value
|
|
: this.extractedContentPlain,
|
|
fullContentMarkdown: fullContentMarkdown.present
|
|
? fullContentMarkdown.value
|
|
: this.fullContentMarkdown,
|
|
fullContentPlain: fullContentPlain.present
|
|
? fullContentPlain.value
|
|
: this.fullContentPlain,
|
|
timestamp: timestamp ?? this.timestamp,
|
|
);
|
|
TabData copyWithCompanion(TabCompanion data) {
|
|
return TabData(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
containerId:
|
|
data.containerId.present ? data.containerId.value : this.containerId,
|
|
orderKey: data.orderKey.present ? data.orderKey.value : this.orderKey,
|
|
url: data.url.present ? data.url.value : this.url,
|
|
title: data.title.present ? data.title.value : this.title,
|
|
isProbablyReaderable: data.isProbablyReaderable.present
|
|
? data.isProbablyReaderable.value
|
|
: this.isProbablyReaderable,
|
|
extractedContentMarkdown: data.extractedContentMarkdown.present
|
|
? data.extractedContentMarkdown.value
|
|
: this.extractedContentMarkdown,
|
|
extractedContentPlain: data.extractedContentPlain.present
|
|
? data.extractedContentPlain.value
|
|
: this.extractedContentPlain,
|
|
fullContentMarkdown: data.fullContentMarkdown.present
|
|
? data.fullContentMarkdown.value
|
|
: this.fullContentMarkdown,
|
|
fullContentPlain: data.fullContentPlain.present
|
|
? data.fullContentPlain.value
|
|
: this.fullContentPlain,
|
|
timestamp: data.timestamp.present ? data.timestamp.value : this.timestamp,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TabData(')
|
|
..write('id: $id, ')
|
|
..write('containerId: $containerId, ')
|
|
..write('orderKey: $orderKey, ')
|
|
..write('url: $url, ')
|
|
..write('title: $title, ')
|
|
..write('isProbablyReaderable: $isProbablyReaderable, ')
|
|
..write('extractedContentMarkdown: $extractedContentMarkdown, ')
|
|
..write('extractedContentPlain: $extractedContentPlain, ')
|
|
..write('fullContentMarkdown: $fullContentMarkdown, ')
|
|
..write('fullContentPlain: $fullContentPlain, ')
|
|
..write('timestamp: $timestamp')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(
|
|
id,
|
|
containerId,
|
|
orderKey,
|
|
url,
|
|
title,
|
|
isProbablyReaderable,
|
|
extractedContentMarkdown,
|
|
extractedContentPlain,
|
|
fullContentMarkdown,
|
|
fullContentPlain,
|
|
timestamp);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is TabData &&
|
|
other.id == this.id &&
|
|
other.containerId == this.containerId &&
|
|
other.orderKey == this.orderKey &&
|
|
other.url == this.url &&
|
|
other.title == this.title &&
|
|
other.isProbablyReaderable == this.isProbablyReaderable &&
|
|
other.extractedContentMarkdown == this.extractedContentMarkdown &&
|
|
other.extractedContentPlain == this.extractedContentPlain &&
|
|
other.fullContentMarkdown == this.fullContentMarkdown &&
|
|
other.fullContentPlain == this.fullContentPlain &&
|
|
other.timestamp == this.timestamp);
|
|
}
|
|
|
|
class TabCompanion extends UpdateCompanion<TabData> {
|
|
final Value<String> id;
|
|
final Value<String?> containerId;
|
|
final Value<String> orderKey;
|
|
final Value<String?> url;
|
|
final Value<String?> title;
|
|
final Value<bool?> isProbablyReaderable;
|
|
final Value<String?> extractedContentMarkdown;
|
|
final Value<String?> extractedContentPlain;
|
|
final Value<String?> fullContentMarkdown;
|
|
final Value<String?> fullContentPlain;
|
|
final Value<DateTime> timestamp;
|
|
final Value<int> rowid;
|
|
const TabCompanion({
|
|
this.id = const Value.absent(),
|
|
this.containerId = const Value.absent(),
|
|
this.orderKey = const Value.absent(),
|
|
this.url = const Value.absent(),
|
|
this.title = const Value.absent(),
|
|
this.isProbablyReaderable = const Value.absent(),
|
|
this.extractedContentMarkdown = const Value.absent(),
|
|
this.extractedContentPlain = const Value.absent(),
|
|
this.fullContentMarkdown = const Value.absent(),
|
|
this.fullContentPlain = const Value.absent(),
|
|
this.timestamp = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
TabCompanion.insert({
|
|
required String id,
|
|
this.containerId = const Value.absent(),
|
|
required String orderKey,
|
|
this.url = const Value.absent(),
|
|
this.title = const Value.absent(),
|
|
this.isProbablyReaderable = const Value.absent(),
|
|
this.extractedContentMarkdown = const Value.absent(),
|
|
this.extractedContentPlain = const Value.absent(),
|
|
this.fullContentMarkdown = const Value.absent(),
|
|
this.fullContentPlain = const Value.absent(),
|
|
required DateTime timestamp,
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id),
|
|
orderKey = Value(orderKey),
|
|
timestamp = Value(timestamp);
|
|
static Insertable<TabData> custom({
|
|
Expression<String>? id,
|
|
Expression<String>? containerId,
|
|
Expression<String>? orderKey,
|
|
Expression<String>? url,
|
|
Expression<String>? title,
|
|
Expression<bool>? isProbablyReaderable,
|
|
Expression<String>? extractedContentMarkdown,
|
|
Expression<String>? extractedContentPlain,
|
|
Expression<String>? fullContentMarkdown,
|
|
Expression<String>? fullContentPlain,
|
|
Expression<DateTime>? timestamp,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (containerId != null) 'container_id': containerId,
|
|
if (orderKey != null) 'order_key': orderKey,
|
|
if (url != null) 'url': url,
|
|
if (title != null) 'title': title,
|
|
if (isProbablyReaderable != null)
|
|
'is_probably_readerable': isProbablyReaderable,
|
|
if (extractedContentMarkdown != null)
|
|
'extracted_content_markdown': extractedContentMarkdown,
|
|
if (extractedContentPlain != null)
|
|
'extracted_content_plain': extractedContentPlain,
|
|
if (fullContentMarkdown != null)
|
|
'full_content_markdown': fullContentMarkdown,
|
|
if (fullContentPlain != null) 'full_content_plain': fullContentPlain,
|
|
if (timestamp != null) 'timestamp': timestamp,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
TabCompanion copyWith(
|
|
{Value<String>? id,
|
|
Value<String?>? containerId,
|
|
Value<String>? orderKey,
|
|
Value<String?>? url,
|
|
Value<String?>? title,
|
|
Value<bool?>? isProbablyReaderable,
|
|
Value<String?>? extractedContentMarkdown,
|
|
Value<String?>? extractedContentPlain,
|
|
Value<String?>? fullContentMarkdown,
|
|
Value<String?>? fullContentPlain,
|
|
Value<DateTime>? timestamp,
|
|
Value<int>? rowid}) {
|
|
return TabCompanion(
|
|
id: id ?? this.id,
|
|
containerId: containerId ?? this.containerId,
|
|
orderKey: orderKey ?? this.orderKey,
|
|
url: url ?? this.url,
|
|
title: title ?? this.title,
|
|
isProbablyReaderable: isProbablyReaderable ?? this.isProbablyReaderable,
|
|
extractedContentMarkdown:
|
|
extractedContentMarkdown ?? this.extractedContentMarkdown,
|
|
extractedContentPlain:
|
|
extractedContentPlain ?? this.extractedContentPlain,
|
|
fullContentMarkdown: fullContentMarkdown ?? this.fullContentMarkdown,
|
|
fullContentPlain: fullContentPlain ?? this.fullContentPlain,
|
|
timestamp: timestamp ?? this.timestamp,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<String>(id.value);
|
|
}
|
|
if (containerId.present) {
|
|
map['container_id'] = Variable<String>(containerId.value);
|
|
}
|
|
if (orderKey.present) {
|
|
map['order_key'] = Variable<String>(orderKey.value);
|
|
}
|
|
if (url.present) {
|
|
map['url'] = Variable<String>(url.value);
|
|
}
|
|
if (title.present) {
|
|
map['title'] = Variable<String>(title.value);
|
|
}
|
|
if (isProbablyReaderable.present) {
|
|
map['is_probably_readerable'] =
|
|
Variable<bool>(isProbablyReaderable.value);
|
|
}
|
|
if (extractedContentMarkdown.present) {
|
|
map['extracted_content_markdown'] =
|
|
Variable<String>(extractedContentMarkdown.value);
|
|
}
|
|
if (extractedContentPlain.present) {
|
|
map['extracted_content_plain'] =
|
|
Variable<String>(extractedContentPlain.value);
|
|
}
|
|
if (fullContentMarkdown.present) {
|
|
map['full_content_markdown'] =
|
|
Variable<String>(fullContentMarkdown.value);
|
|
}
|
|
if (fullContentPlain.present) {
|
|
map['full_content_plain'] = Variable<String>(fullContentPlain.value);
|
|
}
|
|
if (timestamp.present) {
|
|
map['timestamp'] = Variable<DateTime>(timestamp.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TabCompanion(')
|
|
..write('id: $id, ')
|
|
..write('containerId: $containerId, ')
|
|
..write('orderKey: $orderKey, ')
|
|
..write('url: $url, ')
|
|
..write('title: $title, ')
|
|
..write('isProbablyReaderable: $isProbablyReaderable, ')
|
|
..write('extractedContentMarkdown: $extractedContentMarkdown, ')
|
|
..write('extractedContentPlain: $extractedContentPlain, ')
|
|
..write('fullContentMarkdown: $fullContentMarkdown, ')
|
|
..write('fullContentPlain: $fullContentPlain, ')
|
|
..write('timestamp: $timestamp, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class Document extends Table with TableInfo<Document, DocumentData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
Document(this.attachedDatabase, [this._alias]);
|
|
late final GeneratedColumn<String> documentId = GeneratedColumn<String>(
|
|
'document_id', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: 'NOT NULL PRIMARY KEY');
|
|
late final GeneratedColumn<String> mainDocumentId = GeneratedColumn<String>(
|
|
'main_document_id', aliasedName, true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: '');
|
|
late final GeneratedColumn<String> contextId = GeneratedColumn<String>(
|
|
'context_id', aliasedName, true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: '');
|
|
late final GeneratedColumn<String> content = GeneratedColumn<String>(
|
|
'content', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: 'NOT NULL');
|
|
late final GeneratedColumn<String> contentHash = GeneratedColumn<String>(
|
|
'content_hash', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: 'NOT NULL');
|
|
late final GeneratedColumn<String> metadata = GeneratedColumn<String>(
|
|
'metadata', aliasedName, true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: '');
|
|
@override
|
|
List<GeneratedColumn> get $columns =>
|
|
[documentId, mainDocumentId, contextId, content, contentHash, metadata];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'document';
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {documentId};
|
|
@override
|
|
DocumentData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return DocumentData(
|
|
documentId: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}document_id'])!,
|
|
mainDocumentId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string, data['${effectivePrefix}main_document_id']),
|
|
contextId: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}context_id']),
|
|
content: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}content'])!,
|
|
contentHash: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}content_hash'])!,
|
|
metadata: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}metadata']),
|
|
);
|
|
}
|
|
|
|
@override
|
|
Document createAlias(String alias) {
|
|
return Document(attachedDatabase, alias);
|
|
}
|
|
|
|
@override
|
|
bool get dontWriteConstraints => true;
|
|
}
|
|
|
|
class DocumentData extends DataClass implements Insertable<DocumentData> {
|
|
final String documentId;
|
|
final String? mainDocumentId;
|
|
final String? contextId;
|
|
final String content;
|
|
final String contentHash;
|
|
final String? metadata;
|
|
const DocumentData(
|
|
{required this.documentId,
|
|
this.mainDocumentId,
|
|
this.contextId,
|
|
required this.content,
|
|
required this.contentHash,
|
|
this.metadata});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['document_id'] = Variable<String>(documentId);
|
|
if (!nullToAbsent || mainDocumentId != null) {
|
|
map['main_document_id'] = Variable<String>(mainDocumentId);
|
|
}
|
|
if (!nullToAbsent || contextId != null) {
|
|
map['context_id'] = Variable<String>(contextId);
|
|
}
|
|
map['content'] = Variable<String>(content);
|
|
map['content_hash'] = Variable<String>(contentHash);
|
|
if (!nullToAbsent || metadata != null) {
|
|
map['metadata'] = Variable<String>(metadata);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
factory DocumentData.fromJson(Map<String, dynamic> json,
|
|
{ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return DocumentData(
|
|
documentId: serializer.fromJson<String>(json['document_id']),
|
|
mainDocumentId: serializer.fromJson<String?>(json['main_document_id']),
|
|
contextId: serializer.fromJson<String?>(json['context_id']),
|
|
content: serializer.fromJson<String>(json['content']),
|
|
contentHash: serializer.fromJson<String>(json['content_hash']),
|
|
metadata: serializer.fromJson<String?>(json['metadata']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'document_id': serializer.toJson<String>(documentId),
|
|
'main_document_id': serializer.toJson<String?>(mainDocumentId),
|
|
'context_id': serializer.toJson<String?>(contextId),
|
|
'content': serializer.toJson<String>(content),
|
|
'content_hash': serializer.toJson<String>(contentHash),
|
|
'metadata': serializer.toJson<String?>(metadata),
|
|
};
|
|
}
|
|
|
|
DocumentData copyWith(
|
|
{String? documentId,
|
|
Value<String?> mainDocumentId = const Value.absent(),
|
|
Value<String?> contextId = const Value.absent(),
|
|
String? content,
|
|
String? contentHash,
|
|
Value<String?> metadata = const Value.absent()}) =>
|
|
DocumentData(
|
|
documentId: documentId ?? this.documentId,
|
|
mainDocumentId:
|
|
mainDocumentId.present ? mainDocumentId.value : this.mainDocumentId,
|
|
contextId: contextId.present ? contextId.value : this.contextId,
|
|
content: content ?? this.content,
|
|
contentHash: contentHash ?? this.contentHash,
|
|
metadata: metadata.present ? metadata.value : this.metadata,
|
|
);
|
|
DocumentData copyWithCompanion(DocumentCompanion data) {
|
|
return DocumentData(
|
|
documentId:
|
|
data.documentId.present ? data.documentId.value : this.documentId,
|
|
mainDocumentId: data.mainDocumentId.present
|
|
? data.mainDocumentId.value
|
|
: this.mainDocumentId,
|
|
contextId: data.contextId.present ? data.contextId.value : this.contextId,
|
|
content: data.content.present ? data.content.value : this.content,
|
|
contentHash:
|
|
data.contentHash.present ? data.contentHash.value : this.contentHash,
|
|
metadata: data.metadata.present ? data.metadata.value : this.metadata,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('DocumentData(')
|
|
..write('documentId: $documentId, ')
|
|
..write('mainDocumentId: $mainDocumentId, ')
|
|
..write('contextId: $contextId, ')
|
|
..write('content: $content, ')
|
|
..write('contentHash: $contentHash, ')
|
|
..write('metadata: $metadata')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(
|
|
documentId, mainDocumentId, contextId, content, contentHash, metadata);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is DocumentData &&
|
|
other.documentId == this.documentId &&
|
|
other.mainDocumentId == this.mainDocumentId &&
|
|
other.contextId == this.contextId &&
|
|
other.content == this.content &&
|
|
other.contentHash == this.contentHash &&
|
|
other.metadata == this.metadata);
|
|
}
|
|
|
|
class DocumentCompanion extends UpdateCompanion<DocumentData> {
|
|
final Value<String> documentId;
|
|
final Value<String?> mainDocumentId;
|
|
final Value<String?> contextId;
|
|
final Value<String> content;
|
|
final Value<String> contentHash;
|
|
final Value<String?> metadata;
|
|
final Value<int> rowid;
|
|
const DocumentCompanion({
|
|
this.documentId = const Value.absent(),
|
|
this.mainDocumentId = const Value.absent(),
|
|
this.contextId = const Value.absent(),
|
|
this.content = const Value.absent(),
|
|
this.contentHash = const Value.absent(),
|
|
this.metadata = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
DocumentCompanion.insert({
|
|
required String documentId,
|
|
this.mainDocumentId = const Value.absent(),
|
|
this.contextId = const Value.absent(),
|
|
required String content,
|
|
required String contentHash,
|
|
this.metadata = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
}) : documentId = Value(documentId),
|
|
content = Value(content),
|
|
contentHash = Value(contentHash);
|
|
static Insertable<DocumentData> custom({
|
|
Expression<String>? documentId,
|
|
Expression<String>? mainDocumentId,
|
|
Expression<String>? contextId,
|
|
Expression<String>? content,
|
|
Expression<String>? contentHash,
|
|
Expression<String>? metadata,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (documentId != null) 'document_id': documentId,
|
|
if (mainDocumentId != null) 'main_document_id': mainDocumentId,
|
|
if (contextId != null) 'context_id': contextId,
|
|
if (content != null) 'content': content,
|
|
if (contentHash != null) 'content_hash': contentHash,
|
|
if (metadata != null) 'metadata': metadata,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
DocumentCompanion copyWith(
|
|
{Value<String>? documentId,
|
|
Value<String?>? mainDocumentId,
|
|
Value<String?>? contextId,
|
|
Value<String>? content,
|
|
Value<String>? contentHash,
|
|
Value<String?>? metadata,
|
|
Value<int>? rowid}) {
|
|
return DocumentCompanion(
|
|
documentId: documentId ?? this.documentId,
|
|
mainDocumentId: mainDocumentId ?? this.mainDocumentId,
|
|
contextId: contextId ?? this.contextId,
|
|
content: content ?? this.content,
|
|
contentHash: contentHash ?? this.contentHash,
|
|
metadata: metadata ?? this.metadata,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (documentId.present) {
|
|
map['document_id'] = Variable<String>(documentId.value);
|
|
}
|
|
if (mainDocumentId.present) {
|
|
map['main_document_id'] = Variable<String>(mainDocumentId.value);
|
|
}
|
|
if (contextId.present) {
|
|
map['context_id'] = Variable<String>(contextId.value);
|
|
}
|
|
if (content.present) {
|
|
map['content'] = Variable<String>(content.value);
|
|
}
|
|
if (contentHash.present) {
|
|
map['content_hash'] = Variable<String>(contentHash.value);
|
|
}
|
|
if (metadata.present) {
|
|
map['metadata'] = Variable<String>(metadata.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('DocumentCompanion(')
|
|
..write('documentId: $documentId, ')
|
|
..write('mainDocumentId: $mainDocumentId, ')
|
|
..write('contextId: $contextId, ')
|
|
..write('content: $content, ')
|
|
..write('contentHash: $contentHash, ')
|
|
..write('metadata: $metadata, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class TabFts extends Table
|
|
with TableInfo<TabFts, TabFt>, VirtualTableInfo<TabFts, TabFt> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
TabFts(this.attachedDatabase, [this._alias]);
|
|
late final GeneratedColumn<String> title = GeneratedColumn<String>(
|
|
'title', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: '');
|
|
late final GeneratedColumn<String> url = GeneratedColumn<String>(
|
|
'url', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: '');
|
|
late final GeneratedColumn<String> extractedContentPlain =
|
|
GeneratedColumn<String>('extracted_content_plain', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: '');
|
|
late final GeneratedColumn<String> fullContentPlain = GeneratedColumn<String>(
|
|
'full_content_plain', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: '');
|
|
@override
|
|
List<GeneratedColumn> get $columns =>
|
|
[title, url, extractedContentPlain, fullContentPlain];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'tab_fts';
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => const {};
|
|
@override
|
|
TabFt map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return TabFt(
|
|
title: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}title'])!,
|
|
url: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}url'])!,
|
|
extractedContentPlain: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}extracted_content_plain'])!,
|
|
fullContentPlain: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string, data['${effectivePrefix}full_content_plain'])!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
TabFts createAlias(String alias) {
|
|
return TabFts(attachedDatabase, alias);
|
|
}
|
|
|
|
@override
|
|
bool get dontWriteConstraints => true;
|
|
@override
|
|
String get moduleAndArgs =>
|
|
'fts5(title, url, extracted_content_plain, full_content_plain, content=tab, tokenize="trigram")';
|
|
}
|
|
|
|
class TabFt extends DataClass implements Insertable<TabFt> {
|
|
final String title;
|
|
final String url;
|
|
final String extractedContentPlain;
|
|
final String fullContentPlain;
|
|
const TabFt(
|
|
{required this.title,
|
|
required this.url,
|
|
required this.extractedContentPlain,
|
|
required this.fullContentPlain});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['title'] = Variable<String>(title);
|
|
map['url'] = Variable<String>(url);
|
|
map['extracted_content_plain'] = Variable<String>(extractedContentPlain);
|
|
map['full_content_plain'] = Variable<String>(fullContentPlain);
|
|
return map;
|
|
}
|
|
|
|
factory TabFt.fromJson(Map<String, dynamic> json,
|
|
{ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return TabFt(
|
|
title: serializer.fromJson<String>(json['title']),
|
|
url: serializer.fromJson<String>(json['url']),
|
|
extractedContentPlain:
|
|
serializer.fromJson<String>(json['extracted_content_plain']),
|
|
fullContentPlain: serializer.fromJson<String>(json['full_content_plain']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'title': serializer.toJson<String>(title),
|
|
'url': serializer.toJson<String>(url),
|
|
'extracted_content_plain':
|
|
serializer.toJson<String>(extractedContentPlain),
|
|
'full_content_plain': serializer.toJson<String>(fullContentPlain),
|
|
};
|
|
}
|
|
|
|
TabFt copyWith(
|
|
{String? title,
|
|
String? url,
|
|
String? extractedContentPlain,
|
|
String? fullContentPlain}) =>
|
|
TabFt(
|
|
title: title ?? this.title,
|
|
url: url ?? this.url,
|
|
extractedContentPlain:
|
|
extractedContentPlain ?? this.extractedContentPlain,
|
|
fullContentPlain: fullContentPlain ?? this.fullContentPlain,
|
|
);
|
|
TabFt copyWithCompanion(TabFtsCompanion data) {
|
|
return TabFt(
|
|
title: data.title.present ? data.title.value : this.title,
|
|
url: data.url.present ? data.url.value : this.url,
|
|
extractedContentPlain: data.extractedContentPlain.present
|
|
? data.extractedContentPlain.value
|
|
: this.extractedContentPlain,
|
|
fullContentPlain: data.fullContentPlain.present
|
|
? data.fullContentPlain.value
|
|
: this.fullContentPlain,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TabFt(')
|
|
..write('title: $title, ')
|
|
..write('url: $url, ')
|
|
..write('extractedContentPlain: $extractedContentPlain, ')
|
|
..write('fullContentPlain: $fullContentPlain')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode =>
|
|
Object.hash(title, url, extractedContentPlain, fullContentPlain);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is TabFt &&
|
|
other.title == this.title &&
|
|
other.url == this.url &&
|
|
other.extractedContentPlain == this.extractedContentPlain &&
|
|
other.fullContentPlain == this.fullContentPlain);
|
|
}
|
|
|
|
class TabFtsCompanion extends UpdateCompanion<TabFt> {
|
|
final Value<String> title;
|
|
final Value<String> url;
|
|
final Value<String> extractedContentPlain;
|
|
final Value<String> fullContentPlain;
|
|
final Value<int> rowid;
|
|
const TabFtsCompanion({
|
|
this.title = const Value.absent(),
|
|
this.url = const Value.absent(),
|
|
this.extractedContentPlain = const Value.absent(),
|
|
this.fullContentPlain = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
TabFtsCompanion.insert({
|
|
required String title,
|
|
required String url,
|
|
required String extractedContentPlain,
|
|
required String fullContentPlain,
|
|
this.rowid = const Value.absent(),
|
|
}) : title = Value(title),
|
|
url = Value(url),
|
|
extractedContentPlain = Value(extractedContentPlain),
|
|
fullContentPlain = Value(fullContentPlain);
|
|
static Insertable<TabFt> custom({
|
|
Expression<String>? title,
|
|
Expression<String>? url,
|
|
Expression<String>? extractedContentPlain,
|
|
Expression<String>? fullContentPlain,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (title != null) 'title': title,
|
|
if (url != null) 'url': url,
|
|
if (extractedContentPlain != null)
|
|
'extracted_content_plain': extractedContentPlain,
|
|
if (fullContentPlain != null) 'full_content_plain': fullContentPlain,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
TabFtsCompanion copyWith(
|
|
{Value<String>? title,
|
|
Value<String>? url,
|
|
Value<String>? extractedContentPlain,
|
|
Value<String>? fullContentPlain,
|
|
Value<int>? rowid}) {
|
|
return TabFtsCompanion(
|
|
title: title ?? this.title,
|
|
url: url ?? this.url,
|
|
extractedContentPlain:
|
|
extractedContentPlain ?? this.extractedContentPlain,
|
|
fullContentPlain: fullContentPlain ?? this.fullContentPlain,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (title.present) {
|
|
map['title'] = Variable<String>(title.value);
|
|
}
|
|
if (url.present) {
|
|
map['url'] = Variable<String>(url.value);
|
|
}
|
|
if (extractedContentPlain.present) {
|
|
map['extracted_content_plain'] =
|
|
Variable<String>(extractedContentPlain.value);
|
|
}
|
|
if (fullContentPlain.present) {
|
|
map['full_content_plain'] = Variable<String>(fullContentPlain.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TabFtsCompanion(')
|
|
..write('title: $title, ')
|
|
..write('url: $url, ')
|
|
..write('extractedContentPlain: $extractedContentPlain, ')
|
|
..write('fullContentPlain: $fullContentPlain, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class DocumentVec extends Table with TableInfo<DocumentVec, DocumentVecData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
DocumentVec(this.attachedDatabase, [this._alias]);
|
|
late final GeneratedColumn<String> id = GeneratedColumn<String>(
|
|
'id', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: 'NOT NULL PRIMARY KEY');
|
|
late final GeneratedColumn<String> mainDocumentId = GeneratedColumn<String>(
|
|
'main_document_id', aliasedName, true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: '');
|
|
late final GeneratedColumn<String> contextId = GeneratedColumn<String>(
|
|
'context_id', aliasedName, true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: '');
|
|
late final GeneratedColumn<Uint8List> embedding = GeneratedColumn<Uint8List>(
|
|
'embedding', aliasedName, false,
|
|
type: DriftSqlType.blob,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: 'NOT NULL');
|
|
late final GeneratedColumn<String> contentHash = GeneratedColumn<String>(
|
|
'content_hash', aliasedName, false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
$customConstraints: 'NOT NULL');
|
|
late final GeneratedColumn<double> distance = GeneratedColumn<double>(
|
|
'distance', aliasedName, true,
|
|
type: DriftSqlType.double,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: '');
|
|
late final GeneratedColumn<int> k = GeneratedColumn<int>(
|
|
'k', aliasedName, true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
$customConstraints: '');
|
|
@override
|
|
List<GeneratedColumn> get $columns =>
|
|
[id, mainDocumentId, contextId, embedding, contentHash, distance, k];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'document_vec';
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
DocumentVecData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return DocumentVecData(
|
|
id: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}id'])!,
|
|
mainDocumentId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string, data['${effectivePrefix}main_document_id']),
|
|
contextId: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}context_id']),
|
|
embedding: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.blob, data['${effectivePrefix}embedding'])!,
|
|
contentHash: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}content_hash'])!,
|
|
distance: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.double, data['${effectivePrefix}distance']),
|
|
k: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}k']),
|
|
);
|
|
}
|
|
|
|
@override
|
|
DocumentVec createAlias(String alias) {
|
|
return DocumentVec(attachedDatabase, alias);
|
|
}
|
|
|
|
@override
|
|
bool get dontWriteConstraints => true;
|
|
}
|
|
|
|
class DocumentVecData extends DataClass implements Insertable<DocumentVecData> {
|
|
/// dummy definition of virtual table
|
|
/// keep in sync with defined table definition
|
|
final String id;
|
|
final String? mainDocumentId;
|
|
final String? contextId;
|
|
final Uint8List embedding;
|
|
final String contentHash;
|
|
final double? distance;
|
|
final int? k;
|
|
const DocumentVecData(
|
|
{required this.id,
|
|
this.mainDocumentId,
|
|
this.contextId,
|
|
required this.embedding,
|
|
required this.contentHash,
|
|
this.distance,
|
|
this.k});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<String>(id);
|
|
if (!nullToAbsent || mainDocumentId != null) {
|
|
map['main_document_id'] = Variable<String>(mainDocumentId);
|
|
}
|
|
if (!nullToAbsent || contextId != null) {
|
|
map['context_id'] = Variable<String>(contextId);
|
|
}
|
|
map['embedding'] = Variable<Uint8List>(embedding);
|
|
map['content_hash'] = Variable<String>(contentHash);
|
|
if (!nullToAbsent || distance != null) {
|
|
map['distance'] = Variable<double>(distance);
|
|
}
|
|
if (!nullToAbsent || k != null) {
|
|
map['k'] = Variable<int>(k);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
factory DocumentVecData.fromJson(Map<String, dynamic> json,
|
|
{ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return DocumentVecData(
|
|
id: serializer.fromJson<String>(json['id']),
|
|
mainDocumentId: serializer.fromJson<String?>(json['main_document_id']),
|
|
contextId: serializer.fromJson<String?>(json['context_id']),
|
|
embedding: serializer.fromJson<Uint8List>(json['embedding']),
|
|
contentHash: serializer.fromJson<String>(json['content_hash']),
|
|
distance: serializer.fromJson<double?>(json['distance']),
|
|
k: serializer.fromJson<int?>(json['k']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<String>(id),
|
|
'main_document_id': serializer.toJson<String?>(mainDocumentId),
|
|
'context_id': serializer.toJson<String?>(contextId),
|
|
'embedding': serializer.toJson<Uint8List>(embedding),
|
|
'content_hash': serializer.toJson<String>(contentHash),
|
|
'distance': serializer.toJson<double?>(distance),
|
|
'k': serializer.toJson<int?>(k),
|
|
};
|
|
}
|
|
|
|
DocumentVecData copyWith(
|
|
{String? id,
|
|
Value<String?> mainDocumentId = const Value.absent(),
|
|
Value<String?> contextId = const Value.absent(),
|
|
Uint8List? embedding,
|
|
String? contentHash,
|
|
Value<double?> distance = const Value.absent(),
|
|
Value<int?> k = const Value.absent()}) =>
|
|
DocumentVecData(
|
|
id: id ?? this.id,
|
|
mainDocumentId:
|
|
mainDocumentId.present ? mainDocumentId.value : this.mainDocumentId,
|
|
contextId: contextId.present ? contextId.value : this.contextId,
|
|
embedding: embedding ?? this.embedding,
|
|
contentHash: contentHash ?? this.contentHash,
|
|
distance: distance.present ? distance.value : this.distance,
|
|
k: k.present ? k.value : this.k,
|
|
);
|
|
DocumentVecData copyWithCompanion(DocumentVecCompanion data) {
|
|
return DocumentVecData(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
mainDocumentId: data.mainDocumentId.present
|
|
? data.mainDocumentId.value
|
|
: this.mainDocumentId,
|
|
contextId: data.contextId.present ? data.contextId.value : this.contextId,
|
|
embedding: data.embedding.present ? data.embedding.value : this.embedding,
|
|
contentHash:
|
|
data.contentHash.present ? data.contentHash.value : this.contentHash,
|
|
distance: data.distance.present ? data.distance.value : this.distance,
|
|
k: data.k.present ? data.k.value : this.k,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('DocumentVecData(')
|
|
..write('id: $id, ')
|
|
..write('mainDocumentId: $mainDocumentId, ')
|
|
..write('contextId: $contextId, ')
|
|
..write('embedding: $embedding, ')
|
|
..write('contentHash: $contentHash, ')
|
|
..write('distance: $distance, ')
|
|
..write('k: $k')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, mainDocumentId, contextId,
|
|
$driftBlobEquality.hash(embedding), contentHash, distance, k);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is DocumentVecData &&
|
|
other.id == this.id &&
|
|
other.mainDocumentId == this.mainDocumentId &&
|
|
other.contextId == this.contextId &&
|
|
$driftBlobEquality.equals(other.embedding, this.embedding) &&
|
|
other.contentHash == this.contentHash &&
|
|
other.distance == this.distance &&
|
|
other.k == this.k);
|
|
}
|
|
|
|
class DocumentVecCompanion extends UpdateCompanion<DocumentVecData> {
|
|
final Value<String> id;
|
|
final Value<String?> mainDocumentId;
|
|
final Value<String?> contextId;
|
|
final Value<Uint8List> embedding;
|
|
final Value<String> contentHash;
|
|
final Value<double?> distance;
|
|
final Value<int?> k;
|
|
final Value<int> rowid;
|
|
const DocumentVecCompanion({
|
|
this.id = const Value.absent(),
|
|
this.mainDocumentId = const Value.absent(),
|
|
this.contextId = const Value.absent(),
|
|
this.embedding = const Value.absent(),
|
|
this.contentHash = const Value.absent(),
|
|
this.distance = const Value.absent(),
|
|
this.k = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
DocumentVecCompanion.insert({
|
|
required String id,
|
|
this.mainDocumentId = const Value.absent(),
|
|
this.contextId = const Value.absent(),
|
|
required Uint8List embedding,
|
|
required String contentHash,
|
|
this.distance = const Value.absent(),
|
|
this.k = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id),
|
|
embedding = Value(embedding),
|
|
contentHash = Value(contentHash);
|
|
static Insertable<DocumentVecData> custom({
|
|
Expression<String>? id,
|
|
Expression<String>? mainDocumentId,
|
|
Expression<String>? contextId,
|
|
Expression<Uint8List>? embedding,
|
|
Expression<String>? contentHash,
|
|
Expression<double>? distance,
|
|
Expression<int>? k,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (mainDocumentId != null) 'main_document_id': mainDocumentId,
|
|
if (contextId != null) 'context_id': contextId,
|
|
if (embedding != null) 'embedding': embedding,
|
|
if (contentHash != null) 'content_hash': contentHash,
|
|
if (distance != null) 'distance': distance,
|
|
if (k != null) 'k': k,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
DocumentVecCompanion copyWith(
|
|
{Value<String>? id,
|
|
Value<String?>? mainDocumentId,
|
|
Value<String?>? contextId,
|
|
Value<Uint8List>? embedding,
|
|
Value<String>? contentHash,
|
|
Value<double?>? distance,
|
|
Value<int?>? k,
|
|
Value<int>? rowid}) {
|
|
return DocumentVecCompanion(
|
|
id: id ?? this.id,
|
|
mainDocumentId: mainDocumentId ?? this.mainDocumentId,
|
|
contextId: contextId ?? this.contextId,
|
|
embedding: embedding ?? this.embedding,
|
|
contentHash: contentHash ?? this.contentHash,
|
|
distance: distance ?? this.distance,
|
|
k: k ?? this.k,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<String>(id.value);
|
|
}
|
|
if (mainDocumentId.present) {
|
|
map['main_document_id'] = Variable<String>(mainDocumentId.value);
|
|
}
|
|
if (contextId.present) {
|
|
map['context_id'] = Variable<String>(contextId.value);
|
|
}
|
|
if (embedding.present) {
|
|
map['embedding'] = Variable<Uint8List>(embedding.value);
|
|
}
|
|
if (contentHash.present) {
|
|
map['content_hash'] = Variable<String>(contentHash.value);
|
|
}
|
|
if (distance.present) {
|
|
map['distance'] = Variable<double>(distance.value);
|
|
}
|
|
if (k.present) {
|
|
map['k'] = Variable<int>(k.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('DocumentVecCompanion(')
|
|
..write('id: $id, ')
|
|
..write('mainDocumentId: $mainDocumentId, ')
|
|
..write('contextId: $contextId, ')
|
|
..write('embedding: $embedding, ')
|
|
..write('contentHash: $contentHash, ')
|
|
..write('distance: $distance, ')
|
|
..write('k: $k, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
abstract class _$TabDatabase extends GeneratedDatabase {
|
|
_$TabDatabase(QueryExecutor e) : super(e);
|
|
$TabDatabaseManager get managers => $TabDatabaseManager(this);
|
|
late final Container container = Container(this);
|
|
late final Tab tab = Tab(this);
|
|
late final Document document = Document(this);
|
|
late final Trigger tabDocumentDelete = Trigger(
|
|
'CREATE TRIGGER tab_document_delete AFTER DELETE ON tab BEGIN DELETE FROM document WHERE main_document_id = old.id;END',
|
|
'tab_document_delete');
|
|
late final TabFts tabFts = TabFts(this);
|
|
late final Trigger tabAfterInsert = Trigger(
|
|
'CREATE TRIGGER tab_after_insert AFTER INSERT ON tab BEGIN INSERT INTO tab_fts ("rowid", title, url, extracted_content_plain, full_content_plain) VALUES (new."rowid", new.title, new.url, new.extracted_content_plain, new.full_content_plain);END',
|
|
'tab_after_insert');
|
|
late final Trigger tabAfterDelete = Trigger(
|
|
'CREATE TRIGGER tab_after_delete AFTER DELETE ON tab BEGIN INSERT INTO tab_fts (tab_fts, "rowid", title, url, extracted_content_plain, full_content_plain) VALUES (\'delete\', old."rowid", old.title, old.url, old.extracted_content_plain, old.full_content_plain);END',
|
|
'tab_after_delete');
|
|
late final Trigger tabAfterUpdate = Trigger(
|
|
'CREATE TRIGGER tab_after_update AFTER UPDATE ON tab BEGIN INSERT INTO tab_fts (tab_fts, "rowid", title, url, extracted_content_plain, full_content_plain) VALUES (\'delete\', old."rowid", old.title, old.url, old.extracted_content_plain, old.full_content_plain);INSERT INTO tab_fts ("rowid", title, url, extracted_content_plain, full_content_plain) VALUES (new."rowid", new.title, new.url, new.extracted_content_plain, new.full_content_plain);END',
|
|
'tab_after_update');
|
|
late final Index documentMainDocumentId = Index('document_main_document_id',
|
|
'CREATE INDEX document_main_document_id ON document (main_document_id)');
|
|
late final Index documentContextId = Index('document_context_id',
|
|
'CREATE INDEX document_context_id ON document (context_id)');
|
|
late final DocumentVec documentVec = DocumentVec(this);
|
|
late final Trigger documentDelete = Trigger(
|
|
'CREATE TRIGGER document_delete AFTER DELETE ON document BEGIN DELETE FROM document_vec WHERE id = old.document_id;END',
|
|
'document_delete');
|
|
late final Trigger documentUpdateDelete = Trigger(
|
|
'CREATE TRIGGER document_update_delete AFTER UPDATE ON document BEGIN DELETE FROM document_vec WHERE id = new.document_id AND content_hash != new.content_hash;END',
|
|
'document_update_delete');
|
|
late final ContainerDao containerDao = ContainerDao(this as TabDatabase);
|
|
late final TabDao tabDao = TabDao(this as TabDatabase);
|
|
late final VectorDao vectorDao = VectorDao(this as TabDatabase);
|
|
Future<int> optimizeFtsIndex() {
|
|
return customInsert(
|
|
'INSERT INTO tab_fts (tab_fts) VALUES (\'optimize\')',
|
|
variables: [],
|
|
updates: {tabFts},
|
|
);
|
|
}
|
|
|
|
Selectable<ContainerDataWithCount> containersWithCount() {
|
|
return customSelect(
|
|
'SELECT container.*, tab_agg.tab_count FROM container LEFT JOIN (SELECT container_id, COUNT(*) AS tab_count, MAX(timestamp) AS last_updated FROM tab GROUP BY container_id) AS tab_agg ON container.id = tab_agg.container_id ORDER BY tab_agg.last_updated DESC NULLS LAST',
|
|
variables: [],
|
|
readsFrom: {
|
|
container,
|
|
tab,
|
|
}).map((QueryRow row) => ContainerDataWithCount(
|
|
id: row.read<String>('id'),
|
|
name: row.readNullable<String>('name'),
|
|
color: Container.$convertercolor.fromSql(row.read<int>('color')),
|
|
metadata: NullAwareTypeConverter.wrapFromSql(
|
|
Container.$convertermetadata,
|
|
row.readNullable<String>('metadata')),
|
|
tabCount: row.readNullable<int>('tab_count'),
|
|
));
|
|
}
|
|
|
|
Selectable<String> leadingOrderKey(
|
|
{required int bucket, String? containerId}) {
|
|
return customSelect(
|
|
'SELECT lexo_rank_previous(?1, (SELECT order_key FROM tab WHERE container_id IS ?2 ORDER BY order_key LIMIT 1)) AS _c0',
|
|
variables: [
|
|
Variable<int>(bucket),
|
|
Variable<String>(containerId)
|
|
],
|
|
readsFrom: {
|
|
tab,
|
|
}).map((QueryRow row) => row.read<String>('_c0'));
|
|
}
|
|
|
|
Selectable<String> trailingOrderKey(
|
|
{required int bucket, String? containerId}) {
|
|
return customSelect(
|
|
'SELECT lexo_rank_next(?1, (SELECT order_key FROM tab WHERE container_id IS ?2 ORDER BY order_key DESC LIMIT 1)) AS _c0',
|
|
variables: [
|
|
Variable<int>(bucket),
|
|
Variable<String>(containerId)
|
|
],
|
|
readsFrom: {
|
|
tab,
|
|
}).map((QueryRow row) => row.read<String>('_c0'));
|
|
}
|
|
|
|
Selectable<String> orderKeyAfterTab(
|
|
{String? containerId, required String tabId}) {
|
|
return customSelect(
|
|
'WITH ordered_table AS (SELECT id, order_key, LEAD(order_key)OVER (ORDER BY order_key RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE NO OTHERS) AS next_order_key FROM tab WHERE container_id IS ?1) SELECT lexo_rank_reorder_after(order_key, next_order_key) AS _c0 FROM ordered_table WHERE id = ?2',
|
|
variables: [
|
|
Variable<String>(containerId),
|
|
Variable<String>(tabId)
|
|
],
|
|
readsFrom: {
|
|
tab,
|
|
}).map((QueryRow row) => row.read<String>('_c0'));
|
|
}
|
|
|
|
Selectable<TabQueryResult> queryTabsBasic(
|
|
{required String beforeMatch,
|
|
required String afterMatch,
|
|
required String query}) {
|
|
return customSelect(
|
|
'WITH weights AS (SELECT 10.0 AS title_weight, 5.0 AS url_weight) SELECT t.id, highlight(tab_fts, 0, ?1, ?2) AS title, highlight(tab_fts, 1, ?1, ?2) AS url, bm25(tab_fts, weights.title_weight, weights.url_weight) AS weighted_rank, t.url AS clean_url FROM tab_fts AS fts INNER JOIN tab AS t ON t."rowid" = fts."rowid" CROSS JOIN weights WHERE fts.title LIKE ?3 OR fts.url LIKE ?3 ORDER BY weighted_rank ASC, t.timestamp DESC',
|
|
variables: [
|
|
Variable<String>(beforeMatch),
|
|
Variable<String>(afterMatch),
|
|
Variable<String>(query)
|
|
],
|
|
readsFrom: {
|
|
tab,
|
|
tabFts,
|
|
}).map((QueryRow row) => TabQueryResult(
|
|
id: row.read<String>('id'),
|
|
title: row.readNullable<String>('title'),
|
|
url: row.readNullable<String>('url'),
|
|
cleanUrl: row.readNullable<String>('clean_url'),
|
|
weightedRank: row.read<double>('weighted_rank'),
|
|
));
|
|
}
|
|
|
|
Selectable<TabQueryResult> queryTabsFullContent(
|
|
{required String beforeMatch,
|
|
required String afterMatch,
|
|
required String ellipsis,
|
|
required int snippetLength,
|
|
required String query}) {
|
|
return customSelect(
|
|
'WITH weights AS (SELECT 10.0 AS title_weight, 5.0 AS url_weight, 3.0 AS extracted_weight, 1.0 AS full_weight) SELECT t.id, highlight(tab_fts, 0, ?1, ?2) AS title, highlight(tab_fts, 1, ?1, ?2) AS url, snippet(tab_fts, 2, ?1, ?2, ?3, ?4) AS extracted_content, snippet(tab_fts, 3, ?1, ?2, ?3, ?4) AS full_content,(bm25(tab_fts, weights.title_weight, weights.url_weight, weights.extracted_weight, weights.full_weight))AS weighted_rank, t.url AS clean_url FROM tab_fts(?5)AS fts INNER JOIN tab AS t ON t."rowid" = fts."rowid" CROSS JOIN weights ORDER BY weighted_rank ASC, t.timestamp DESC',
|
|
variables: [
|
|
Variable<String>(beforeMatch),
|
|
Variable<String>(afterMatch),
|
|
Variable<String>(ellipsis),
|
|
Variable<int>(snippetLength),
|
|
Variable<String>(query)
|
|
],
|
|
readsFrom: {
|
|
tab,
|
|
tabFts,
|
|
}).map((QueryRow row) => TabQueryResult(
|
|
id: row.read<String>('id'),
|
|
title: row.readNullable<String>('title'),
|
|
url: row.readNullable<String>('url'),
|
|
cleanUrl: row.readNullable<String>('clean_url'),
|
|
extractedContent: row.readNullable<String>('extracted_content'),
|
|
fullContent: row.readNullable<String>('full_content'),
|
|
weightedRank: row.read<double>('weighted_rank'),
|
|
));
|
|
}
|
|
|
|
Selectable<DocumentData> missingDocumentEmbeddings(
|
|
{String? mainDocumentId, String? contextId}) {
|
|
return customSelect(
|
|
'SELECT doc.* FROM document AS doc WHERE doc.main_document_id IS COALESCE(?1, doc.main_document_id) AND doc.context_id IS COALESCE(?2, doc.context_id) AND NOT EXISTS (SELECT 1 AS _c0 FROM document_vec AS vec WHERE vec.id = doc.document_id)',
|
|
variables: [
|
|
Variable<String>(mainDocumentId),
|
|
Variable<String>(contextId)
|
|
],
|
|
readsFrom: {
|
|
document,
|
|
documentVec,
|
|
}).asyncMap(document.mapFromRow);
|
|
}
|
|
|
|
Selectable<VectorResult> queryVectors(
|
|
{required Uint8List searchVectors,
|
|
int? k,
|
|
String? mainDocumentId,
|
|
String? contextId}) {
|
|
return customSelect(
|
|
'SELECT vec.id, doc.main_document_id, doc.context_id, doc.content, doc.metadata, vec.distance FROM document_vec AS vec INNER JOIN document AS doc ON doc.document_id = vec.id WHERE vec.embedding MATCH ?1 AND vec.k = ?2 AND vec.main_document_id IS COALESCE(?3, vec.main_document_id) AND vec.context_id IS COALESCE(?4, vec.context_id) ORDER BY vec.distance',
|
|
variables: [
|
|
Variable<Uint8List>(searchVectors),
|
|
Variable<int>(k),
|
|
Variable<String>(mainDocumentId),
|
|
Variable<String>(contextId)
|
|
],
|
|
readsFrom: {
|
|
documentVec,
|
|
document,
|
|
}).map((QueryRow row) => VectorResult(
|
|
id: row.read<String>('id'),
|
|
mainDocumentId: row.readNullable<String>('main_document_id'),
|
|
contextId: row.readNullable<String>('context_id'),
|
|
content: row.read<String>('content'),
|
|
metadata: row.readNullable<String>('metadata'),
|
|
distance: row.readNullable<double>('distance'),
|
|
));
|
|
}
|
|
|
|
@override
|
|
Iterable<TableInfo<Table, Object?>> get allTables =>
|
|
allSchemaEntities.whereType<TableInfo<Table, Object?>>();
|
|
@override
|
|
List<DatabaseSchemaEntity> get allSchemaEntities => [
|
|
container,
|
|
tab,
|
|
document,
|
|
tabDocumentDelete,
|
|
tabFts,
|
|
tabAfterInsert,
|
|
tabAfterDelete,
|
|
tabAfterUpdate,
|
|
documentMainDocumentId,
|
|
documentContextId,
|
|
documentVec,
|
|
documentDelete,
|
|
documentUpdateDelete
|
|
];
|
|
@override
|
|
StreamQueryUpdateRules get streamUpdateRules => const StreamQueryUpdateRules(
|
|
[
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName('container',
|
|
limitUpdateKind: UpdateKind.delete),
|
|
result: [
|
|
TableUpdate('tab', kind: UpdateKind.delete),
|
|
],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName('tab',
|
|
limitUpdateKind: UpdateKind.delete),
|
|
result: [
|
|
TableUpdate('document', kind: UpdateKind.delete),
|
|
],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName('tab',
|
|
limitUpdateKind: UpdateKind.insert),
|
|
result: [
|
|
TableUpdate('tab_fts', kind: UpdateKind.insert),
|
|
],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName('tab',
|
|
limitUpdateKind: UpdateKind.delete),
|
|
result: [
|
|
TableUpdate('tab_fts', kind: UpdateKind.insert),
|
|
],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName('tab',
|
|
limitUpdateKind: UpdateKind.update),
|
|
result: [
|
|
TableUpdate('tab_fts', kind: UpdateKind.insert),
|
|
],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName('document',
|
|
limitUpdateKind: UpdateKind.delete),
|
|
result: [
|
|
TableUpdate('document_vec', kind: UpdateKind.delete),
|
|
],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName('document',
|
|
limitUpdateKind: UpdateKind.update),
|
|
result: [
|
|
TableUpdate('document_vec', kind: UpdateKind.delete),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
typedef $ContainerCreateCompanionBuilder = ContainerCompanion Function({
|
|
required String id,
|
|
Value<String?> name,
|
|
required Color color,
|
|
Value<ContainerMetadata?> metadata,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $ContainerUpdateCompanionBuilder = ContainerCompanion Function({
|
|
Value<String> id,
|
|
Value<String?> name,
|
|
Value<Color> color,
|
|
Value<ContainerMetadata?> metadata,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $ContainerReferences
|
|
extends BaseReferences<_$TabDatabase, Container, ContainerData> {
|
|
$ContainerReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<Tab, List<TabData>> _tabRefsTable(
|
|
_$TabDatabase db) =>
|
|
MultiTypedResultKey.fromTable(db.tab,
|
|
aliasName: $_aliasNameGenerator(db.container.id, db.tab.containerId));
|
|
|
|
$TabProcessedTableManager get tabRefs {
|
|
final manager = $TabTableManager($_db, $_db.tab)
|
|
.filter((f) => f.containerId.id.sqlEquals($_itemColumn<String>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(_tabRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache));
|
|
}
|
|
}
|
|
|
|
class $ContainerFilterComposer extends Composer<_$TabDatabase, Container> {
|
|
$ContainerFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get id => $composableBuilder(
|
|
column: $table.id, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get name => $composableBuilder(
|
|
column: $table.name, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnWithTypeConverterFilters<Color, Color, int> get color =>
|
|
$composableBuilder(
|
|
column: $table.color,
|
|
builder: (column) => ColumnWithTypeConverterFilters(column));
|
|
|
|
ColumnWithTypeConverterFilters<ContainerMetadata?, ContainerMetadata, String>
|
|
get metadata => $composableBuilder(
|
|
column: $table.metadata,
|
|
builder: (column) => ColumnWithTypeConverterFilters(column));
|
|
|
|
Expression<bool> tabRefs(Expression<bool> Function($TabFilterComposer f) f) {
|
|
final $TabFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.tab,
|
|
getReferencedColumn: (t) => t.containerId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$TabFilterComposer(
|
|
$db: $db,
|
|
$table: $db.tab,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $ContainerOrderingComposer extends Composer<_$TabDatabase, Container> {
|
|
$ContainerOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get id => $composableBuilder(
|
|
column: $table.id, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get name => $composableBuilder(
|
|
column: $table.name, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<int> get color => $composableBuilder(
|
|
column: $table.color, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get metadata => $composableBuilder(
|
|
column: $table.metadata, builder: (column) => ColumnOrderings(column));
|
|
}
|
|
|
|
class $ContainerAnnotationComposer extends Composer<_$TabDatabase, Container> {
|
|
$ContainerAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get name =>
|
|
$composableBuilder(column: $table.name, builder: (column) => column);
|
|
|
|
GeneratedColumnWithTypeConverter<Color, int> get color =>
|
|
$composableBuilder(column: $table.color, builder: (column) => column);
|
|
|
|
GeneratedColumnWithTypeConverter<ContainerMetadata?, String> get metadata =>
|
|
$composableBuilder(column: $table.metadata, builder: (column) => column);
|
|
|
|
Expression<T> tabRefs<T extends Object>(
|
|
Expression<T> Function($TabAnnotationComposer a) f) {
|
|
final $TabAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.tab,
|
|
getReferencedColumn: (t) => t.containerId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$TabAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.tab,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $ContainerTableManager extends RootTableManager<
|
|
_$TabDatabase,
|
|
Container,
|
|
ContainerData,
|
|
$ContainerFilterComposer,
|
|
$ContainerOrderingComposer,
|
|
$ContainerAnnotationComposer,
|
|
$ContainerCreateCompanionBuilder,
|
|
$ContainerUpdateCompanionBuilder,
|
|
(ContainerData, $ContainerReferences),
|
|
ContainerData,
|
|
PrefetchHooks Function({bool tabRefs})> {
|
|
$ContainerTableManager(_$TabDatabase db, Container table)
|
|
: super(TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$ContainerFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$ContainerOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$ContainerAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback: ({
|
|
Value<String> id = const Value.absent(),
|
|
Value<String?> name = const Value.absent(),
|
|
Value<Color> color = const Value.absent(),
|
|
Value<ContainerMetadata?> metadata = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
ContainerCompanion(
|
|
id: id,
|
|
name: name,
|
|
color: color,
|
|
metadata: metadata,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback: ({
|
|
required String id,
|
|
Value<String?> name = const Value.absent(),
|
|
required Color color,
|
|
Value<ContainerMetadata?> metadata = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
ContainerCompanion.insert(
|
|
id: id,
|
|
name: name,
|
|
color: color,
|
|
metadata: metadata,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) =>
|
|
(e.readTable(table), $ContainerReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: ({tabRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [if (tabRefs) db.tab],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (tabRefs)
|
|
await $_getPrefetchedData<ContainerData, Container,
|
|
TabData>(
|
|
currentTable: table,
|
|
referencedTable: $ContainerReferences._tabRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$ContainerReferences(db, table, p0).tabRefs,
|
|
referencedItemsForCurrentItem:
|
|
(item, referencedItems) => referencedItems
|
|
.where((e) => e.containerId == item.id),
|
|
typedResults: items)
|
|
];
|
|
},
|
|
);
|
|
},
|
|
));
|
|
}
|
|
|
|
typedef $ContainerProcessedTableManager = ProcessedTableManager<
|
|
_$TabDatabase,
|
|
Container,
|
|
ContainerData,
|
|
$ContainerFilterComposer,
|
|
$ContainerOrderingComposer,
|
|
$ContainerAnnotationComposer,
|
|
$ContainerCreateCompanionBuilder,
|
|
$ContainerUpdateCompanionBuilder,
|
|
(ContainerData, $ContainerReferences),
|
|
ContainerData,
|
|
PrefetchHooks Function({bool tabRefs})>;
|
|
typedef $TabCreateCompanionBuilder = TabCompanion Function({
|
|
required String id,
|
|
Value<String?> containerId,
|
|
required String orderKey,
|
|
Value<String?> url,
|
|
Value<String?> title,
|
|
Value<bool?> isProbablyReaderable,
|
|
Value<String?> extractedContentMarkdown,
|
|
Value<String?> extractedContentPlain,
|
|
Value<String?> fullContentMarkdown,
|
|
Value<String?> fullContentPlain,
|
|
required DateTime timestamp,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $TabUpdateCompanionBuilder = TabCompanion Function({
|
|
Value<String> id,
|
|
Value<String?> containerId,
|
|
Value<String> orderKey,
|
|
Value<String?> url,
|
|
Value<String?> title,
|
|
Value<bool?> isProbablyReaderable,
|
|
Value<String?> extractedContentMarkdown,
|
|
Value<String?> extractedContentPlain,
|
|
Value<String?> fullContentMarkdown,
|
|
Value<String?> fullContentPlain,
|
|
Value<DateTime> timestamp,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $TabReferences extends BaseReferences<_$TabDatabase, Tab, TabData> {
|
|
$TabReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static Container _containerIdTable(_$TabDatabase db) => db.container
|
|
.createAlias($_aliasNameGenerator(db.tab.containerId, db.container.id));
|
|
|
|
$ContainerProcessedTableManager? get containerId {
|
|
final $_column = $_itemColumn<String>('container_id');
|
|
if ($_column == null) return null;
|
|
final manager = $ContainerTableManager($_db, $_db.container)
|
|
.filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_containerIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]));
|
|
}
|
|
}
|
|
|
|
class $TabFilterComposer extends Composer<_$TabDatabase, Tab> {
|
|
$TabFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get id => $composableBuilder(
|
|
column: $table.id, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get orderKey => $composableBuilder(
|
|
column: $table.orderKey, 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<bool> get isProbablyReaderable => $composableBuilder(
|
|
column: $table.isProbablyReaderable,
|
|
builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get extractedContentMarkdown => $composableBuilder(
|
|
column: $table.extractedContentMarkdown,
|
|
builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get extractedContentPlain => $composableBuilder(
|
|
column: $table.extractedContentPlain,
|
|
builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get fullContentMarkdown => $composableBuilder(
|
|
column: $table.fullContentMarkdown,
|
|
builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get fullContentPlain => $composableBuilder(
|
|
column: $table.fullContentPlain,
|
|
builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<DateTime> get timestamp => $composableBuilder(
|
|
column: $table.timestamp, builder: (column) => ColumnFilters(column));
|
|
|
|
$ContainerFilterComposer get containerId {
|
|
final $ContainerFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.containerId,
|
|
referencedTable: $db.container,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$ContainerFilterComposer(
|
|
$db: $db,
|
|
$table: $db.container,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $TabOrderingComposer extends Composer<_$TabDatabase, Tab> {
|
|
$TabOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get id => $composableBuilder(
|
|
column: $table.id, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get orderKey => $composableBuilder(
|
|
column: $table.orderKey, 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<bool> get isProbablyReaderable => $composableBuilder(
|
|
column: $table.isProbablyReaderable,
|
|
builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get extractedContentMarkdown => $composableBuilder(
|
|
column: $table.extractedContentMarkdown,
|
|
builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get extractedContentPlain => $composableBuilder(
|
|
column: $table.extractedContentPlain,
|
|
builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get fullContentMarkdown => $composableBuilder(
|
|
column: $table.fullContentMarkdown,
|
|
builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get fullContentPlain => $composableBuilder(
|
|
column: $table.fullContentPlain,
|
|
builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<DateTime> get timestamp => $composableBuilder(
|
|
column: $table.timestamp, builder: (column) => ColumnOrderings(column));
|
|
|
|
$ContainerOrderingComposer get containerId {
|
|
final $ContainerOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.containerId,
|
|
referencedTable: $db.container,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$ContainerOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.container,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $TabAnnotationComposer extends Composer<_$TabDatabase, Tab> {
|
|
$TabAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get orderKey =>
|
|
$composableBuilder(column: $table.orderKey, 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<bool> get isProbablyReaderable => $composableBuilder(
|
|
column: $table.isProbablyReaderable, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get extractedContentMarkdown => $composableBuilder(
|
|
column: $table.extractedContentMarkdown, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get extractedContentPlain => $composableBuilder(
|
|
column: $table.extractedContentPlain, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get fullContentMarkdown => $composableBuilder(
|
|
column: $table.fullContentMarkdown, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get fullContentPlain => $composableBuilder(
|
|
column: $table.fullContentPlain, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get timestamp =>
|
|
$composableBuilder(column: $table.timestamp, builder: (column) => column);
|
|
|
|
$ContainerAnnotationComposer get containerId {
|
|
final $ContainerAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.containerId,
|
|
referencedTable: $db.container,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$ContainerAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.container,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $TabTableManager extends RootTableManager<
|
|
_$TabDatabase,
|
|
Tab,
|
|
TabData,
|
|
$TabFilterComposer,
|
|
$TabOrderingComposer,
|
|
$TabAnnotationComposer,
|
|
$TabCreateCompanionBuilder,
|
|
$TabUpdateCompanionBuilder,
|
|
(TabData, $TabReferences),
|
|
TabData,
|
|
PrefetchHooks Function({bool containerId})> {
|
|
$TabTableManager(_$TabDatabase db, Tab table)
|
|
: super(TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$TabFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$TabOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$TabAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback: ({
|
|
Value<String> id = const Value.absent(),
|
|
Value<String?> containerId = const Value.absent(),
|
|
Value<String> orderKey = const Value.absent(),
|
|
Value<String?> url = const Value.absent(),
|
|
Value<String?> title = const Value.absent(),
|
|
Value<bool?> isProbablyReaderable = const Value.absent(),
|
|
Value<String?> extractedContentMarkdown = const Value.absent(),
|
|
Value<String?> extractedContentPlain = const Value.absent(),
|
|
Value<String?> fullContentMarkdown = const Value.absent(),
|
|
Value<String?> fullContentPlain = const Value.absent(),
|
|
Value<DateTime> timestamp = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
TabCompanion(
|
|
id: id,
|
|
containerId: containerId,
|
|
orderKey: orderKey,
|
|
url: url,
|
|
title: title,
|
|
isProbablyReaderable: isProbablyReaderable,
|
|
extractedContentMarkdown: extractedContentMarkdown,
|
|
extractedContentPlain: extractedContentPlain,
|
|
fullContentMarkdown: fullContentMarkdown,
|
|
fullContentPlain: fullContentPlain,
|
|
timestamp: timestamp,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback: ({
|
|
required String id,
|
|
Value<String?> containerId = const Value.absent(),
|
|
required String orderKey,
|
|
Value<String?> url = const Value.absent(),
|
|
Value<String?> title = const Value.absent(),
|
|
Value<bool?> isProbablyReaderable = const Value.absent(),
|
|
Value<String?> extractedContentMarkdown = const Value.absent(),
|
|
Value<String?> extractedContentPlain = const Value.absent(),
|
|
Value<String?> fullContentMarkdown = const Value.absent(),
|
|
Value<String?> fullContentPlain = const Value.absent(),
|
|
required DateTime timestamp,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
TabCompanion.insert(
|
|
id: id,
|
|
containerId: containerId,
|
|
orderKey: orderKey,
|
|
url: url,
|
|
title: title,
|
|
isProbablyReaderable: isProbablyReaderable,
|
|
extractedContentMarkdown: extractedContentMarkdown,
|
|
extractedContentPlain: extractedContentPlain,
|
|
fullContentMarkdown: fullContentMarkdown,
|
|
fullContentPlain: fullContentPlain,
|
|
timestamp: timestamp,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), $TabReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: ({containerId = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [],
|
|
addJoins: <
|
|
T extends TableManagerState<
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic>>(state) {
|
|
if (containerId) {
|
|
state = state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.containerId,
|
|
referencedTable: $TabReferences._containerIdTable(db),
|
|
referencedColumn: $TabReferences._containerIdTable(db).id,
|
|
) as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [];
|
|
},
|
|
);
|
|
},
|
|
));
|
|
}
|
|
|
|
typedef $TabProcessedTableManager = ProcessedTableManager<
|
|
_$TabDatabase,
|
|
Tab,
|
|
TabData,
|
|
$TabFilterComposer,
|
|
$TabOrderingComposer,
|
|
$TabAnnotationComposer,
|
|
$TabCreateCompanionBuilder,
|
|
$TabUpdateCompanionBuilder,
|
|
(TabData, $TabReferences),
|
|
TabData,
|
|
PrefetchHooks Function({bool containerId})>;
|
|
typedef $DocumentCreateCompanionBuilder = DocumentCompanion Function({
|
|
required String documentId,
|
|
Value<String?> mainDocumentId,
|
|
Value<String?> contextId,
|
|
required String content,
|
|
required String contentHash,
|
|
Value<String?> metadata,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $DocumentUpdateCompanionBuilder = DocumentCompanion Function({
|
|
Value<String> documentId,
|
|
Value<String?> mainDocumentId,
|
|
Value<String?> contextId,
|
|
Value<String> content,
|
|
Value<String> contentHash,
|
|
Value<String?> metadata,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
class $DocumentFilterComposer extends Composer<_$TabDatabase, Document> {
|
|
$DocumentFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get documentId => $composableBuilder(
|
|
column: $table.documentId, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get mainDocumentId => $composableBuilder(
|
|
column: $table.mainDocumentId,
|
|
builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get contextId => $composableBuilder(
|
|
column: $table.contextId, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get content => $composableBuilder(
|
|
column: $table.content, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get contentHash => $composableBuilder(
|
|
column: $table.contentHash, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get metadata => $composableBuilder(
|
|
column: $table.metadata, builder: (column) => ColumnFilters(column));
|
|
}
|
|
|
|
class $DocumentOrderingComposer extends Composer<_$TabDatabase, Document> {
|
|
$DocumentOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get documentId => $composableBuilder(
|
|
column: $table.documentId, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get mainDocumentId => $composableBuilder(
|
|
column: $table.mainDocumentId,
|
|
builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get contextId => $composableBuilder(
|
|
column: $table.contextId, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get content => $composableBuilder(
|
|
column: $table.content, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get contentHash => $composableBuilder(
|
|
column: $table.contentHash, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get metadata => $composableBuilder(
|
|
column: $table.metadata, builder: (column) => ColumnOrderings(column));
|
|
}
|
|
|
|
class $DocumentAnnotationComposer extends Composer<_$TabDatabase, Document> {
|
|
$DocumentAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get documentId => $composableBuilder(
|
|
column: $table.documentId, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get mainDocumentId => $composableBuilder(
|
|
column: $table.mainDocumentId, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get contextId =>
|
|
$composableBuilder(column: $table.contextId, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get content =>
|
|
$composableBuilder(column: $table.content, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get contentHash => $composableBuilder(
|
|
column: $table.contentHash, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get metadata =>
|
|
$composableBuilder(column: $table.metadata, builder: (column) => column);
|
|
}
|
|
|
|
class $DocumentTableManager extends RootTableManager<
|
|
_$TabDatabase,
|
|
Document,
|
|
DocumentData,
|
|
$DocumentFilterComposer,
|
|
$DocumentOrderingComposer,
|
|
$DocumentAnnotationComposer,
|
|
$DocumentCreateCompanionBuilder,
|
|
$DocumentUpdateCompanionBuilder,
|
|
(DocumentData, BaseReferences<_$TabDatabase, Document, DocumentData>),
|
|
DocumentData,
|
|
PrefetchHooks Function()> {
|
|
$DocumentTableManager(_$TabDatabase db, Document table)
|
|
: super(TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$DocumentFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$DocumentOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$DocumentAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback: ({
|
|
Value<String> documentId = const Value.absent(),
|
|
Value<String?> mainDocumentId = const Value.absent(),
|
|
Value<String?> contextId = const Value.absent(),
|
|
Value<String> content = const Value.absent(),
|
|
Value<String> contentHash = const Value.absent(),
|
|
Value<String?> metadata = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
DocumentCompanion(
|
|
documentId: documentId,
|
|
mainDocumentId: mainDocumentId,
|
|
contextId: contextId,
|
|
content: content,
|
|
contentHash: contentHash,
|
|
metadata: metadata,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback: ({
|
|
required String documentId,
|
|
Value<String?> mainDocumentId = const Value.absent(),
|
|
Value<String?> contextId = const Value.absent(),
|
|
required String content,
|
|
required String contentHash,
|
|
Value<String?> metadata = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
DocumentCompanion.insert(
|
|
documentId: documentId,
|
|
mainDocumentId: mainDocumentId,
|
|
contextId: contextId,
|
|
content: content,
|
|
contentHash: contentHash,
|
|
metadata: metadata,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
));
|
|
}
|
|
|
|
typedef $DocumentProcessedTableManager = ProcessedTableManager<
|
|
_$TabDatabase,
|
|
Document,
|
|
DocumentData,
|
|
$DocumentFilterComposer,
|
|
$DocumentOrderingComposer,
|
|
$DocumentAnnotationComposer,
|
|
$DocumentCreateCompanionBuilder,
|
|
$DocumentUpdateCompanionBuilder,
|
|
(DocumentData, BaseReferences<_$TabDatabase, Document, DocumentData>),
|
|
DocumentData,
|
|
PrefetchHooks Function()>;
|
|
typedef $TabFtsCreateCompanionBuilder = TabFtsCompanion Function({
|
|
required String title,
|
|
required String url,
|
|
required String extractedContentPlain,
|
|
required String fullContentPlain,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $TabFtsUpdateCompanionBuilder = TabFtsCompanion Function({
|
|
Value<String> title,
|
|
Value<String> url,
|
|
Value<String> extractedContentPlain,
|
|
Value<String> fullContentPlain,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
class $TabFtsFilterComposer extends Composer<_$TabDatabase, TabFts> {
|
|
$TabFtsFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get title => $composableBuilder(
|
|
column: $table.title, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get url => $composableBuilder(
|
|
column: $table.url, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get extractedContentPlain => $composableBuilder(
|
|
column: $table.extractedContentPlain,
|
|
builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get fullContentPlain => $composableBuilder(
|
|
column: $table.fullContentPlain,
|
|
builder: (column) => ColumnFilters(column));
|
|
}
|
|
|
|
class $TabFtsOrderingComposer extends Composer<_$TabDatabase, TabFts> {
|
|
$TabFtsOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get title => $composableBuilder(
|
|
column: $table.title, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get url => $composableBuilder(
|
|
column: $table.url, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get extractedContentPlain => $composableBuilder(
|
|
column: $table.extractedContentPlain,
|
|
builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get fullContentPlain => $composableBuilder(
|
|
column: $table.fullContentPlain,
|
|
builder: (column) => ColumnOrderings(column));
|
|
}
|
|
|
|
class $TabFtsAnnotationComposer extends Composer<_$TabDatabase, TabFts> {
|
|
$TabFtsAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get title =>
|
|
$composableBuilder(column: $table.title, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get url =>
|
|
$composableBuilder(column: $table.url, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get extractedContentPlain => $composableBuilder(
|
|
column: $table.extractedContentPlain, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get fullContentPlain => $composableBuilder(
|
|
column: $table.fullContentPlain, builder: (column) => column);
|
|
}
|
|
|
|
class $TabFtsTableManager extends RootTableManager<
|
|
_$TabDatabase,
|
|
TabFts,
|
|
TabFt,
|
|
$TabFtsFilterComposer,
|
|
$TabFtsOrderingComposer,
|
|
$TabFtsAnnotationComposer,
|
|
$TabFtsCreateCompanionBuilder,
|
|
$TabFtsUpdateCompanionBuilder,
|
|
(TabFt, BaseReferences<_$TabDatabase, TabFts, TabFt>),
|
|
TabFt,
|
|
PrefetchHooks Function()> {
|
|
$TabFtsTableManager(_$TabDatabase db, TabFts table)
|
|
: super(TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$TabFtsFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$TabFtsOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$TabFtsAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback: ({
|
|
Value<String> title = const Value.absent(),
|
|
Value<String> url = const Value.absent(),
|
|
Value<String> extractedContentPlain = const Value.absent(),
|
|
Value<String> fullContentPlain = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
TabFtsCompanion(
|
|
title: title,
|
|
url: url,
|
|
extractedContentPlain: extractedContentPlain,
|
|
fullContentPlain: fullContentPlain,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback: ({
|
|
required String title,
|
|
required String url,
|
|
required String extractedContentPlain,
|
|
required String fullContentPlain,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
TabFtsCompanion.insert(
|
|
title: title,
|
|
url: url,
|
|
extractedContentPlain: extractedContentPlain,
|
|
fullContentPlain: fullContentPlain,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
));
|
|
}
|
|
|
|
typedef $TabFtsProcessedTableManager = ProcessedTableManager<
|
|
_$TabDatabase,
|
|
TabFts,
|
|
TabFt,
|
|
$TabFtsFilterComposer,
|
|
$TabFtsOrderingComposer,
|
|
$TabFtsAnnotationComposer,
|
|
$TabFtsCreateCompanionBuilder,
|
|
$TabFtsUpdateCompanionBuilder,
|
|
(TabFt, BaseReferences<_$TabDatabase, TabFts, TabFt>),
|
|
TabFt,
|
|
PrefetchHooks Function()>;
|
|
typedef $DocumentVecCreateCompanionBuilder = DocumentVecCompanion Function({
|
|
required String id,
|
|
Value<String?> mainDocumentId,
|
|
Value<String?> contextId,
|
|
required Uint8List embedding,
|
|
required String contentHash,
|
|
Value<double?> distance,
|
|
Value<int?> k,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $DocumentVecUpdateCompanionBuilder = DocumentVecCompanion Function({
|
|
Value<String> id,
|
|
Value<String?> mainDocumentId,
|
|
Value<String?> contextId,
|
|
Value<Uint8List> embedding,
|
|
Value<String> contentHash,
|
|
Value<double?> distance,
|
|
Value<int?> k,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
class $DocumentVecFilterComposer extends Composer<_$TabDatabase, DocumentVec> {
|
|
$DocumentVecFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get id => $composableBuilder(
|
|
column: $table.id, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get mainDocumentId => $composableBuilder(
|
|
column: $table.mainDocumentId,
|
|
builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get contextId => $composableBuilder(
|
|
column: $table.contextId, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<Uint8List> get embedding => $composableBuilder(
|
|
column: $table.embedding, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get contentHash => $composableBuilder(
|
|
column: $table.contentHash, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<double> get distance => $composableBuilder(
|
|
column: $table.distance, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<int> get k => $composableBuilder(
|
|
column: $table.k, builder: (column) => ColumnFilters(column));
|
|
}
|
|
|
|
class $DocumentVecOrderingComposer
|
|
extends Composer<_$TabDatabase, DocumentVec> {
|
|
$DocumentVecOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get id => $composableBuilder(
|
|
column: $table.id, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get mainDocumentId => $composableBuilder(
|
|
column: $table.mainDocumentId,
|
|
builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get contextId => $composableBuilder(
|
|
column: $table.contextId, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<Uint8List> get embedding => $composableBuilder(
|
|
column: $table.embedding, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get contentHash => $composableBuilder(
|
|
column: $table.contentHash, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<double> get distance => $composableBuilder(
|
|
column: $table.distance, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<int> get k => $composableBuilder(
|
|
column: $table.k, builder: (column) => ColumnOrderings(column));
|
|
}
|
|
|
|
class $DocumentVecAnnotationComposer
|
|
extends Composer<_$TabDatabase, DocumentVec> {
|
|
$DocumentVecAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get mainDocumentId => $composableBuilder(
|
|
column: $table.mainDocumentId, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get contextId =>
|
|
$composableBuilder(column: $table.contextId, builder: (column) => column);
|
|
|
|
GeneratedColumn<Uint8List> get embedding =>
|
|
$composableBuilder(column: $table.embedding, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get contentHash => $composableBuilder(
|
|
column: $table.contentHash, builder: (column) => column);
|
|
|
|
GeneratedColumn<double> get distance =>
|
|
$composableBuilder(column: $table.distance, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get k =>
|
|
$composableBuilder(column: $table.k, builder: (column) => column);
|
|
}
|
|
|
|
class $DocumentVecTableManager extends RootTableManager<
|
|
_$TabDatabase,
|
|
DocumentVec,
|
|
DocumentVecData,
|
|
$DocumentVecFilterComposer,
|
|
$DocumentVecOrderingComposer,
|
|
$DocumentVecAnnotationComposer,
|
|
$DocumentVecCreateCompanionBuilder,
|
|
$DocumentVecUpdateCompanionBuilder,
|
|
(
|
|
DocumentVecData,
|
|
BaseReferences<_$TabDatabase, DocumentVec, DocumentVecData>
|
|
),
|
|
DocumentVecData,
|
|
PrefetchHooks Function()> {
|
|
$DocumentVecTableManager(_$TabDatabase db, DocumentVec table)
|
|
: super(TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$DocumentVecFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$DocumentVecOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$DocumentVecAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback: ({
|
|
Value<String> id = const Value.absent(),
|
|
Value<String?> mainDocumentId = const Value.absent(),
|
|
Value<String?> contextId = const Value.absent(),
|
|
Value<Uint8List> embedding = const Value.absent(),
|
|
Value<String> contentHash = const Value.absent(),
|
|
Value<double?> distance = const Value.absent(),
|
|
Value<int?> k = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
DocumentVecCompanion(
|
|
id: id,
|
|
mainDocumentId: mainDocumentId,
|
|
contextId: contextId,
|
|
embedding: embedding,
|
|
contentHash: contentHash,
|
|
distance: distance,
|
|
k: k,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback: ({
|
|
required String id,
|
|
Value<String?> mainDocumentId = const Value.absent(),
|
|
Value<String?> contextId = const Value.absent(),
|
|
required Uint8List embedding,
|
|
required String contentHash,
|
|
Value<double?> distance = const Value.absent(),
|
|
Value<int?> k = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) =>
|
|
DocumentVecCompanion.insert(
|
|
id: id,
|
|
mainDocumentId: mainDocumentId,
|
|
contextId: contextId,
|
|
embedding: embedding,
|
|
contentHash: contentHash,
|
|
distance: distance,
|
|
k: k,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
));
|
|
}
|
|
|
|
typedef $DocumentVecProcessedTableManager = ProcessedTableManager<
|
|
_$TabDatabase,
|
|
DocumentVec,
|
|
DocumentVecData,
|
|
$DocumentVecFilterComposer,
|
|
$DocumentVecOrderingComposer,
|
|
$DocumentVecAnnotationComposer,
|
|
$DocumentVecCreateCompanionBuilder,
|
|
$DocumentVecUpdateCompanionBuilder,
|
|
(
|
|
DocumentVecData,
|
|
BaseReferences<_$TabDatabase, DocumentVec, DocumentVecData>
|
|
),
|
|
DocumentVecData,
|
|
PrefetchHooks Function()>;
|
|
|
|
class $TabDatabaseManager {
|
|
final _$TabDatabase _db;
|
|
$TabDatabaseManager(this._db);
|
|
$ContainerTableManager get container =>
|
|
$ContainerTableManager(_db, _db.container);
|
|
$TabTableManager get tab => $TabTableManager(_db, _db.tab);
|
|
$DocumentTableManager get document =>
|
|
$DocumentTableManager(_db, _db.document);
|
|
$TabFtsTableManager get tabFts => $TabFtsTableManager(_db, _db.tabFts);
|
|
$DocumentVecTableManager get documentVec =>
|
|
$DocumentVecTableManager(_db, _db.documentVec);
|
|
}
|