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