/[wait]/cvs-head/lib/WAIT/Table.pm
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /cvs-head/lib/WAIT/Table.pm

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

branches/CPAN/lib/WAIT/Table.pm revision 13 by ulpfr, Fri Apr 28 15:42:44 2000 UTC cvs-head/lib/WAIT/Table.pm revision 24 by ulpfr, Sat Nov 11 17:21:28 2000 UTC
# Line 4  Line 4 
4  # Author          : Ulrich Pfeifer  # Author          : Ulrich Pfeifer
5  # Created On      : Thu Aug  8 13:05:10 1996  # Created On      : Thu Aug  8 13:05:10 1996
6  # Last Modified By: Ulrich Pfeifer  # Last Modified By: Ulrich Pfeifer
7  # Last Modified On: Sun May 30 20:42:30 1999  # Last Modified On: Fri May 19 14:51:14 2000
8  # Language        : CPerl  # Language        : CPerl
9  # Update Count    : 56  # Update Count    : 133
10  # Status          : Unknown, Use with caution!  # Status          : Unknown, Use with caution!
11  #  #
12  # Copyright (c) 1996-1997, Ulrich Pfeifer  # Copyright (c) 1996-1997, Ulrich Pfeifer
# Line 34  use Carp; Line 34  use Carp;
34  # use autouse Carp => qw( croak($) );  # use autouse Carp => qw( croak($) );
35  use DB_File;  use DB_File;
36  use Fcntl;  use Fcntl;
37    use LockFile::Simple ();
38    
39  my $USE_RECNO = 0;  my $USE_RECNO = 0;
40    
# Line 163  sub new { Line 164  sub new {
164    } elsif (!mkdir($self->{file}, 0775)) {    } elsif (!mkdir($self->{file}, 0775)) {
165      croak "Could not 'mkdir $self->{file}': $!\n";      croak "Could not 'mkdir $self->{file}': $!\n";
166    }    }
167    
168      my $lockmgr = LockFile::Simple->make(-autoclean => 1);
169      # aquire a write lock
170      $self->{write_lock} = $lockmgr->lock($self->{file} . '/write')
171        or die "Can't lock '$self->{file}/write'";
172    
173    $self->{djk}      = $parm{djk}      if defined $parm{djk};    $self->{djk}      = $parm{djk}      if defined $parm{djk};
174    $self->{layout}   = $parm{layout} || new WAIT::Parse::Base;    $self->{layout}   = $parm{layout} || new WAIT::Parse::Base;
175    $self->{access}   = $parm{access} if defined $parm{access};    $self->{access}   = $parm{access} if defined $parm{access};
# Line 188  sub new { Line 195  sub new {
195      }      }
196      $self->create_inverted_index(attribute => $att, pipeline  => \@spec, @opt);      $self->create_inverted_index(attribute => $att, pipeline  => \@spec, @opt);
197    }    }
198    
199    $self;    $self;
200    # end of backwarn compatibility stuff    # end of backwarn compatibility stuff
201  }  }
# Line 323  sub drop { Line 331  sub drop {
331        $_->drop;        $_->drop;
332      }      }
333      unlink "$file/records";      unlink "$file/records";
334        # $self->unlock;
335      ! (!-e $file or rmdir $file);      ! (!-e $file or rmdir $file);
336    } else {    } else {
337      croak ref($self)."::drop called directly";      croak ref($self)."::drop called directly";
# Line 373  sub open { Line 382  sub open {
382                           $self->{mode}, 0664, $DB_BTREE);                           $self->{mode}, 0664, $DB_BTREE);
383      }      }
384    }    }
385    
386      # Locking
387      #
388      # We allow multiple readers to coexists.  But write access excludes
389      # all read access vice versa.  In practice read access on tables
390      # open for writing will mostly work ;-)
391    
392      my $lockmgr = LockFile::Simple->make(-autoclean => 1);
393    
394      # aquire a write lock. We might hold one acquired in create() already
395      $self->{write_lock} ||= $lockmgr->lock($self->{file} . '/write')
396        or die "Can't lock '$self->{file}/write'";
397    
398      my $lockdir = $self->{file} . '/read';
399      unless (-d $lockdir) {
400        mkdir $lockdir, 0755 or die "Could not mkdir $lockdir: $!";
401      }
402    
403      if ($self->{mode} & O_RDWR) {
404        # this is a hack.  We do not check for reopening ...
405        return $self if $self->{write_lock};
406        
407        # If we actually want to write we must check if there are any readers
408        opendir DIR, $lockdir or
409          die "Could not opendir '$lockdir': $!";
410        for my $lockfile (grep { -f "$lockdir/$_" } readdir DIR) {
411          # check if the locks are still valid.
412          # Since we are protected by a write lock, we could use a pline file.
413          # But we want to use the stale testing from LockFile::Simple.
414          if (my $lck = $lockmgr->trylock("$lockdir/$lockfile")) {
415            warn "Removing stale lockfile '$lockdir/$lockfile'";
416            $lck->release;
417          } else {
418            $self->{write_lock}->release;
419            die "Cannot write table '$file' while it's in use";
420          }
421        }
422      } else {
423        # this is a hack.  We do not check for reopening ...
424        return $self if $self->{read_lock};
425        
426        # We are a reader. So we release the write lock
427        my $id = time;
428        while (-f "$lockdir/$id.lock") { # here assume ".lock" format!
429          $id++;
430        }
431        $self->{read_lock} = $lockmgr->lock("$lockdir/$id");
432        $self->{write_lock}->release;
433        delete $self->{write_lock};
434      }
435    
436    $self;    $self;
437  }  }
438    
# Line 432  sub insert { Line 492  sub insert {
492    my $tuple = join($;, map($parm{$_} || '', @{$self->{attr}}));    my $tuple = join($;, map($parm{$_} || '', @{$self->{attr}}));
493    my $key;    my $key;
494    my @deleted = keys %{$self->{deleted}};    my @deleted = keys %{$self->{deleted}};
495      my $gotkey = 0;
496    
497    if (@deleted) {    if (@deleted) {
498      $key = pop @deleted;      $key = pop @deleted;
499      delete $self->{deleted}->{$key};      delete $self->{deleted}->{$key};
500        # Sanity check
501        if ($key && $key>0) {
502          $gotkey=1;
503    } else {    } else {
504          warn(sprintf("WAIT database inconsistency during insert ".
505                       "key[%s]: Please rebuild index\n",
506                       $key
507                      ));
508        }
509      }
510      unless ($gotkey) {
511      $key = $self->{nextk}++;      $key = $self->{nextk}++;
512    }    }
513    if ($USE_RECNO) {    if ($USE_RECNO) {
# Line 450  sub insert { Line 521  sub insert {
521        if ($key == $self->{nextk}-1) {        if ($key == $self->{nextk}-1) {
522          $self->{nextk}--;          $self->{nextk}--;
523        } else {        } else {
524            # warn "setting key[$key] deleted during insert";
525          $self->{deleted}->{$key}=1;          $self->{deleted}->{$key}=1;
526        }        }
527        my $idx;        my $idx;
# Line 504  sub delete_by_key { Line 576  sub delete_by_key {
576    my $self  = shift;    my $self  = shift;
577    my $key   = shift;    my $key   = shift;
578    
579      unless ($key) {
580        Carp::cluck "Warning: delete_by_key called without key. Looks like a bug in WAIT?";
581        return;
582      }
583    
584    return $self->{deleted}->{$key} if defined $self->{deleted}->{$key};    return $self->{deleted}->{$key} if defined $self->{deleted}->{$key};
585    my %tuple = $self->fetch($key);    my %tuple = $self->fetch($key);
586    for (values %{$self->{indexes}}) {    for (values %{$self->{indexes}}) {
# Line 520  sub delete_by_key { Line 597  sub delete_by_key {
597        }        }
598      }      }
599    }    }
600      # warn "setting key[$key] deleted during delete_by_key";
601    ++$self->{deleted}->{$key};    ++$self->{deleted}->{$key};
602  }  }
603    
604  sub delete {  sub delete {
605    my $self  = shift;    my $self  = shift;
606    my $tkey = $self->have(@_);    my $tkey = $self->have(@_);
607      # warn "tkey[$tkey]\@_[@_]";
608    defined $tkey && $self->delete_by_key($tkey, @_);    defined $tkey && $self->delete_by_key($tkey, @_);
609  }  }
610    
611  sub unpack {  sub unpack {
612    my $self = shift;    my $self = shift;
613    my $tuple = shift;    my $tuple = shift;
614      return unless defined $tuple;
615    
616    my $att;    my $att;
617    my @result;    my @result;
# Line 544  sub unpack { Line 623  sub unpack {
623    @result;    @result;
624  }  }
625    
626    sub set {
627      my ($self, $iattr, $value) = @_;
628      
629      unless ($self->{write_lock}) {
630        die "Cannot set attribute $iattr without having a write lock. Nothing done";
631      }
632      for my $att (keys %{$self->{inverted}}) {
633        if ($] > 5.003) {         # avoid bug in perl up to 5.003_05
634          my $idx;
635          for $idx (@{$self->{inverted}->{$att}}) {
636            $idx->set($iattr, $value);
637          }
638        } else {
639          map $_->set($iattr, $value), @{$self->{inverted}->{$att}};
640        }
641      }
642    
643      1;
644    }
645    
646  sub close {  sub close {
647    my $self = shift;    my $self = shift;
648    
# Line 551  sub close { Line 650  sub close {
650      eval {$self->{'access'}->close}; # dont bother if not opened      eval {$self->{'access'}->close}; # dont bother if not opened
651    }    }
652    for (values %{$self->{indexes}}) {    for (values %{$self->{indexes}}) {
653        require WAIT::Index;
654      $_->close();      $_->close();
655    }    }
656    if (defined $self->{inverted}) {    if (defined $self->{inverted}) {
657        require WAIT::InvertedIndex;
658      my $att;      my $att;
659      for $att (keys %{$self->{inverted}}) {      for $att (keys %{$self->{inverted}}) {
660        if ($] > 5.003) {         # avoid bug in perl up to 5.003_05        if ($] > 5.003) {         # avoid bug in perl up to 5.003_05
# Line 577  sub close { Line 678  sub close {
678      delete $self->{db};      delete $self->{db};
679    }    }
680    
681      $self->unlock;
682      
683    1;    1;
684  }  }
685    
686    sub unlock {
687      my $self = shift;
688    
689      # Either we have a read or a write lock (or we close the table already)
690      # unless ($self->{read_lock} || $self->{write_lock}) {
691      #   warn "WAIT::Table::unlock: Table aparently hold's no lock"
692      # }
693      if ($self->{write_lock}) {
694        $self->{write_lock}->release();
695        delete $self->{write_lock};
696      }
697      if ($self->{read_lock}) {
698        $self->{read_lock}->release();
699        delete $self->{read_lock};
700      }
701    
702    }
703    
704  sub DESTROY {  sub DESTROY {
705    my $self = shift;    my $self = shift;
706    
707    warn "Table handle destroyed without closing it first"    warn "Table handle destroyed without closing it first"
708      if $self->{db} and $self->{mode}&O_RDWR;      if $self->{write_lock} || $self->{read_lock};
709  }  }
710    
711  sub open_scan {  sub open_scan {
# Line 642  sub intervall { Line 763  sub intervall {
763  }  }
764    
765  sub search {  sub search {
766    my $self = shift;    my $self  = shift;
767    my $attr = shift;    my ($query, $attr, $cont, $raw);
768    my $cont = shift;    if (ref $_[0]) {
769    my $raw  = shift;      $query = shift;
770      
771        $attr = $query->{attr};
772        $cont = $query->{cont};
773        $raw  = $query->{raw};
774      } else {
775        require Carp;
776        Carp::cluck("Using three argument search interface is deprecated, use hashref interface instead");
777        $attr = shift;
778        $cont = shift;
779        $raw  = shift;
780        $query = {
781                  attr => $attr,
782                  cont => $cont,
783                  raw  => $raw,
784                 };
785      }
786    
787    my %result;    my %result;
788    
789    defined $self->{db} or $self->open; # require layout    defined $self->{db} or $self->open; # require layout
# Line 655  sub search { Line 793  sub search {
793        my $name = $_->name;        my $name = $_->name;
794        if (exists $raw->{$name} and @{$raw->{$name}}) {        if (exists $raw->{$name} and @{$raw->{$name}}) {
795          my $scale = 1/scalar(@{$raw->{$name}});          my $scale = 1/scalar(@{$raw->{$name}});
796          my %r = $_->search_raw(@{$raw->{$name}});          my %r = $_->search_raw($query, @{$raw->{$name}});
797          my ($key, $val);          my ($key, $val);
798          while (($key, $val) = each %r) {          while (($key, $val) = each %r) {
799            if (exists $result{$key}) {            if (exists $result{$key}) {
# Line 669  sub search { Line 807  sub search {
807    }    }
808    if (defined $cont and $cont ne '') {    if (defined $cont and $cont ne '') {
809      for (@{$self->{inverted}->{$attr}}) {      for (@{$self->{inverted}->{$attr}}) {
810        my %r = $_->search($cont);        my %r = $_->search($query, $cont);
811        my ($key, $val);        my ($key, $val);
812        while (($key, $val) = each %r) {        while (($key, $val) = each %r) {
813          if (exists $result{$key}) {          if (exists $result{$key}) {
Legend:
Removed from v.13  
changed lines
  Added in v.24
  ViewVC Help
Powered by ViewVC 1.1.26