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 fxt2.tags_id;";
 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     my $sql = ($main_sql_start . join(", ", map { "\"$_\""; } @tag_ids) .
 126                $main_sql_mid   . join(", ", map { "\"$_\""; } @tag_ids) .
 127                $main_sql_end);
 128     print "SQL: $sql\n";
 129     my $result=$self->cmd_rows($sql);
 130     my @tagnames=map { $_->[0]; } @$result;
 131     print "SUBNAMES: ", join(', ', @tagnames), "\n";
 132     return(@tagnames);
 133 }
 134
 135 sub tag_values
 136 {
 137     my($self, $tag)=@_;
 138     my $sql=("SELECT DISTINCT tagvals.name FROM tags\n" .
 139              "INNER JOIN tags_x_tagvals ON tags.id=tags_x_tagvals.tags_id\n" .
 140              "INNER JOIN tagvals ON tagvals.id=tags_x_tagvals.tagvals_id\n" .
 141              "WHERE tags.name=?");
 142     my $tags=$self->cmd_rows($sql, $tag);
 143     return(map { $_->[0]; } @$tags);
 144 }
 145
 146 sub tag_id
 147 {
 148     my($self, $tag)=@_;
 149     my $sql='SELECT id FROM tags WHERE name=?';
 150     my ($id)=$self->cmd_onerow($sql, $tag);
 151     return($id);
 152 }
 153
 154 sub add
 155 {
 156     my($self,$path)=@_;
 157     my $file=ID3FS::File->new($path);
 158     return unless(defined($file));
 159     my $artist=$file->artist();
 160     my $album=$file->album();
 161     my $v1genre=$file->v1genre();
 162     my $year=$file->year();
 163     my $audiotype=$file->album();
 164     my $tags=$file->tags();
 165     my $haspic=$file->haspic();
 166
 167     my $file_id=$self->add_to_table("files", $path);
 168     my $artists_id=$self->add_to_table("artists",  $artist);
 169     my $albums_id=$self->add_to_table("albums",  $album);
 170     for my $tag (keys %$tags)
 171     {
 172         $self->add_tag($file_id, $tag, $tags->{$tag});
 173     }
 174
 175     if($self->ok($year))
 176     {
 177         $self->add_tag($file_id, "year", $year);
 178         if($year=~/^(\d\d\d)\d$/)
 179         {
 180             $self->add_tag($file_id, "decade", "${1}0s");
 181         }
 182     }
 183     if($self->ok($v1genre))
 184     {
 185         $self->add_tag($file_id, "v1genre", $v1genre);
 186     }
 187
 188     if($haspic)
 189     {
 190         $self->add_tag($file_id, "haspic", undef);
 191     }
 192
 193     $self->add_relation("files_x_artists",
 194                         { "files_id" => $file_id,
 195                           "artists_id" => $artists_id });
 196
 197     $self->add_relation("artists_x_albums",
 198                       { "artists_id" => $artists_id,
 199                         "albums_id" => $albums_id});
 200 }
 201
 202 sub add_tag
 203 {
 204     my($self, $file_id, $tag, $val)=@_;
 205     my $tag_id=$self->add_to_table("tags",  $tag);
 206     $self->add_relation("files_x_tags",
 207                         { "files_id" => $file_id,
 208                           "tags_id"  => $tag_id });
 209     if(defined($val))
 210     {
 211         my $val_id=$self->add_to_table("tagvals", $val);
 212         $self->add_relation("tags_x_tagvals",
 213                             { "tags_id"     => $tag_id,
 214                               "tagvals_id"  => $val_id });
 215     }
 216 }
 217
 218 sub add_to_table
 219 {
 220     my($self, $table, $name, $extradata)=@_;
 221     my $id=$self->lookup_id($table, $name);
 222     unless(defined($id))
 223     {
 224         my $sql="INSERT INTO $table (";
 225         $sql .= "id, " if($self->{postgres});
 226         my @fields=qw(name);
 227         if(defined($extradata))
 228         {
 229             push(@fields, sort keys(%$extradata));
 230         }
 231         $sql .= join(", ", @fields);
 232         $sql .=") VALUES (";
 233         $sql .=") nextval('seq'), " if($self->{postgres});
 234         $sql .= join(", ", map { "?"; } @fields);
 235         $sql .= ");";
 236         $id=$self->cmd_id($sql, $name, map { $extradata->{$_} || ""; } sort keys %$extradata);
 237     }
 238     return $id;
 239 }
 240
 241 sub add_relation
 242 {
 243     my ($self, $relname, $fields)=@_;
 244     return if($self->relation_exists($relname, $fields));
 245     my $sql="INSERT INTO $relname (";
 246     $sql .= join(", ", sort keys(%$fields));
 247     $sql .= ") VALUES (";
 248     $sql .= join(", ", map { "?"; } sort keys(%$fields));
 249     $sql .= ");";
 250     $self->cmd($sql, map { $fields->{$_}; } sort keys(%$fields));
 251 }
 252
 253 sub lookup_id
 254 {
 255     my($self, $table, $name)=@_;
 256     my($id)=$self->cmd_onerow("SELECT id FROM $table where name=?", $name);
 257     return $id;
 258 }
 259
 260 sub relation_exists
 261 {
 262     my ($self, $relname, $fields)=@_;
 263     my $sql="SELECT count(1) FROM $relname WHERE ";
 264     my @exprs=();
 265     my @vals=();
 266     for my $field (keys %$fields)
 267     {
 268         push(@exprs,$field);
 269         push(@vals,$fields->{$field});
 270     }
 271     $sql .= join(' AND ', map { "$_=?"; } @exprs);
 272     my ($ret)=$self->cmd_onerow($sql, @vals);
 273     return $ret;
 274 }
 275
 276 sub ok
 277 {
 278     my($self, $thing)=@_;
 279     return(defined($thing) && length($thing));
 280 }
 281
 282 sub cmd
 283 {
 284     my ($self, @args)=@_;
 285     # don't care about retcode
 286     $self->cmd_sth(@args);
 287 }
 288
 289 sub cmd_onerow
 290 {
 291     my ($self, @args)=@_;
 292     my $sth=$self->cmd_sth(@args);
 293     return($sth->fetchrow_array());
 294 }
 295
 296 sub cmd_rows
 297 {
 298     my ($self, @args)=@_;
 299     my $sth=$self->cmd_sth(@args);
 300     return $sth->fetchall_arrayref();
 301 }
 302
 303 sub cmd_id
 304 {
 305     my ($self, @args)=@_;
 306     $self->cmd_sth(@args);
 307     return($self->last_insert_id());
 308 }
 309
 310 sub last_insert_id
 311 {
 312     my $self=shift;
 313     if($self->{postgres})
 314     {
 315         return $self->{dbh}->last_insert_id(undef, undef, undef, undef,
 316                                             { sequence => "seq" });
 317     }
 318     else
 319     {
 320         return $self->{dbh}->last_insert_id("","","","");
 321     }
 322 }
 323
 324 __DATA__
 325
 326 CREATE TABLE id3fs (
 327     schema_version INTEGER
 328 );
 329
 330 CREATE TABLE files (
 331     id INTEGER PRIMARY KEY,
 332     name text
 333 );
 334
 335 CREATE TABLE artists (
 336     id INTEGER PRIMARY KEY,
 337     name text
 338 );
 339
 340 CREATE TABLE albums (
 341     id INTEGER PRIMARY KEY,
 342     name text
 343 );
 344
 345 CREATE TABLE tags (
 346     id INTEGER PRIMARY KEY,
 347     name text
 348 );
 349
 350 CREATE TABLE tagvals (
 351     id INTEGER PRIMARY KEY,
 352     name text
 353 );
 354
 355 CREATE TABLE files_x_tags (
 356     files_id INTEGER,
 357     tags_id INTEGER
 358 );
 359
 360 CREATE TABLE tags_x_tagvals (
 361     tags_id INTEGER,
 362     tagvals_id INTEGER
 363 );
 364
 365 CREATE TABLE files_x_artists (
 366     files_id INTEGER,
 367     artists_id INTEGER
 368 );
 369
 370 CREATE TABLE artists_x_albums (
 371     artists_id INTEGER,
 372     albums_id INTEGER
 373 );