lib/ID3FS/Path/Node.pm

   1 package ID3FS::Path::Node;
   2
   3 use strict;
   4 use warnings;
   5
   6 sub new
   7 {
   8     my $proto=shift;
   9     my $class=ref($proto) || $proto;
  10     my $self={};
  11     bless($self,$class);
  12
  13     my $db=shift;
  14     $self->{type}=shift;
  15     $self->{name}=shift;
  16     $self->{parents_id}=shift;
  17     if($self->{type} ne "boolean")
  18     {
  19         my $table=ucfirst($self->{type});
  20         $table .= "s" unless($table=~/s$/);
  21         $self->{id}=$db->lookup_id($table, $self->{name}, $self->{parents_id});
  22         return undef unless(defined($self->{id}));
  23     }
  24     return $self;
  25 }
  26
  27 sub set
  28 {
  29     my($self, $name, $val)=@_;
  30     if(defined($val))
  31     {
  32         $self->{$name}=$val;
  33     }
  34     return $self->{$name};
  35 }
  36
  37 sub left       { return shift->set("left",       shift); }
  38 sub right      { return shift->set("right",      shift); }
  39 sub name       { return shift->set("name",       shift); }
  40 sub type       { return shift->set("type",       shift); }
  41 sub id         { return shift->set("id",         shift); }
  42 sub parents_id { return shift->set("parents_id", shift); }
  43
  44 sub print
  45 {
  46     my($self)=@_;
  47     my $op=$self->name();
  48     my $left=$self->left();
  49     my $right=$self->right();
  50     return "" unless($left || $right);
  51     my $str .= $self->print_node($left);
  52     $str .= (" " . $op . " ") if($op);
  53     $str .= $self->print_node($right);
  54     if($op || ($left && $right))
  55     {
  56         $str="(" . $str . ")";
  57     }
  58     return $str;
  59 }
  60
  61 sub print_node
  62 {
  63     my($self, $node)=@_;
  64     return "" unless(defined($node));
  65     return $node->print() if(ref($node) eq "ID3FS::Path::Node");
  66     return $node->{name};
  67 }
  68
  69 sub to_sql
  70 {
  71     my($self, $hasvals, $not, @joins)=@_;
  72     $not=0 unless(defined($not));
  73     my @outjoins=();
  74     my $str='';
  75     # init
  76     unless(@joins)
  77     {
  78         @outjoins = @joins = ("INNER");
  79     }
  80     if($self->type() ne "boolean")
  81     {
  82         my $cnt=scalar(@joins)+1;
  83         $str .= "t" . scalar(@joins) . ".id='" . $self->{id} . "'";
  84         if($not && !$hasvals)
  85         {
  86             $str .= " AND fxt" . scalar(@joins) . ".files_id IS NULL";
  87         }
  88         return ($str, @outjoins);
  89     }
  90     else
  91     {
  92         my $left=$self->left();
  93         my $right=$self->right();
  94         return ("", @outjoins) unless($left || $right);
  95         my ($leftstr, @leftjoins) = $left->to_sql($hasvals, $not, @joins) if($left);
  96         push(@joins, @leftjoins);
  97         push(@outjoins, @leftjoins);
  98         my $op=$self->name();
  99         if(defined($op) && $self->type() eq "boolean")
 100         {
 101             # if we are ANDing, add an inner join
 102             # also if we are NOTing, but we are looking for a tag *value*
 103             if( ($op eq "AND") || ($hasvals && ($op eq "NOT")))
 104             {
 105                 # hack - if right child is a NOT, we don't need extra join/brackets
 106                 # NOT will do the same and we will end up with an extra one
 107                 unless($right && $right->name() && $right->name() eq "NOT")
 108                 {
 109                     push(@joins, "INNER");
 110                     push(@outjoins, "INNER");
 111                 }
 112             }
 113             elsif($op eq "NOT")
 114             {
 115                 $not=1;
 116                 push(@joins, "LEFT");
 117                 push(@outjoins, "LEFT");
 118 #               print("LEFT: ", $left->print(), "\n") if ($left);
 119 #               print("RIGHT: ", $right->print(), "\n") if($right);
 120             }
 121         }
 122         my ($rightstr, @rightjoins) = $right->to_sql($hasvals, $not, @joins) if($right);
 123         push(@outjoins, @rightjoins);
 124 #       print "LEFT (", scalar(@leftjoins), "): $leftstr\n";
 125 #       print "RIGHT (", scalar(@rightjoins), "): $rightstr\n";
 126         my $str=$leftstr;
 127         $str .= " $op " if($op && !$not);
 128         $str .= $rightstr;
 129         if($op || ($left && $right))
 130         {
 131             $str="(" . $str . ")";
 132         }
 133 #       print "STR: $str\n";
 134         return($str, @outjoins);
 135     }
 136 }
 137
 138 sub used_tags
 139 {
 140     my($self)=@_;
 141     if($self->type() eq "boolean")
 142     {
 143         my @used=();
 144         push(@used, $self->left()->used_tags())  if($self->left());
 145         push(@used, $self->right()->used_tags()) if($self->right());
 146         return(grep { defined; } @used);
 147     }
 148     return $self->id();
 149 }
 150
 151 1;