lib/ID3FS/Path.pm

   1 # id3fs - a FUSE-based filesystem for browsing audio metadata
   2 # Copyright (C) 2010  Ian Beckwith <ianb@erislabs.net>
   3 #
   4 # This program is free software: you can redistribute it and/or modify
   5 # it under the terms of the GNU General Public License as published by
   6 # the Free Software Foundation, either version 3 of the License, or
   7 # (at your option) any later version.
   8 #
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU General Public License
  15 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 package ID3FS::Path;
  18
  19 use strict;
  20 use warnings;
  21 use ID3FS::Path::Node;
  22
  23 our ($STATE_INVALID, $STATE_ROOT, $STATE_TAG, $STATE_TAGVAL,
  24      $STATE_BOOLEAN, $STATE_ALBUMS, $STATE_TRACKLIST,
  25      $STATE_FILE, $STATE_ALL)=(0..8);
  26
  27 # operator precedence
  28 our %priorities=( "OR" => 0, "AND" => 1, "NOT" => 2 );
  29
  30 our $PATH_ALLTRACKS= "TRACKS";
  31 our $PATH_NOARTIST = "NOARTIST";
  32 our $PATH_NOALBUM  = "NOALBUM";
  33
  34 our $ENABLE_FILTER = 1;
  35
  36 sub new
  37 {
  38     my $proto=shift;
  39     my $class=ref($proto) || $proto;
  40     my $self={};
  41     bless($self,$class);
  42
  43     $self->{elements}=[];
  44     $self->{db}=shift;
  45     $self->{path}=shift;
  46     $self->{verbose}=shift;
  47     $self->{maxtagdepth}=shift;
  48     $self->{curtagdepth}=0;
  49     $self->{path} =~ s/\/\//\//g; # drop doubled slashes
  50
  51     $self->parse();
  52 #    print "STATE: ", $self->state(), "\n";
  53     return $self;
  54 }
  55
  56 sub isdir
  57 {
  58     my($self)=@_;
  59     if(($self->state() == $STATE_FILE) ||
  60        ($self->state() == $STATE_INVALID))
  61     {
  62         return 0;
  63     }
  64     return 1;
  65 }
  66
  67 sub isfile
  68 {
  69     my($self)=@_;
  70     return($self->state() == $STATE_FILE);
  71 }
  72
  73 sub isvalid
  74 {
  75     my($self)=@_;
  76     return($self->state() != $STATE_INVALID);
  77 }
  78
  79 sub dest
  80 {
  81     my($self, $mountpoint)=@_;
  82     if($self->state() == $STATE_FILE)
  83     {
  84         return $self->filename($mountpoint);
  85     }
  86     return "ERROR"; #should never happen?
  87 }
  88
  89 sub dirents
  90 {
  91     my($self)=@_;
  92     my @dents=();
  93     my @fents=();
  94     my $state=$self->state();
  95 #    print "DIRENTS: STATE: $state\n";
  96 #    print "DIRENTS: FILE: $self->{path}\n";
  97     if($state==$STATE_ALL)
  98     {
  99         @dents=($self->filter($PATH_ALLTRACKS, $PATH_NOARTIST), $self->artists());
 100     }
 101     elsif($state==$STATE_TAG || $state==$STATE_TAGVAL)
 102     {
 103         my $tail=$self->tail();
 104         if($state==$STATE_TAG && $self->is($TYPE_TAG, $tail) &&
 105            $self->{db}->tag_has_values($tail->id()))
 106         {
 107             @dents=$self->tags();
 108         }
 109         else
 110         {
 111             if($self->{maxtagdepth} && ($self->{curtagdepth} < $self->{maxtagdepth}))
 112             {
 113                 @dents=qw(AND OR);
 114             }
 115             push(@dents, $self->filter($PATH_ALLTRACKS, $PATH_NOARTIST), $self->artists());
 116         }
 117     }
 118     elsif($state==$STATE_BOOLEAN)
 119     {
 120         my $parent=$self->tail();
 121         unless($self->is($TYPE_BOOL, $parent) && $parent->{name} eq "NOT")
 122         {
 123             @dents=("NOT");
 124         }
 125         push(@dents,$self->tags());
 126     }
 127     elsif($state==$STATE_ROOT)
 128     {
 129         @dents=(qw(ALL NOT), $self->tags());
 130     }
 131     elsif($state==$STATE_ALBUMS)
 132     {
 133         @dents=$self->filter($PATH_ALLTRACKS, $PATH_NOALBUM, $self->albums());
 134     }
 135     elsif($state==$STATE_TRACKLIST)
 136     {
 137         @fents=$self->tracks();
 138     }
 139     else
 140     {
 141         print "id3fsd: INTERNAL ERROR: DIRENTS: UNHANDLED STATE: $state\n";
 142     }
 143     return(\@dents, \@fents);
 144 }
 145
 146 # State Machine Of Doom
 147 sub parse
 148 {
 149     my($self)=@_;
 150     $self->state($STATE_ROOT);
 151     return if($self->{path} eq "/");
 152     @{$self->{components}}=split(/\//, $self->{path});
 153     shift @{$self->{components}}; # drop empty field before leading /
 154 #    print "PATH: $self->{path}\n";
 155     my @parts=@{$self->{components}};
 156     my($tag, $tagval);
 157     $self->{elements}=[];
 158     $self->{in_all}=0;
 159     my $root_not=0;
 160     my $tags_seen=0;
 161     while(defined(my $name=shift @parts))
 162     {
 163 #       print "NAME: $name\n";
 164         my $state=$self->state();
 165         if($state==$STATE_INVALID)
 166         {
 167 #           print "SM: INVALID: $name\n";
 168             return;
 169         }
 170         elsif($state==$STATE_ROOT)
 171         {
 172 #           print "SM: ROOT: $name\n";
 173             if($name eq "ALL")
 174             {
 175                 $self->{in_all}=1;
 176                 $self->state($STATE_ALL);
 177             }
 178             elsif($name eq "NOT")
 179             {
 180                 $root_not=1;
 181                 push(@{$self->{elements}}, ID3FS::Path::Node->new($self->{db}, $TYPE_BOOL, $name));
 182                 $self->state($STATE_BOOLEAN);
 183             }
 184             else
 185             {
 186                 $tag=ID3FS::Path::Node->new($self->{db}, $TYPE_TAG, $name);
 187                 if($tag)
 188                 {
 189                     push(@{$self->{elements}}, $tag);
 190                     $tags_seen++;
 191                     $self->state($STATE_TAG);
 192                 }
 193                 else
 194                 {
 195                     $self->state($STATE_INVALID);
 196                 }
 197             }
 198         }
 199         elsif($state==$STATE_TAG || $state==$STATE_TAGVAL)
 200         {
 201             my $tag=$self->tail();
 202 #           print "SM: TAG/TAGVAL($state): $name\n";
 203             if($state==$STATE_TAG && $self->is($TYPE_TAG, $tag) &&
 204                $self->{db}->tag_has_values($tag->id()))
 205             {
 206 #               print "Parsing: parent: $tag->id()\n";
 207                 my $tagval=ID3FS::Path::Node->new($self->{db}, $TYPE_TAG, $name, $tag->id());
 208                 if(defined($tagval))
 209                 {
 210                     $self->state($STATE_TAGVAL);
 211                     # stay in tag state
 212                     push(@{$self->{elements}}, $tagval);
 213                 }
 214                 else
 215                 {
 216                     $self->state($STATE_INVALID);
 217                 }
 218             }
 219             elsif($name eq $PATH_ALLTRACKS)
 220             {
 221                 $self->state($STATE_TRACKLIST);
 222             }
 223             elsif($name eq $PATH_NOARTIST)
 224             {
 225                 $self->state($STATE_TRACKLIST);
 226             }
 227             elsif($name eq "AND")
 228             {
 229                 $self->state($STATE_BOOLEAN);
 230                 push(@{$self->{elements}}, ID3FS::Path::Node->new($self->{db}, $TYPE_BOOL, $name));
 231             }
 232             elsif($name eq "OR")
 233             {
 234                 $self->state($STATE_BOOLEAN);
 235                 push(@{$self->{elements}}, ID3FS::Path::Node->new($self->{db}, $TYPE_BOOL, $name));
 236             }
 237             else
 238             {
 239                 my $artist=ID3FS::Path::Node->new($self->{db}, $TYPE_ARTIST, $name);
 240                 if($artist)
 241                 {
 242                     push(@{$self->{elements}}, $artist);
 243                     $self->state($STATE_ALBUMS);
 244                 }
 245                 else
 246                 {
 247                     $self->state($STATE_INVALID);
 248                 }
 249             }
 250         }
 251         elsif($state==$STATE_BOOLEAN)
 252         {
 253 #           print "SM: BOOLEAN: $name\n";
 254             my $parent=$self->tail();
 255             my $allownot=1;
 256             if($self->is($TYPE_BOOL, $parent) &&
 257                $parent->{name} eq "NOT")
 258             {
 259                 $allownot=0;
 260             }
 261             if($allownot && $name eq "NOT")
 262             {
 263                 $self->state($STATE_BOOLEAN);
 264                 push(@{$self->{elements}}, ID3FS::Path::Node->new($self->{db}, $TYPE_BOOL, $name));
 265             }
 266             else
 267             {
 268                 my $tag=ID3FS::Path::Node->new($self->{db}, $TYPE_TAG, $name);
 269                 if($tag)
 270                 {
 271                     push(@{$self->{elements}}, $tag);
 272                     $tags_seen++;
 273                     $self->state($STATE_TAG);
 274                 }
 275                 else
 276                 {
 277                     $self->state($STATE_INVALID);
 278                 }
 279             }
 280         }
 281         elsif($state==$STATE_ALBUMS)
 282         {
 283 #           print "SM: ALBUM: $name\n";
 284             if($name eq $PATH_ALLTRACKS)
 285             {
 286                 $self->state($STATE_TRACKLIST);
 287             }
 288             elsif($name eq $PATH_NOALBUM)
 289             {
 290                 $self->state($STATE_TRACKLIST);
 291             }
 292             else
 293             {
 294                 my $album=ID3FS::Path::Node->new($self->{db}, $TYPE_ALBUM, $name);
 295                 if($album)
 296                 {
 297                     push(@{$self->{elements}}, $album);
 298                     $self->state($STATE_TRACKLIST);
 299                 }
 300                 else
 301                 {
 302                     $self->state($STATE_INVALID);
 303                 }
 304             }
 305         }
 306         elsif($state==$STATE_TRACKLIST)
 307         {
 308 #           print "SM: TRACKLIST: $name\n";
 309             my $track=ID3FS::Path::Node->new($self->{db}, $TYPE_FILE, $name);
 310             if($track)
 311             {
 312                 push(@{$self->{elements}}, $track);
 313                 $self->state($STATE_FILE);
 314             }
 315             else
 316             {
 317                 $self->state($STATE_INVALID);
 318             }
 319         }
 320         elsif($state==$STATE_FILE)
 321         {
 322 #           print "SM: FILE: $name\n";
 323             # Can't have anything after a filename
 324             $self->state($STATE_INVALID);
 325         }
 326         elsif($state==$STATE_ALL)
 327         {
 328             if($name eq $PATH_ALLTRACKS)
 329             {
 330                 $self->state($STATE_TRACKLIST);
 331             }
 332             elsif($name eq $PATH_NOARTIST)
 333             {
 334                 $self->state($STATE_TRACKLIST);
 335             }
 336             else
 337             {
 338                 my $artist=ID3FS::Path::Node->new($self->{db}, $TYPE_ARTIST, $name);
 339                 if($artist)
 340                 {
 341                     push(@{$self->{elements}}, $artist);
 342                     $self->state($STATE_ALBUMS);
 343                 }
 344                 else
 345                 {
 346                     $self->state($STATE_INVALID);
 347                 }
 348             }
 349         }
 350         else
 351         {
 352             print "SM: ERROR: UNKNOWN STATE: $self->{state}\n";
 353             $self->state($STATE_INVALID);
 354         }
 355     }
 356
 357     my @elements=@{$self->{elements}};
 358     # remove trailing boolean
 359     while(@elements && $self->is($TYPE_BOOL, $elements[$#elements]))
 360     {
 361         pop @elements;
 362     }
 363     # sort elements by precedence
 364     @elements=$self->sort_elements(@elements);
 365     $self->{tagtree}=$self->elements_to_tree(\@elements);
 366 }
 367
 368 sub state
 369 {
 370     my($self, $newstate)=@_;
 371     if(defined($newstate))
 372     {
 373         $self->{state}=$newstate;
 374         $self->{curtagdepth}++ if($newstate == $STATE_TAG);
 375     }
 376     return $self->{state};
 377 }
 378
 379 # link up precedence-sorted list into a binary tree
 380 sub elements_to_tree
 381 {
 382     my($self, $elements)=@_;
 383     return undef unless(@$elements);
 384     my ($left, $right, $op)=(undef, undef, undef);
 385     my $thing=pop @$elements;
 386     if($self->is($TYPE_BOOL, $thing))
 387     {
 388         $right=$self->elements_to_tree($elements);
 389         if($thing->{name} ne "NOT")
 390         {
 391             $left=$self->elements_to_tree($elements);
 392         }
 393         $thing->left($left);
 394         $thing->right($right);
 395     }
 396     return $thing;
 397 }
 398
 399 # Dijkstra's shunting-yard algorithm
 400 sub sort_elements
 401 {
 402     my ($self, @input)=@_;
 403     my @opstack=();
 404     my @output=();
 405 #    print "INPUT: ", join(', ', map { $_->{name}; } @input), "\n";
 406     while(my $thing = shift @input)
 407     {
 408         if($self->is($TYPE_TAG, $thing))
 409         {
 410             # Handle tag values by dropping parent
 411             if(@input && $self->is($TYPE_TAG, $input[0]))
 412             {
 413                 $thing=shift @input;
 414             }
 415             push(@output, $thing);
 416         }
 417         elsif($self->is($TYPE_BOOL, $thing))
 418         {
 419             while(@opstack &&
 420                   ($priorities{$thing->{name}} <= $priorities{$opstack[$#opstack]->{name}}))
 421             {
 422                 push(@output, pop(@opstack));
 423             }
 424             push(@opstack, $thing);
 425         }
 426     }
 427     while(@opstack)
 428     {
 429         push(@output, pop(@opstack));
 430     }
 431 #    print "STACK: ", join(', ', map { $_->{name}; } @output), "\n";
 432     return @output;
 433 }
 434
 435 sub used_tags
 436 {
 437     my($self)=@_;
 438     return() unless(defined($self->{tagtree}));
 439     return($self->{tagtree}->used_tags());
 440 }
 441
 442 sub expecting_values
 443 {
 444     my($self)=@_;
 445     my $tail=$self->tail();
 446     if($self->is($TYPE_TAG, $tail))
 447     {
 448         return($self->{db}->tag_has_values($tail->id()));
 449     }
 450 }
 451
 452 sub trailing_tag_id
 453 {
 454     my($self)=@_;
 455     my $tail=$self->tail();
 456     if($self->is($TYPE_TAG, $tail))
 457     {
 458         return($tail->id());
 459     }
 460     return undef;
 461 }
 462
 463 sub trailing_tag_parent
 464 {
 465     my($self)=@_;
 466     my $tail=$self->tail();
 467     if($self->is($TYPE_TAG, $tail))
 468     {
 469         return($tail->{parents_id});
 470     }
 471     return undef;
 472 }
 473
 474 sub tail
 475 {
 476     my($self)=@_;
 477     return($self->{elements}->[$#{$self->{elements}}]);
 478 }
 479
 480 sub is
 481 {
 482     my($self, $type, $thing)=@_;
 483     return 0 unless($thing);
 484     return 0 unless($thing->type());
 485     return 1 if($type == $thing->type());
 486     return 0;
 487 }
 488
 489 # the one before last
 490 sub tail_parent
 491 {
 492     my($self)=@_;
 493     return($self->{elements}->[($#{$self->{elements}}) - 1]);
 494 }
 495
 496 ######################################################################
 497
 498 sub tags
 499 {
 500     my($self)=@_;
 501     if(!$self->{tagtree}) # / or /NOT
 502     {
 503         my $sql="SELECT DISTINCT name FROM tags WHERE parents_id='';";
 504         return($self->{db}->cmd_firstcol($sql));
 505     }
 506     my $hasvals=$self->expecting_values();
 507     my $parent=$self->trailing_tag_parent();
 508 #    print "THASVALS: $hasvals\n";
 509 #    print "TPARENT: ", (defined($parent)? $parent : "NO"), "\n";
 510     my @ids=();
 511     my $sql="SELECT tags.name FROM ";
 512     if($self->in_or())
 513     {
 514         $sql .= "files_x_tags\n";
 515     }
 516     else
 517     {
 518         $sql .= ("(\n" .
 519                  $self->tags_subselect() .
 520                  ") AS subselect\n" .
 521                  "INNER JOIN files_x_tags ON subselect.files_id=files_x_tags.files_id\n");
 522     }
 523     $sql .= "INNER JOIN tags ON files_x_tags.tags_id=tags.id\n";
 524     my @andclauses=();
 525     my $id=$self->trailing_tag_id();
 526
 527     my $parentclause= "tags.parents_id='";
 528     if($hasvals)
 529     {
 530         $parentclause .= $id;
 531     }
 532     elsif($parent)
 533     {
 534         $parentclause .= $parent;
 535     }
 536     $parentclause .= "'";
 537     push(@andclauses, $parentclause);
 538
 539     my @used=$self->used_tags();
 540     if(@used)
 541     {
 542         push(@andclauses, "tags.id NOT IN (" . join(', ', @used) . ")");
 543     }
 544     if(@andclauses)
 545     {
 546         $sql .= "WHERE " . join(' AND ', @andclauses) . "\n";
 547     }
 548
 549     $sql .= "GROUP BY tags.name;";
 550     print "SQL(TAGS): $sql\n" if($self->{verbose});
 551     my @tagnames=$self->{db}->cmd_firstcol($sql);
 552     print("SUBNAMES: ", join(', ', @tagnames), "\n") if($self->{verbose});
 553     return(@tagnames);
 554 }
 555
 556 sub artists
 557 {
 558     my($self)=@_;
 559     if(!@{$self->{elements}}) # /ALL
 560     {
 561         my $sql="SELECT DISTINCT name FROM artists WHERE name!='';";
 562         return($self->{db}->cmd_firstcol($sql));
 563     }
 564     my @ids=();
 565     my $sql=$self->sql_start("artists.name");
 566     $sql .= ("INNER JOIN artists ON files.artists_id=artists.id\n" .
 567              "WHERE artists.name != ''\n" .
 568              "GROUP BY artists.name;");
 569     print "SQL(ARTISTS): $sql\n" if($self->{verbose});
 570     my @tagnames=$self->{db}->cmd_firstcol($sql);
 571     print("ARTISTS: ", join(', ', @tagnames), "\n") if($self->{verbose});
 572     return(@tagnames);
 573 }
 574
 575 sub albums
 576 {
 577     my($self)=@_;
 578     my @ids=();
 579     my $tail=$self->tail();
 580     if($self->is($TYPE_ARTIST, $tail))
 581     {
 582         return $self->artist_albums($tail->id());
 583     }
 584     my $sql=$self->sql_start("albums.name");
 585     $sql .= ("INNER JOIN albums ON files.albums_id=albums.id\n" .
 586              "WHERE albums.name != ''\n" .
 587              "GROUP BY albums.name;");
 588     print "SQL(ALBUMS): \n$sql\n" if($self->{verbose});
 589     my @names=$self->{db}->cmd_firstcol($sql);
 590     print("ALBUMS: ", join(', ', @names), "\n") if($self->{verbose});
 591     return(@names);
 592 }
 593
 594 sub artist_albums
 595 {
 596     my($self, $artist_id)=@_;
 597     my $sql=$self->sql_start("albums.name");
 598     $sql .= ("INNER JOIN albums ON albums.id=files.albums_id\n" .
 599              "INNER JOIN artists ON artists.id=files.artists_id\n" .
 600              "WHERE artists.id=? and albums.name <> ''\n" .
 601              "GROUP BY albums.name\n");
 602     print "ARTIST_ALBUMS SQL: $sql\n" if($self->{verbose});
 603     my @albums=$self->{db}->cmd_firstcol($sql, $artist_id);
 604     print("ALBUMS: ", join(', ', @albums), "\n") if($self->{verbose});
 605     return(@albums);
 606 }
 607
 608 sub artist_tracks
 609 {
 610     my($self, $artist_id)=@_;
 611     my $sql=$self->sql_start("files.name");
 612     $sql .= ("INNER JOIN artists ON artists.id=files.artists_id\n" .
 613              "INNER JOIN albums  ON albums.id=files.albums_id\n" .
 614              "WHERE artists.id=? AND albums.name=''\n" .
 615              "GROUP BY files.name\n");
 616     print "ARTIST_TRACKS SQL: $sql\n" if($self->{verbose});
 617     my @names=$self->{db}->cmd_firstcol($sql, $artist_id);
 618     print("ARTISTTRACKS: ", join(', ', @names), "\n") if($self->{verbose});
 619     return(@names);
 620 }
 621
 622 sub album_tracks
 623 {
 624     my($self, $artist_id, $album_id)=@_;
 625     my $sql=("SELECT files.name FROM files\n" .
 626              "INNER JOIN albums  ON albums.id=files.albums_id\n" .
 627              "INNER JOIN artists ON artists.id=files.artists_id\n" .
 628              "WHERE artists.id=? AND albums.id=?\n" .
 629              "GROUP BY files.name\n");
 630     print "ALBUM_TRACKS SQL($artist_id, $album_id): $sql\n" if($self->{verbose});
 631     my @names=$self->{db}->cmd_firstcol($sql, $artist_id, $album_id);
 632     print("TRACKS: ", join(', ', @names), "\n") if($self->{verbose});
 633     return(@names);
 634 }
 635
 636 sub tracks
 637 {
 638     my($self)=@_;
 639     my $tail=$self->tail();
 640     if($self->is($TYPE_ARTIST, $tail))
 641     {
 642         return $self->artist_tracks($tail->id());
 643     }
 644     elsif($self->is($TYPE_ALBUM, $tail))
 645     {
 646         my $artist_id=0;
 647         my $artist=$self->tail_parent();
 648         if($self->is($TYPE_ARTIST, $artist))
 649         {
 650             # should always happen
 651             $artist_id=$artist->id();
 652         }
 653         return $self->album_tracks($artist_id, $tail->id());
 654     }
 655     my $sql=$self->sql_start("files.name");
 656     $sql .= "INNER JOIN artists ON files.artists_id=artists.id\n";
 657     if($self->{components}->[$#{$self->{components}}] eq $PATH_NOARTIST)
 658     {
 659         $sql .= "WHERE artists.name =''\n";
 660     }
 661     $sql .= "GROUP BY files.name;";
 662     print "TRACKS SQL($self->{path}): $sql\n" if($self->{verbose});
 663     my @names=$self->{db}->cmd_firstcol($sql);
 664     print("TRACKS: ", join(', ', @names), "\n") if($self->{verbose});
 665     return(@names);
 666 }
 667
 668 sub filename
 669 {
 670     my($self, $mountpoint)=@_;
 671     my $tail=$self->tail();
 672     if($self->is($TYPE_FILE, $tail))
 673     {
 674         my $id=$tail->id();
 675         my $sql=("SELECT paths.name, files.name FROM files\n" .
 676                  "INNER JOIN paths ON files.paths_id=paths.id\n" .
 677                  "WHERE files.id=?\n" .
 678                  "GROUP BY paths.name, files.name");
 679         print "FILENAME SQL: $sql\n" if($self->{verbose});
 680         my ($path, $name)=$self->{db}->cmd_onerow($sql, $id);
 681         return($self->{db}->relativise($path, $name, $mountpoint, $self->{path}));
 682     }
 683     # should never happen
 684     return "ERROR";
 685 }
 686
 687 sub tags_subselect
 688 {
 689     my($self)=@_;
 690     my $hasvals=$self->expecting_values();
 691     my $tree=$self->{tagtree};
 692     my $parent=$self->trailing_tag_parent();
 693
 694     my $tag=undef;
 695     if($hasvals)
 696     {
 697         $tag=$self->trailing_tag_id();
 698 #       print "Trailing id: $tag\n";
 699     }
 700     my ($sqlclause, @joins)=(undef, ());
 701     ($sqlclause, @joins) = $tree->to_sql($hasvals) if($tree);
 702 #    print "SQL(" . scalar(@joins) ."): $sqlclause\n";
 703     my $sql="\tSELECT fxt1.files_id FROM tags t1";
 704     my @crosses=();
 705     my @inners=();
 706 #    $joinsneeded++ if($tag);
 707     for(my $i=0; $i <= $#joins; $i++)
 708     {
 709         my $cnt=$i+1;
 710         my $join=$joins[$i];
 711         my $inner=("\t$join JOIN files_x_tags fxt$cnt ON " .
 712                    "t${cnt}.id=fxt${cnt}.tags_id");
 713         if($i > 0)
 714         {
 715             push(@crosses, "CROSS JOIN tags t$cnt");
 716             $inner .= " AND fxt1.files_id=fxt${cnt}.files_id";
 717         }
 718         push(@inners, $inner);
 719     }
 720     $sql .= ("\n\t" . join(" ", @crosses)) if(@crosses);
 721     $sql .= ("\n" . join("\n", @inners)) if(@inners);
 722     $sql .= "\n\tWHERE $sqlclause" if($sqlclause);
 723 #    if($tag)
 724 #    {
 725 #       $sql .= " AND t${joinsneeded}.parents_id='$tag'";
 726 #    }
 727     $sql .= "\n\tGROUP BY fxt1.files_id\n";
 728     return $sql;
 729 }
 730
 731 sub sql_start
 732 {
 733     my($self, $tables)=@_;
 734     my $sql="SELECT $tables FROM ";
 735     if($self->{in_all})
 736     {
 737         $sql .= "files\n";
 738     }
 739     else
 740     {
 741         $sql .= ("(\n" .
 742                  $self->tags_subselect() .
 743                  ") AS subselect\n" .
 744                  "INNER JOIN files ON subselect.files_id=files.id\n");
 745     }
 746     return $sql;
 747 }
 748
 749 # we just filter $ALLTRACKS, $NOARTIST and $NOALBUM
 750 # filtering tags properly requires up to four levels of recursion
 751 # (tag/tagval/AND/NOT) and is too slow
 752 sub filter
 753 {
 754     my($self, @dirs)=@_;
 755     return(@dirs) unless($ENABLE_FILTER);
 756     my $base=$self->{path};
 757     my @outdirs=();
 758     for my $dir (@dirs)
 759     {
 760         push(@outdirs, $dir) unless($self->empty("$base/$dir"));
 761     }
 762     return(@outdirs);
 763 }
 764
 765 sub empty
 766 {
 767     my($self, $dir)=@_;
 768     my $path=ID3FS::Path->new($self->{db}, $dir, $self->{verbose},
 769                               ($self->{maxtagdepth} - $self->{curtagdepth}));
 770     return 1 unless($path->isvalid());
 771     my($subdirs,$subfiles)=$path->dirents();
 772     return 0 if(@$subfiles || @$subdirs);
 773     return 1;
 774 }
 775
 776 # if path is .../OR/ or .../OR/NOT
 777 sub in_or
 778 {
 779     my($self)=@_;
 780     my $tail=$self->tail();
 781     return 0 unless($tail);
 782     return 0 unless($tail->type() == $TYPE_BOOL);
 783     return 1 if($tail->name() eq "OR");
 784     return 0 unless($tail->name() eq "NOT");
 785     my $parent=$self->tail_parent();
 786     return 0 unless($parent);
 787     return 0 unless($parent->type() == $TYPE_BOOL);
 788     return 1 if($parent->name() eq "OR");
 789     return 0;
 790 }
 791
 792 1;