added common BackupPC::Search::host_backup_nums
[BackupPC.git] / bin / BackupPC_ASA_SearchUpdate
1 #!/usr/bin/perl
2
3 use strict;
4 use lib "/usr/local/BackupPC/lib";
5
6 use DBI;
7 use BackupPC::Lib;
8 use BackupPC::View;
9 use Data::Dumper;
10 use Getopt::Long::Descriptive;
11 use Time::HiRes qw/time/;
12 use File::Pid;
13 use POSIX qw/strftime/;
14 use BackupPC::Search;
15 use Cwd qw/abs_path/;
16 use Data::Dump qw(dump);
17
18 use constant BPC_FTYPE_DIR => 5;
19 use constant EST_CHUNK => 4096;
20
21 # daylight saving time change offset for 1h
22 my $dst_offset = 60 * 60;
23
24 my $debug = 0;
25 $|=1;
26
27 my $start_t = time();
28
29 my $pid_path = abs_path($0);
30 $pid_path =~ s/\W+/_/g;
31
32 my $pidfile = new File::Pid({
33         file => "/tmp/search_update.pid",
34 });
35
36 if (my $pid = $pidfile->running ) {
37         die "$0 already running: $pid\n";
38 } elsif ($pidfile->pid ne $$) {
39         $pidfile->remove;
40         $pidfile = new File::Pid;
41 }
42 print STDERR "$0 using pid ",$pidfile->pid," file ",$pidfile->file,"\n";
43 $pidfile->write;
44
45 my $t_fmt = '%Y-%m-%d %H:%M:%S';
46
47 my $hosts;
48 my $bpc = BackupPC::Lib->new || die;
49 my %Conf = $bpc->Conf();
50 my $TopDir = $bpc->TopDir();
51 my $beenThere = {};
52
53 my $dsn = $Conf{SearchDSN} || die "Need SearchDSN in config.pl\n";
54 my $user = $Conf{SearchUser} || '';
55
56 my $index_node_url = $Conf{HyperEstraierIndex};
57
58 my $dbh = DBI->connect($dsn, $user, "", { RaiseError => 1, AutoCommit => 0 });
59
60 my ($opt,$usage) = describe_options(
61 "%c %o",
62 [ 'create|c',   "create database on first use" ],
63 [ 'delete|d',   "delete database before import" ],
64 [ 'max|m=i',    "import just max increments for one host" ],
65 [ 'host|h=s@',  "import just host(s)" ],
66 [],
67 [ 'verbose|v:i', 'set verbosity (debug) level' ],
68 [ 'index|i',    'update full text index' ],
69 [ 'junk|j',     "update full text, don't check existing files" ],
70 [ 'fast|f',     "don't do anything with full text index" ],
71 [ 'quiet|q',    "be quiet for hosts without changes" ],
72 [ 'help',       "show help" ],
73 );
74
75 print($usage->text), exit if $opt->help;
76
77 warn "hosts: ",dump( $opt->host );
78
79 #---- subs ----
80
81 sub status {
82         my $text = shift;
83         $text =~ s{\s+$}{};
84         my $new = $0;
85         $new =~ s{^[\w\/]+/(\w+) }{$1 }; # strip path from process name
86         if ( $text =~ m/^\|/ ) {
87                 $new =~ s/\|.*/$text/ or $new .= " $text";
88         } else {
89                 $new =~ s/\s+.*/ $text/ or $new .= " $text";
90         }
91         $0 = $new;
92 }
93
94 sub fmt_time {
95         my $t = shift || return;
96         my $out = "";
97         my ($ss,$mm,$hh) = gmtime($t);
98         $out .= "${hh}h" if ($hh);
99         $out .= sprintf("%02d:%02d", $mm,$ss);
100         return $out;
101 }
102
103 sub curr_time {
104         return strftime($t_fmt,localtime());
105 }
106
107 sub hest_update {
108
109         my ($host_id, $share_id, $num) = @_;
110
111         my $skip_check = $opt->junk && print STDERR "Skipping check for existing files -- this should be used only with initital import\n";
112
113         print curr_time," updating fulltext:";
114
115         my $t = time();
116
117         my $offset = 0;
118         my $added = 0;
119
120         my $search = BackupPC::Search->search_module;
121
122         my $results = 0;
123
124         do {
125
126                 my $where = '';
127                 my @data;
128                 if (defined($host_id) && defined($share_id) && defined($num)) {
129                         $where = qq{
130                         WHERE
131                                 hosts.id = ? AND
132                                 shares.id = ? AND
133                                 files.backupnum = ?
134                         };
135                         @data = ( $host_id, $share_id, $num );
136                 }
137
138                 my $limit = sprintf('LIMIT '.EST_CHUNK.' OFFSET %d', $offset);
139
140                 my $sth = $dbh->prepare(qq{
141                         SELECT
142                                 files.id                        AS fid,
143                                 hosts.name                      AS hname,
144                                 shares.name                     AS sname,
145                                 -- shares.share                 AS sharename,
146                                 files.backupnum                 AS backupnum,
147                                 -- files.name                   AS filename,
148                                 files.path                      AS filepath,
149                                 files.date                      AS date,
150                                 files.type                      AS type,
151                                 files.size                      AS size,
152                                 files.shareid                   AS shareid,
153                                 backups.date                    AS backup_date
154                         FROM files 
155                                 INNER JOIN shares       ON files.shareID=shares.ID
156                                 INNER JOIN hosts        ON hosts.ID = shares.hostID
157                                 INNER JOIN backups      ON backups.num = files.backupNum and backups.hostID = hosts.ID AND backups.shareID = shares.ID
158                         $where
159                         $limit
160                 });
161
162                 $sth->execute(@data);
163                 $results = $sth->rows;
164
165                 if ($results == 0) {
166                         print " - no new files\n";
167                         return;
168                 } else {
169                         print "...";
170                 }
171
172                 sub fmt_date {
173                         my $t = shift || return;
174                         my $iso = BackupPC::Lib::timeStamp($t);
175                         $iso =~ s/\s/T/;
176                         return $iso;
177                 }
178
179                 while (my $row = $sth->fetchrow_hashref()) {
180                         next if $search->exists( $row );
181                         $search->add_doc( $row );
182                         $added++;
183                 }
184
185                 print "$added";
186                 status "| $added";
187
188                 $offset += EST_CHUNK;
189
190         } while ($results == EST_CHUNK);
191
192         $search->commit;
193
194         my $dur = (time() - $t) || 1;
195         printf(" [%.2f/s dur: %s]\n",
196                 ( $added / $dur ),
197                 fmt_time($dur)
198         );
199 }
200
201 #---- /subs ----
202
203
204 ## update index ##
205 if ( ( $opt->index || $opt->junk ) && !$opt->create ) {
206         # update all
207         print "force update of Hyper Estraier index ";
208         print "by -i flag" if ($opt->index);
209         print "by -j flag" if ($opt->junk);
210         print "\n";
211         hest_update();
212 }
213
214 ## create tables ##
215 if ($opt->create) {
216         sub do_index {
217                 my $index = shift || return;
218                 my ($table,$col,$unique) = split(/:/, $index);
219                 $unique ||= '';
220                 $index =~ s/\W+/_/g;
221                 print "$index on $table($col)" . ( $unique ? "u" : "" ) . " ";
222                 $dbh->do(qq{ create $unique index $index on $table($col) });
223         }
224
225         print "creating tables...\n";
226
227         my $sql;
228         { local $/ = undef; $sql = <DATA> };
229         $dbh->do( $sql );
230
231         print "creating indexes: ";
232
233         foreach my $index (qw(
234                 hosts:name
235                 backups:hostID
236                 backups:num
237                 backups:shareID
238                 shares:hostID
239                 shares:name
240                 files:shareID
241                 files:path
242                 files:name
243                 files:date
244                 files:size
245                 archive:dvd_nr
246                 archive_burned:archive_id
247                 backup_parts:backup_id,part_nr:unique
248         )) {
249                 do_index($index);
250         }
251
252         print "...\n";
253
254         $dbh->commit;
255
256 }
257
258 ## delete data before inseting ##
259 if ($opt->delete) {
260         print "deleting ";
261         foreach my $table (qw(files dvds backups shares hosts)) {
262                 print "$table ";
263                 $dbh->do(qq{ DELETE FROM $table });
264         }
265         print " done...\n";
266
267         $dbh->commit;
268 }
269
270 ## insert new values ##
271
272 # get hosts
273 $hosts = $bpc->HostInfoRead();
274 my $hostID;
275 my $shareID;
276
277 my $sth;
278
279 $sth->{insert_hosts} = $dbh->prepare(qq{
280 INSERT INTO hosts (name, IP) VALUES (?,?)
281 });
282
283 $sth->{hosts_by_name} = $dbh->prepare(qq{
284 SELECT id FROM hosts WHERE name=?
285 });
286
287 $sth->{backups_count} = $dbh->prepare(qq{
288 SELECT COUNT(*)
289 FROM backups
290 WHERE hostID=? AND num=? AND shareid=?
291 });
292
293 $sth->{insert_backups} = $dbh->prepare(qq{
294 INSERT INTO backups (hostID, num, date, type, shareid, size)
295 VALUES (?,?,?,?,?,-1)
296 });
297
298 $sth->{update_backups_size} = $dbh->prepare(qq{
299 UPDATE backups SET size = ?
300 WHERE hostID = ? and num = ? and date = ? and type =? and shareid = ?
301 });
302
303 $sth->{insert_files} = $dbh->prepare(qq{
304 INSERT INTO files
305         (shareID, backupNum, name, path, date, type, size)
306         VALUES (?,?,?,?,?,?,?)
307 });
308
309 my @hosts = keys %{$hosts};
310 my $host_nr = 0;
311
312 foreach my $host_key (@hosts) {
313
314         my $hostname = $hosts->{$host_key}->{'host'} || die "can't find host for $host_key";
315         $hostname = lc $hostname;
316
317         next if $opt->host && ! grep { m/^$hostname$/i } @{ $opt->host };
318
319         $sth->{hosts_by_name}->execute($hostname);
320
321         unless (($hostID) = $sth->{hosts_by_name}->fetchrow_array()) {
322                 $sth->{insert_hosts}->execute(
323                         $hostname,
324                         $hosts->{$host_key}->{'ip'}
325                 );
326
327                 $hostID = $dbh->last_insert_id(undef,undef,'hosts',undef);
328         }
329
330         $host_nr++;
331         # get backups for a host
332         my @backups = $bpc->BackupInfoRead($hostname);
333         my $incs = scalar @backups;
334
335         my $host_header = sprintf("host %s [%d/%d]: %d increments\n",
336                 $hosts->{$host_key}->{'host'},
337                 $host_nr,
338                 ($#hosts + 1),
339                 $incs
340         );
341         print $host_header unless $opt->quiet;
342  
343         my $inc_nr = 0;
344         $beenThere = {};
345
346         foreach my $backup (@backups) {
347
348                 $inc_nr++;
349                 last if defined $opt->max && $inc_nr > $opt->max;
350
351                 my $backupNum = $backup->{'num'};
352                 my @backupShares = ();
353
354                 my $share_header = sprintf("%-10s %2d/%-2d #%-2d %s %5s/%5s files (date: %s dur: %s)\n", 
355                         $hosts->{$host_key}->{'host'},
356                         $inc_nr, $incs, $backupNum, 
357                         $backup->{type} || '?',
358                         $backup->{nFilesNew} || '?', $backup->{nFiles} || '?',
359                         strftime($t_fmt,localtime($backup->{startTime})),
360                         fmt_time($backup->{endTime} - $backup->{startTime})
361                 );
362                 print $share_header unless $opt->quiet;
363                 status "$hostname $backupNum $share_header";
364
365                 my $files = BackupPC::View->new($bpc, $hostname, \@backups, { only_increment => 1 });
366
367                 foreach my $share ($files->shareList($backupNum)) {
368
369                         my $t = time();
370
371                         $shareID = getShareID($share, $hostID, $hostname);
372                 
373                         $sth->{backups_count}->execute($hostID, $backupNum, $shareID);
374                         my ($count) = $sth->{backups_count}->fetchrow_array();
375                         # skip if allready in database!
376                         next if ($count > 0);
377
378                         # dump host and share header for -q
379                         if ( $opt->quiet ) {
380                                 if ($host_header) {
381                                         print $host_header;
382                                         $host_header = undef;
383                                 }
384                                 print $share_header;
385                         }
386
387                         # dump some log
388                         print curr_time," ", $share;
389
390                         $sth->{insert_backups}->execute(
391                                 $hostID,
392                                 $backupNum,
393                                 $backup->{'endTime'},
394                                 substr($backup->{'type'},0,4),
395                                 $shareID,
396                         );
397
398                         my ($f, $nf, $d, $nd, $size) = recurseDir($bpc, $hostname, $files, $backupNum, $share, "", $shareID);
399
400                         eval {
401                                 $sth->{update_backups_size}->execute(
402                                         $size,
403                                         $hostID,
404                                         $backupNum,
405                                         $backup->{'endTime'},
406                                         substr($backup->{'type'},0,4),
407                                         $shareID,
408                                 );
409                                 print " commit";
410                                 $dbh->commit();
411                         };
412                         if ($@) {
413                                 print " rollback";
414                                 $dbh->rollback();
415                         }
416
417                         my $dur = (time() - $t) || 1;
418                         my $status = sprintf("%d/%d files %d/%d dirs %0.2f MB [%.2f/s dur: %s]",
419                                 $nf, $f, $nd, $d,
420                                 ($size / 1024 / 1024),
421                                 ( ($f+$d) / $dur ),
422                                 fmt_time($dur)
423                         );
424                         print " $status\n";
425                         status "$hostname $backupNum $status";
426
427                         if ($nf + $nd > 0) {
428                                 status "$hostname $backupNum full-text | indexing";
429                                 #eval { hest_update($hostID, $shareID, $backupNum) };
430                                 #warn "ERROR: $@" if $@;
431                                 hest_update($hostID, $shareID, $backupNum);
432                                 # eval breaks our re-try logic
433                         }
434                 }
435
436         }
437 }
438 undef $sth;
439 $dbh->commit();
440 $dbh->disconnect();
441
442 print "total duration: ",fmt_time(time() - $start_t),"\n";
443
444 $pidfile->remove;
445
446 sub getShareID() {
447
448         my ($share, $hostID, $hostname) = @_;
449
450         $sth->{share_id} ||= $dbh->prepare(qq{
451                 SELECT ID FROM shares WHERE hostID=? AND name=?
452         });
453
454         $sth->{share_id}->execute($hostID,$share);
455
456         my ($id) = $sth->{share_id}->fetchrow_array();
457
458         return $id if (defined($id));
459
460         $sth->{insert_share} ||= $dbh->prepare(qq{
461                 INSERT INTO shares 
462                         (hostID,name,share) 
463                 VALUES (?,?,?)
464         });
465
466         my $drop_down = $hostname . '/' . $share;
467         $drop_down =~ s#//+#/#g;
468
469         $sth->{insert_share}->execute($hostID,$share, $drop_down);
470         return $dbh->last_insert_id(undef,undef,'shares',undef);
471 }
472
473 sub found_in_db {
474
475         my @data = @_;
476         shift @data;
477
478         my ($key, $shareID,undef,$name,$path,$date,undef,$size) = @_;
479
480         return $beenThere->{$key} if (defined($beenThere->{$key}));
481
482         $sth->{file_in_db} ||= $dbh->prepare(qq{
483                 SELECT 1 FROM files
484                 WHERE shareID = ? and
485                         path = ? and 
486                         size = ? and
487                         ( date = ? or date = ? or date = ? )
488                 LIMIT 1
489         });
490
491         my @param = ($shareID,$path,$size,$date, $date-$dst_offset, $date+$dst_offset);
492         $sth->{file_in_db}->execute(@param);
493         my $rows = $sth->{file_in_db}->rows;
494         print STDERR "## found_in_db($shareID,$path,$date,$size) ",( $rows ? '+' : '-' ), join(" ",@param), "\n" if ($debug >= 3);
495
496         $beenThere->{$key}++;
497
498         $sth->{'insert_files'}->execute(@data) unless ($rows);
499         return $rows;
500 }
501
502 ####################################################
503 # recursing through filesystem structure and       #
504 # and returning flattened files list               #
505 ####################################################
506 sub recurseDir($$$$$$$$) {
507
508         my ($bpc, $hostname, $files, $backupNum, $share, $dir, $shareID) = @_;
509
510         print STDERR "\nrecurse($hostname,$backupNum,$share,$dir,$shareID)\n" if ($debug >= 1);
511
512         my ($nr_files, $new_files, $nr_dirs, $new_dirs, $size) = (0,0,0,0,0);
513
514         { # scope
515                 my @stack;
516
517                 print STDERR "# dirAttrib($backupNum, $share, $dir)\n" if ($debug >= 2);
518                 my $filesInBackup = $files->dirAttrib($backupNum, $share, $dir);
519
520                 # first, add all the entries in current directory
521                 foreach my $path_key (keys %{$filesInBackup}) {
522                         print STDERR "# file ",Dumper($filesInBackup->{$path_key}),"\n" if ($debug >= 3);
523                         my @data = (
524                                 $shareID,
525                                 $backupNum,
526                                 $path_key,
527                                 $filesInBackup->{$path_key}->{'relPath'},
528                                 $filesInBackup->{$path_key}->{'mtime'},
529                                 $filesInBackup->{$path_key}->{'type'},
530                                 $filesInBackup->{$path_key}->{'size'}
531                         );
532
533                         my $key = join(" ", (
534                                 $shareID,
535                                 $dir,
536                                 $path_key,
537                                 $filesInBackup->{$path_key}->{'mtime'},
538                                 $filesInBackup->{$path_key}->{'size'}
539                         ));
540
541                         my $key_dst_prev = join(" ", (
542                                 $shareID,
543                                 $dir,
544                                 $path_key,
545                                 $filesInBackup->{$path_key}->{'mtime'} - $dst_offset,
546                                 $filesInBackup->{$path_key}->{'size'}
547                         ));
548
549                         my $key_dst_next = join(" ", (
550                                 $shareID,
551                                 $dir,
552                                 $path_key,
553                                 $filesInBackup->{$path_key}->{'mtime'} + $dst_offset,
554                                 $filesInBackup->{$path_key}->{'size'}
555                         ));
556
557                         my $found;
558                         if (
559                                 ! defined($beenThere->{$key}) &&
560                                 ! defined($beenThere->{$key_dst_prev}) &&
561                                 ! defined($beenThere->{$key_dst_next}) &&
562                                 ! ($found = found_in_db($key, @data))
563                         ) {
564                                 print STDERR "# key: $key [", $beenThere->{$key},"]" if ($debug >= 2);
565
566                                 if ($filesInBackup->{$path_key}->{'type'} == BPC_FTYPE_DIR) {
567                                         $new_dirs++ unless ($found);
568                                         print STDERR " dir\n" if ($debug >= 2);
569                                 } else {
570                                         $new_files++ unless ($found);
571                                         print STDERR " file\n" if ($debug >= 2);
572                                 }
573                                 $size += $filesInBackup->{$path_key}->{'size'} || 0;
574                         }
575
576                         if ($filesInBackup->{$path_key}->{'type'} == BPC_FTYPE_DIR) {
577                                 $nr_dirs++;
578
579                                 my $full_path = $dir . '/' . $path_key;
580                                 push @stack, $full_path;
581                                 print STDERR "### store to stack: $full_path\n" if ($debug >= 3);
582
583 #                               my ($f,$nf,$d,$nd) = recurseDir($bpc, $hostname, $backups, $backupNum, $share, $path_key, $shareID) unless ($beenThere->{$key});
584 #
585 #                               $nr_files += $f;
586 #                               $new_files += $nf;
587 #                               $nr_dirs += $d;
588 #                               $new_dirs += $nd;
589
590                         } else {
591                                 $nr_files++;
592                         }
593                 }
594
595                 print STDERR "## STACK ",join(", ", @stack),"\n" if ($debug >= 2);
596
597                 while ( my $dir = shift @stack ) {
598                         my ($f,$nf,$d,$nd, $s) = recurseDir($bpc, $hostname, $files, $backupNum, $share, $dir, $shareID);
599                         print STDERR "# $dir f: $f nf: $nf d: $d nd: $nd\n" if ($debug >= 1);
600                         $nr_files += $f;
601                         $new_files += $nf;
602                         $nr_dirs += $d;
603                         $new_dirs += $nd;
604                         $size += $s;
605                 }
606         }
607
608         return ($nr_files, $new_files, $nr_dirs, $new_dirs, $size);
609 }
610
611 __DATA__
612
613 create table hosts (
614         ID      SERIAL          PRIMARY KEY,
615         name    VARCHAR(30)     NOT NULL,
616         IP      VARCHAR(15)
617 );            
618
619 create table shares (
620         ID      SERIAL          PRIMARY KEY,
621         hostID  INTEGER         NOT NULL references hosts(id),
622         name    VARCHAR(30)     NOT NULL,
623         share   VARCHAR(200)    NOT NULL
624 );            
625
626 create table dvds (
627         ID      SERIAL          PRIMARY KEY, 
628         num     INTEGER         NOT NULL,
629         name    VARCHAR(255)    NOT NULL,
630         mjesto  VARCHAR(255)
631 );
632
633 create table backups (
634         id      serial,
635         hostID  INTEGER         NOT NULL references hosts(id),
636         num     INTEGER         NOT NULL,
637         date    integer         NOT NULL, 
638         type    CHAR(4)         not null,
639         shareID integer         not null references shares(id),
640         size    bigint          not null,
641         inc_size bigint         not null default -1,
642         inc_deleted boolean     default false,
643         parts   integer         not null default 0,
644         PRIMARY KEY(id)
645 );            
646
647 create table backup_parts (
648         id serial,
649         backup_id int references backups(id),
650         part_nr int not null check (part_nr > 0),
651         tar_size bigint not null check (tar_size > 0),
652         size bigint not null check (size > 0),
653         md5 text not null,
654         items int not null check (items > 0),
655         date timestamp default now(),
656         filename text not null,
657         primary key(id)
658 );
659
660 create table files (
661         ID              SERIAL,
662         shareID         INTEGER NOT NULL references shares(id),
663         backupNum       INTEGER NOT NULL,
664         name            VARCHAR(255) NOT NULL,
665         path            VARCHAR(255) NOT NULL,
666         date            integer NOT NULL,
667         type            INTEGER NOT NULL,
668         size            bigint  NOT NULL,
669         primary key(id)
670 );
671
672 create sequence dvd_nr;
673
674 create table archive (
675         id              serial,
676         dvd_nr          int not null,
677         total_size      bigint default -1,
678         note            text,
679         username        varchar(20) not null,
680         date            timestamp default now(),
681         primary key(id)
682 );      
683
684 create table archive_parts (
685         archive_id      int not null references archive(id) on delete cascade,
686         backup_part_id  int not null references backup_parts(id),
687         primary key(archive_id, backup_part_id)
688 );
689
690 create table archive_burned (
691         archive_id      int references archive(id),
692         date            timestamp default now(),
693         part            int not null default 1,
694         copy            int not null default 1,
695         iso_size bigint default -1
696 );
697
698 -- report backups and corresponding dvd
699
700 --create view backups_on_dvds as
701 --select
702 --      backups.id as id,
703 --      hosts.name || ':' || shares.name as share,
704 --      backups.num as num,
705 --      backups.type as type,
706 --      abstime(backups.date) as backup_date,
707 --      backups.size as size,
708 --      backups.inc_size as gzip_size,
709 --      archive.id as archive_id,
710 --      archive.dvd_nr
711 --from backups
712 --join shares on backups.shareid=shares.id
713 --join hosts on shares.hostid = hosts.id
714 --left outer join archive_backup_parts on backups.id = archive_backup_parts.backup_id
715 --left outer join archive on archive_backup_parts.archive_id = archive.id
716 --where backups.parts > 0 and size > 0
717 --order by backups.date
718 --;
719
720
721 -- used by BackupPC_ASA_BurnArchiveMedia
722 CREATE VIEW archive_backup_parts AS
723 SELECT
724         backup_parts.backup_id,
725         archive_id,
726         dvd_nr,
727         backup_part_id,
728         hosts.name as host,
729         shares.name as share,
730         backups.num as num,
731         backups.date as date,
732         backup_parts.part_nr as part_nr,
733         backups.parts as parts,
734         backup_parts.size as size,
735         backup_parts.md5 as md5,
736         backup_parts.items,
737         backup_parts.filename
738 FROM backup_parts
739 JOIN archive_parts ON backup_parts.id = backup_part_id
740 JOIN archive       ON archive_id = archive.id
741 JOIN backups       ON backup_id = backups.id
742 JOIN hosts         ON hostid = hosts.id
743 JOIN shares        ON shareid = shares.id
744 ;
745
746
747 CREATE VIEW backups_burned AS
748 SELECT backup_parts.backup_id,
749 count(backup_parts.backup_id) as backup_parts,
750 count(archive_burned.archive_id) AS burned_parts,
751 count(backup_parts.backup_id) = count(archive_burned.archive_id) as burned
752    FROM backup_parts 
753    left outer JOIN archive_parts ON backup_part_id = backup_parts.id
754    left join archive on archive.id = archive_id
755    left outer join archive_burned on archive_burned.archive_id = archive.id
756   GROUP BY backup_parts.backup_id ;
757
758
759 -- triggers for backup_parts consistency
760 create or replace function backup_parts_check() returns trigger as '
761 declare
762         b_parts integer;
763         b_counted integer;
764         b_id    integer;
765 begin
766         -- raise notice ''old/new parts %/% backup_id %/%'', old.parts, new.parts, old.id, new.id;
767         if (TG_OP=''UPDATE'') then
768                 b_id := new.id;
769                 b_parts := new.parts;
770         elsif (TG_OP = ''INSERT'') then
771                 b_id := new.id;
772                 b_parts := new.parts;
773         end if;
774         b_counted := (select count(*) from backup_parts where backup_id = b_id);
775         -- raise notice ''backup % parts %'', b_id, b_parts;
776         if ( b_parts != b_counted ) then
777                 raise exception ''Update of backup % aborted, requested % parts and there are really % parts'', b_id, b_parts, b_counted;
778         end if;
779         return null;
780 end;
781 ' language plpgsql;
782
783 create trigger do_backup_parts_check
784         after insert or update or delete on backups
785         for each row execute procedure backup_parts_check();
786
787 create or replace function backup_backup_parts_check() returns trigger as '
788 declare
789         b_id            integer;
790         my_part_nr      integer;
791         calc_part       integer;
792 begin
793         if (TG_OP = ''INSERT'') then
794                 -- raise notice ''trigger: % backup_id %'', TG_OP, new.backup_id;
795                 b_id = new.backup_id;
796                 my_part_nr = new.part_nr;
797                 execute ''update backups set parts = parts + 1 where id = '' || b_id;
798         elsif (TG_OP = ''DELETE'') then
799                 -- raise notice ''trigger: % backup_id %'', TG_OP, old.backup_id;
800                 b_id = old.backup_id;
801                 my_part_nr = old.part_nr;
802                 execute ''update backups set parts = parts - 1 where id = '' || b_id;
803         end if;
804         calc_part := (select count(part_nr) from backup_parts where backup_id = b_id);
805         if ( my_part_nr != calc_part ) then
806                 raise exception ''Update of backup_parts with backup_id % aborted, requested part_nr is % and calulated next is %'', b_id, my_part_nr, calc_part;
807         end if;
808         return null;
809 end;
810 ' language plpgsql;
811
812 create trigger do_backup_backup_parts_check
813         after insert or update or delete on backup_parts
814         for each row execute procedure backup_backup_parts_check();
815