lib/ID3FS/DB.pm

   1 package ID3FS::DB;
   2
   3 use strict;
   4 use warnings;
   5 use DBI;
   6 use ID3FS::File;
   7
   8 our $SCHEMA_VERSION=1;
   9 my $dbfile=".id3fs";
  10
  11 sub new
  12 {
  13     my $proto=shift;
  14     my $class=ref($proto) || $proto;
  15     my $self={};
  16     bless($self,$class);
  17
  18     my($dir, $init, $me)=@_;
  19     $self->{dbpath}="$dir/$dbfile";
  20     $self->{me}=$me;
  21
  22     my $exists=-f $self->{dbpath};
  23
  24     $self->{postgres}=0;
  25
  26     unless($self->{postgres})
  27     {
  28         die("$me: $self->{dbpath}: not found. use --init to create.\n") if(!$exists && !$init);
  29         die("$me: --init used but $self->{dbpath} exists.\n")           if($exists && $init);
  30     }
  31
  32     my $connectstr="dbi:SQLite:dbname=$self->{dbpath}";
  33     my ($user, $pass)=("", "");
  34     if($self->{postgres})
  35     {
  36         $connectstr="dbi:Pg:dbname=id3fs";
  37         $user="ianb";
  38         $pass="foo";
  39     }
  40     $self->{dbh}=DBI->connect($connectstr, $user, $pass,
  41                               { AutoCommit=>1 } );
  42     unless(defined($self->{dbh}))
  43     {
  44         die("$me: DB Error: " . $DBI::errstr . "\n");
  45     }
  46
  47     if($init)
  48     {
  49         $self->create();
  50     }
  51     else
  52     {
  53         $self->checkschema();
  54     }
  55
  56     return $self;
  57 }
  58
  59 sub create
  60 {
  61     my($self,$name)=@_;
  62     my @schema=split(/\n\n/,join("", <DATA>));
  63     close(DATA);
  64     for my $cmd (@schema)
  65     {
  66         $self->{dbh}->do($cmd);
  67     }
  68     if($self->{postgres})
  69     {
  70         $self->cmd("CREATE SEQUENCE seq");
  71     }
  72     $self->cmd("INSERT INTO id3fs (schema_version) VALUES (?)", $SCHEMA_VERSION);
  73 }
  74
  75 sub checkschema
  76 {
  77     my $self=shift;
  78     my ($version)=$self->cmd_onerow("SELECT schema_version from id3fs");
  79     if(!defined($version) || $version != $SCHEMA_VERSION)
  80     {
  81         die("$self->{me}: id3fs database version " .
  82             defined($version) ? $version : '""' .
  83             "not known, current version is $SCHEMA_VERSION.\n");
  84     }
  85 }
  86
  87 sub cmd_sth
  88 {
  89     my($self, $sql, @params)=@_;
  90     my $sth=$self->{dbh}->prepare($sql);
  91     my $idx=1;
  92     for my $param (@params)
  93     {
  94         $param="" unless(defined($param));
  95         $sth->bind_param($idx++, $param);
  96     }
  97     $sth->execute();
  98     return $sth;
  99 }
 100
 101 sub tags
 102 {
 103     my($self, @constraints)=@_;
 104     if(!@constraints) # /
 105     {
 106         my $sql="SELECT DISTINCT name FROM tags;";
 107         my $tags=$self->cmd_rows($sql);
 108         return(map { $_->[0]; } @$tags);
 109     }
 110     my @file_ids=();
 111     my @tag_ids=();
 112     my $main_sql_start=("SELECT tags.name FROM files\n" .
 113                         "  INNER JOIN files_x_tags fxt1 ON files.id=fxt1.files_id\n" .
 114                         "  INNER JOIN files_x_tags fxt2 ON files.id=fxt2.files_id\n" .
 115                         "  INNER JOIN tags ON tags.id=fxt2.tags_id\n" .
 116                         "  WHERE fxt1.tags_id IN \n\t(");
 117     my $main_sql_mid=")\n\tAND fxt2.tags_id NOT IN \n\t(";
 118     my $main_sql_end=")\n  GROUP BY tags.name;";
 119     while(my $constraint=shift @constraints)
 120     {
 121         print "CONSTRAINT: $constraint->{name}\n";
 122         my $cid=$constraint->{id};
 123         push(@tag_ids, $cid);
 124     }
 125     @tag_ids = map( { "\"$_\""; } @tag_ids) unless($self->{postgres});
 126     my $tagstr=join(", ", @tag_ids);
 127     my $sql = ($main_sql_start . $tagstr .
 128                $main_sql_mid   . $tagstr .
 129                $main_sql_end);
 130     print "SQL: $sql\n";
 131     my $result=$self->cmd_rows($sql);
 132     my @tagnames=map { $_->[0]; } @$result;
 133     print "SUBNAMES: ", join(', ', @tagnames), "\n";
 134     return(@tagnames);
 135 }
 136
 137 sub tag_values
 138 {
 139     my($self, $tag)=@_;
 140     my $sql=("SELECT DISTINCT tagvals.name FROM tags\n" .
 141              "INNER JOIN tags_x_tagvals ON tags.id=tags_x_tagvals.tags_id\n" .
 142              "INNER JOIN tagvals ON tagvals.id=tags_x_tagvals.tagvals_id\n" .
 143              "WHERE tags.name=?");
 144     my $tags=$self->cmd_rows($sql, $tag);
 145     return(map { $_->[0]; } @$tags);
 146 }
 147
 148 sub tag_id
 149 {
 150     my($self, $tag)=@_;
 151     my $sql='SELECT id FROM tags WHERE name=?';
 152     my ($id)=$self->cmd_onerow($sql, $tag);
 153     return($id);
 154 }
 155
 156 sub add
 157 {
 158     my($self,$path)=@_;
 159     my $file=ID3FS::File->new($path);
 160     return unless(defined($file));
 161     my $artist=$file->artist();
 162     my $album=$file->album();
 163     my $v1genre=$file->v1genre();
 164     my $year=$file->year();
 165     my $audiotype=$file->album();
 166     my $tags=$file->tags();
 167     my $haspic=$file->haspic();
 168
 169     my $file_id=$self->add_to_table("files", $path);
 170     my $artists_id=$self->add_to_table("artists",  $artist);
 171     my $albums_id=$self->add_to_table("albums",  $album);
 172     for my $tag (keys %$tags)
 173     {
 174         $self->add_tag($file_id, $tag, $tags->{$tag});
 175     }
 176
 177     if($self->ok($year))
 178     {
 179         $self->add_tag($file_id, "year", $year);
 180         if($year=~/^(\d\d\d)\d$/)
 181         {
 182             $self->add_tag($file_id, "decade", "${1}0s");
 183         }
 184     }
 185     if($self->ok($v1genre))
 186     {
 187         $self->add_tag($file_id, "v1genre", $v1genre);
 188     }
 189
 190     if($haspic)
 191     {
 192         $self->add_tag($file_id, "haspic", undef);
 193     }
 194
 195     $self->add_relation("files_x_artists",
 196                         { "files_id" => $file_id,
 197                           "artists_id" => $artists_id });
 198
 199     $self->add_relation("artists_x_albums",
 200                       { "artists_id" => $artists_id,
 201                         "albums_id" => $albums_id});
 202 }
 203
 204 sub add_tag
 205 {
 206     my($self, $file_id, $tag, $val)=@_;
 207     my $tag_id=$self->add_to_table("tags",  $tag);
 208     $self->add_relation("files_x_tags",
 209                         { "files_id" => $file_id,
 210                           "tags_id"  => $tag_id });
 211     if(defined($val))
 212     {
 213         my $val_id=$self->add_to_table("tagvals", $val);
 214         $self->add_relation("tags_x_tagvals",
 215                             { "tags_id"     => $tag_id,
 216                               "tagvals_id"  => $val_id });
 217     }
 218 }
 219
 220 sub add_to_table
 221 {
 222     my($self, $table, $name, $extradata)=@_;
 223     my $id=$self->lookup_id($table, $name);
 224     unless(defined($id))
 225     {
 226         my $sql="INSERT INTO $table (";
 227         $sql .= "id, " if($self->{postgres});
 228         my @fields=qw(name);
 229         if(defined($extradata))
 230         {
 231             push(@fields, sort keys(%$extradata));
 232         }
 233         $sql .= join(", ", @fields);
 234         $sql .=") VALUES (";
 235         $sql .=") nextval('seq'), " if($self->{postgres});
 236         $sql .= join(", ", map { "?"; } @fields);
 237         $sql .= ");";
 238         $id=$self->cmd_id($sql, $name, map { $extradata->{$_} || ""; } sort keys %$extradata);
 239     }
 240     return $id;
 241 }
 242
 243 sub add_relation
 244 {
 245     my ($self, $relname, $fields)=@_;
 246     return if($self->relation_exists($relname, $fields));
 247     my $sql="INSERT INTO $relname (";
 248     $sql .= join(", ", sort keys(%$fields));
 249     $sql .= ") VALUES (";
 250     $sql .= join(", ", map { "?"; } sort keys(%$fields));
 251     $sql .= ");";
 252     $self->cmd($sql, map { $fields->{$_}; } sort keys(%$fields));
 253 }
 254
 255 sub lookup_id
 256 {
 257     my($self, $table, $name)=@_;
 258     my($id)=$self->cmd_onerow("SELECT id FROM $table where name=?", $name);
 259     return $id;
 260 }
 261
 262 sub relation_exists
 263 {
 264     my ($self, $relname, $fields)=@_;
 265     my $sql="SELECT count(1) FROM $relname WHERE ";
 266     my @exprs=();
 267     my @vals=();
 268     for my $field (keys %$fields)
 269     {
 270         push(@exprs,$field);
 271         push(@vals,$fields->{$field});
 272     }
 273     $sql .= join(' AND ', map { "$_=?"; } @exprs);
 274     my ($ret)=$self->cmd_onerow($sql, @vals);
 275     return $ret;
 276 }
 277
 278 sub ok
 279 {
 280     my($self, $thing)=@_;
 281     return(defined($thing) && length($thing));
 282 }
 283
 284 sub cmd
 285 {
 286     my ($self, @args)=@_;
 287     # don't care about retcode
 288     $self->cmd_sth(@args);
 289 }
 290
 291 sub cmd_onerow
 292 {
 293     my ($self, @args)=@_;
 294     my $sth=$self->cmd_sth(@args);
 295     return($sth->fetchrow_array());
 296 }
 297
 298 sub cmd_rows
 299 {
 300     my ($self, @args)=@_;
 301     my $sth=$self->cmd_sth(@args);
 302     return $sth->fetchall_arrayref();
 303 }
 304
 305 sub cmd_id
 306 {
 307     my ($self, @args)=@_;
 308     $self->cmd_sth(@args);
 309     return($self->last_insert_id());
 310 }
 311
 312 sub last_insert_id
 313 {
 314     my $self=shift;
 315     if($self->{postgres})
 316     {
 317         return $self->{dbh}->last_insert_id(undef, undef, undef, undef,
 318                                             { sequence => "seq" });
 319     }
 320     else
 321     {
 322         return $self->{dbh}->last_insert_id("","","","");
 323     }
 324 }
 325
 326 __DATA__
 327
 328 CREATE TABLE id3fs (
 329     schema_version INTEGER
 330 );
 331
 332 CREATE TABLE files (
 333     id INTEGER PRIMARY KEY,
 334     name text
 335 );
 336
 337 CREATE TABLE artists (
 338     id INTEGER PRIMARY KEY,
 339     name text
 340 );
 341
 342 CREATE TABLE albums (
 343     id INTEGER PRIMARY KEY,
 344     name text
 345 );
 346
 347 CREATE TABLE tags (
 348     id INTEGER PRIMARY KEY,
 349     name text
 350 );
 351
 352 CREATE TABLE tagvals (
 353     id INTEGER PRIMARY KEY,
 354     name text
 355 );
 356
 357 CREATE TABLE files_x_tags (
 358     files_id INTEGER,
 359     tags_id INTEGER
 360 );
 361
 362 CREATE TABLE tags_x_tagvals (
 363     tags_id INTEGER,
 364     tagvals_id INTEGER
 365 );
 366
 367 CREATE TABLE files_x_artists (
 368     files_id INTEGER,
 369     artists_id INTEGER
 370 );
 371
 372 CREATE TABLE artists_x_albums (
 373     artists_id INTEGER,
 374     albums_id INTEGER
 375 );