-# Copyright (C) 2018 all contributors <meta@public-inbox.org>
+# Copyright (C) 2018-2020 all contributors <meta@public-inbox.org>
# License: AGPL-3.0+ <https://www.gnu.org/licenses/agpl-3.0.txt>
# for XOVER, OVER in NNTP, and feeds/homepage/threads in PSGI
-# Unlike Msgmap, this is an _UNSTABLE_ database which can be
+# Unlike Msgmap, this is an _UNSTABLE_ cache which can be
# tweaked/updated over time and rebuilt.
+#
+# Ghost messages (messages which are only referenced in References/In-Reply-To)
+# are denoted by a negative NNTP article number.
package PublicInbox::OverIdx;
use strict;
use warnings;
use base qw(PublicInbox::Over);
use IO::Handle;
-use DBI qw(:sql_types); # SQL_BLOB
+use DBI;
+use PublicInbox::MID qw/id_compress mids_for_index references/;
+use PublicInbox::Smsg qw(subject_normalized);
+use Compress::Zlib qw(compress);
+use PublicInbox::Search;
sub dbh_new {
my ($self) = @_;
- my $dbh = $self->SUPER::dbh_new;
- $dbh->do('PRAGMA synchronous = OFF'); # commit_fsync instead
+ my $dbh = $self->SUPER::dbh_new(1);
+
+ # TRUNCATE reduces I/O compared to the default (DELETE)
+ # We do not use WAL since we're optimized for read-only ops,
+ # (and read-only requires SQLite 3.22.0 (2018-01-22)).
$dbh->do('PRAGMA journal_mode = TRUNCATE');
+
+ # 80000 pages (80MiB on SQLite <3.12.0, 320MiB on 3.12.0+)
+ # was found to be good in 2018 during the large LKML import
+ # at the time. This ought to be configurable based on HW
+ # and inbox size; I suspect it's overkill for many inboxes.
$dbh->do('PRAGMA cache_size = 80000');
+
create_tables($dbh);
$dbh;
}
-sub commit_fsync {
- my $fn = $_[0]->{filename};
- if (open my $fh, '+<', $fn) {
- $fh->sync;
- close $fh;
- }
-}
-
sub get_counter ($$) {
my ($dbh, $key) = @_;
my $sth = $dbh->prepare_cached(<<'', undef, 1);
}
sub delete_by_num {
- my ($self, $num) = @_;
+ my ($self, $num, $tid_ref) = @_;
my $dbh = $self->{dbh};
+ if ($tid_ref) {
+ my $sth = $dbh->prepare_cached(<<'', undef, 1);
+SELECT tid FROM over WHERE num = ? LIMIT 1
+
+ $sth->execute($num);
+ $$tid_ref = $sth->fetchrow_array; # may be undef
+ }
foreach (qw(over id2num)) {
$dbh->prepare_cached(<<"")->execute($num);
DELETE FROM $_ WHERE num = ?
# this includes ghosts
sub each_by_mid {
- my ($self, $mid, $cols, $cb) = @_;
+ my ($self, $mid, $cols, $cb, @arg) = @_;
my $dbh = $self->{dbh};
=over
foreach (@$nums) {
$sth->execute($_->[0]);
my $smsg = $sth->fetchrow_hashref;
- $cb->(PublicInbox::Over::load_from_row($smsg)) or
- return;
+ $smsg = PublicInbox::Over::load_from_row($smsg);
+ $cb->($self, $smsg, @arg) or return;
}
return if $nr != $lim;
}
}
+sub _resolve_mid_to_tid {
+ my ($self, $smsg, $tid) = @_;
+ my $cur_tid = $smsg->{tid};
+ if (defined $$tid) {
+ merge_threads($self, $$tid, $cur_tid);
+ } else {
+ $$tid = $cur_tid;
+ }
+ 1;
+}
+
# this will create a ghost as necessary
sub resolve_mid_to_tid {
my ($self, $mid) = @_;
my $tid;
- each_by_mid($self, $mid, ['tid'], sub {
- my ($smsg) = @_;
- my $cur_tid = $smsg->{tid};
- if (defined $tid) {
- merge_threads($self, $tid, $cur_tid);
- } else {
- $tid = $cur_tid;
- }
- 1;
- });
+ each_by_mid($self, $mid, ['tid'], \&_resolve_mid_to_tid, \$tid);
defined $tid ? $tid : create_ghost($self, $mid);
}
sub create_ghost {
my ($self, $mid) = @_;
- my $id = $self->mid2id($mid);
- my $num = $self->next_ghost_num;
+ my $id = mid2id($self, $mid);
+ my $num = next_ghost_num($self);
$num < 0 or die "ghost num is non-negative: $num\n";
- my $tid = $self->next_tid;
+ my $tid = next_tid($self);
my $dbh = $self->{dbh};
$dbh->prepare_cached(<<'')->execute($num, $tid);
INSERT INTO over (num, tid) VALUES (?,?)
merge_threads($self, $tid, $ptid);
}
} else {
- $tid = defined $old_tid ? $old_tid : $self->next_tid;
+ $tid = defined $old_tid ? $old_tid : next_tid($self);
}
$tid;
}
+sub parse_references ($$$) {
+ my ($smsg, $hdr, $mids) = @_;
+ my $refs = references($hdr);
+ push(@$refs, @$mids) if scalar(@$mids) > 1;
+ return $refs if scalar(@$refs) == 0;
+
+ # prevent circular references here:
+ my %seen = ( $smsg->{mid} => 1 );
+ my @keep;
+ foreach my $ref (@$refs) {
+ if (length($ref) > PublicInbox::MID::MAX_MID_SIZE) {
+ warn "References: <$ref> too long, ignoring\n";
+ next;
+ }
+ push(@keep, $ref) unless $seen{$ref}++;
+ }
+ $smsg->{references} = '<'.join('> <', @keep).'>' if @keep;
+ \@keep;
+}
+
+# normalize subjects so they are suitable as pathnames for URLs
+# XXX: consider for removal
+sub subject_path ($) {
+ my ($subj) = @_;
+ $subj = subject_normalized($subj);
+ $subj =~ s![^a-zA-Z0-9_\.~/\-]+!_!g;
+ lc($subj);
+}
+
+sub add_overview {
+ my ($self, $mime, $smsg) = @_;
+ $smsg->{lines} = $mime->body_raw =~ tr!\n!\n!;
+ my $hdr = $mime->header_obj;
+ my $mids = mids_for_index($hdr);
+ my $refs = parse_references($smsg, $hdr, $mids);
+ my $subj = $smsg->{subject};
+ my $xpath;
+ if ($subj ne '') {
+ $xpath = subject_path($subj);
+ $xpath = id_compress($xpath);
+ }
+ my $dd = $smsg->to_doc_data;
+ utf8::encode($dd);
+ $dd = compress($dd);
+ add_over($self, [ @$smsg{qw(ts ds num)}, $mids, $refs, $xpath, $dd ]);
+}
+
+sub _add_over {
+ my ($self, $smsg, $mid, $refs, $old_tid, $v) = @_;
+ my $cur_tid = $smsg->{tid};
+ my $n = $smsg->{num};
+ die "num must not be zero for $mid" if !$n;
+ $$old_tid = $cur_tid unless defined $$old_tid;
+ if ($n > 0) { # regular mail
+ merge_threads($self, $$old_tid, $cur_tid);
+ } elsif ($n < 0) { # ghost
+ link_refs($self, $refs, $$old_tid);
+ delete_by_num($self, $n);
+ $$v++;
+ }
+ 1;
+}
+
sub add_over {
my ($self, $values) = @_;
- my ($ts, $num, $mids, $refs, $xpath, $ddd) = @$values;
+ my ($ts, $ds, $num, $mids, $refs, $xpath, $ddd) = @$values;
my $old_tid;
my $vivified = 0;
- $self->begin_lazy;
- $self->delete_by_num($num);
+ begin_lazy($self);
+ delete_by_num($self, $num, \$old_tid);
foreach my $mid (@$mids) {
my $v = 0;
- each_by_mid($self, $mid, ['tid'], sub {
- my ($cur) = @_;
- my $cur_tid = $cur->{tid};
- my $n = $cur->{num};
- die "num must not be zero for $mid" if !$n;
- $old_tid = $cur_tid unless defined $old_tid;
- if ($n > 0) { # regular mail
- merge_threads($self, $old_tid, $cur_tid);
- } elsif ($n < 0) { # ghost
- link_refs($self, $refs, $old_tid);
- $self->delete_by_num($n);
- $v++;
- }
- 1;
- });
+ each_by_mid($self, $mid, ['tid'], \&_add_over,
+ $mid, $refs, \$old_tid, \$v);
$v > 1 and warn "BUG: vivified multiple ($v) ghosts for $mid\n";
$vivified += $v;
}
my $tid = $vivified ? $old_tid : link_refs($self, $refs, $old_tid);
- my $sid = $self->sid($xpath);
+ my $sid = sid($self, $xpath);
my $dbh = $self->{dbh};
my $sth = $dbh->prepare_cached(<<'');
-INSERT INTO over (num, tid, sid, ts, ddd)
-VALUES (?,?,?,?,?)
+INSERT INTO over (num, tid, sid, ts, ds, ddd)
+VALUES (?,?,?,?,?,?)
my $n = 0;
- my @v = ($num, $tid, $sid, $ts);
+ my @v = ($num, $tid, $sid, $ts, $ds);
foreach (@v) { $sth->bind_param(++$n, $_) }
- $sth->bind_param(++$n, $ddd, SQL_BLOB);
+ $sth->bind_param(++$n, $ddd);
$sth->execute;
$sth = $dbh->prepare_cached(<<'');
INSERT INTO id2num (id, num) VALUES (?,?)
foreach my $mid (@$mids) {
- my $id = $self->mid2id($mid);
+ my $id = mid2id($self, $mid);
$sth->execute($id, $num);
}
}
-sub delete_articles {
- my ($self, $nums) = @_;
- my $dbh = $self->connect;
- $self->delete_by_num($_) foreach @$nums;
+sub _remove_oid {
+ my ($self, $smsg, $oid, $nr) = @_;
+ if (!defined($oid) || $smsg->{blob} eq $oid) {
+ delete_by_num($self, $smsg->{num});
+ $$nr++;
+ }
+ 1;
}
+# returns number of removed messages
+# $oid may be undef to match only on $mid
sub remove_oid {
my ($self, $oid, $mid) = @_;
- $self->begin_lazy;
- each_by_mid($self, $mid, ['ddd'], sub {
- my ($smsg) = @_;
- $self->delete_by_num($smsg->{num}) if $smsg->{blob} eq $oid;
- 1;
- });
+ my $nr = 0;
+ begin_lazy($self);
+ each_by_mid($self, $mid, ['ddd'], \&_remove_oid, $oid, \$nr);
+ $nr;
+}
+
+sub _num_mid0_for_oid {
+ my ($self, $smsg, $oid, $res) = @_;
+ my $blob = $smsg->{blob};
+ return 1 if (!defined($blob) || $blob ne $oid); # continue;
+ @$res = ($smsg->{num}, $smsg->{mid});
+ 0; # done
+}
+
+sub num_mid0_for_oid {
+ my ($self, $oid, $mid) = @_;
+ my $res = [];
+ begin_lazy($self);
+ each_by_mid($self, $mid, ['ddd'], \&_num_mid0_for_oid, $oid, $res);
+ @$res, # ($num, $mid0);
}
sub create_tables {
tid INTEGER NOT NULL,
sid INTEGER,
ts INTEGER,
+ ds INTEGER,
ddd VARBINARY, /* doc-data-deflated */
UNIQUE (num)
)
$dbh->do('CREATE INDEX IF NOT EXISTS idx_tid ON over (tid)');
$dbh->do('CREATE INDEX IF NOT EXISTS idx_sid ON over (sid)');
$dbh->do('CREATE INDEX IF NOT EXISTS idx_ts ON over (ts)');
+ $dbh->do('CREATE INDEX IF NOT EXISTS idx_ds ON over (ds)');
$dbh->do(<<'');
CREATE TABLE IF NOT EXISTS counter (
sub disconnect {
my ($self) = @_;
die "in transaction" if $self->{txn};
- $self->{dbh} = undef;
+ $self->SUPER::disconnect;
}
sub create {