lib/WAIT/Index.pm

#                              -*- Mode: Cperl -*- 
# Index.pm -- 
# ITIID           : $ITI$ $Header $__Header$
# Author          : Ulrich Pfeifer
# Created On      : Thu Aug  8 13:05:10 1996
# Last Modified By: Ulrich Pfeifer
# Last Modified On: Sat Apr 27 18:06:47 2002
# Language        : CPerl
# Update Count    : 128
# Status          : Unknown, Use with caution!
# 
# Copyright (c) 1996-1997, Ulrich Pfeifer
# 

package WAIT::Index;
use WAIT::IndexScan;
use strict;
use BerkeleyDB;
use Fcntl;
use vars qw($VERSION);

$VERSION = "1.801"; # Table.pm tests if we are loaded by checking $VERSION

sub new {
  my $type = shift;
  my %parm = @_;
  my $self = {};

  unless ($self->{file} = $parm{file}) {
    require Carp;
    Carp::croak("No file specified");
  }
  unless ($self->{name} = $parm{name}) {
    require Carp;
    Carp::croak("No name specified");
  }
  unless ($self->{attr} = $parm{attr}) {
    require Carp;
    Carp::croak("No attributes specified");
  }
  bless $self, ref($type) || $type;
}

sub drop {
  my $self = shift;
  if ((caller)[0] eq 'WAIT::Table') { # Table knows about this
    my $file = $self->{file};
    ! (!-e $file or unlink $file);
  } else {                            # notify our database
    require Carp;
    Carp::croak(ref($self)."::drop called directly");
  }
}

sub open {
  my $self = shift;
  my $file = $self->{file};

  if ($self->{dbh}) {
    $self->{dbh};
  } else {
    my $dbmode = ($self->{mode} & O_CREAT) ? DB_CREATE : 0;
    $self->{dbh} = tie(%{$self->{db}}, 'BerkeleyDB::Btree',
                       -Filename => $self->{file},
                       -Subname  => 'records',
                       -Flags    => $dbmode,
                       -Mode     => 0664);
  }
}

sub insert {
  my $self  = shift;
  my $key   = shift;
  my %parm  = @_;

  defined $self->{db} or $self->open;

  my $tuple = join($;, map($parm{$_}, @{$self->{attr}}));

  if (exists $self->{db}->{$tuple}) {
    # duplicate entry
    return undef;
  }
  print STDERR "$tuple => $key\n";
  $self->{db}->{$tuple} = $key;
}

sub have {
  my $self  = shift;
  my %parm  = @_;

  defined $self->{db} or $self->open;

  my $tuple = join($;, map($parm{$_}, @{$self->{attr}}));

  print STDERR "$tuple <= ", $self->{db}->{$tuple}, "\n";
  $self->{db}->{$tuple};
}

sub fetch {
  my $self  = shift;
  my %parm  = @_;
  my @keys  = @{$self->{attr}->[0]};

  defined $self->{db} or $self->open;

  my $key   = join($;, map($parm{$_}, @keys));
  $self->{db}->{$key};
}

sub delete {
  my $self  = shift;
  my $key   = shift;
  my %parm  = @_;

  defined $self->{db} or $self->open;

  my $tuple = join($;, map($parm{$_}||"", @{$self->{attr}}));

  delete $self->{db}->{$tuple};
}

sub sync {
  my $self = shift;
  $self->{dbh}->db_sync if $self->{dbh};
}

sub close {
  my $self = shift;

  delete $self->{scans} if defined $self->{scans};

  if ($self->{dbh}) {
    delete $self->{dbh};
    delete $self->{db};
    #untie %{$self->{db}};
  }
}

#sub DESTROY { $_[0]->close }

sub open_scan {
  my $self = shift;
  my $code = shift;

  $self->{dbh} or $self->open;
  new WAIT::IndexScan $self, $code;
}

1;
1	ulpfr	13	# -- Mode: Cperl --
2	ulpfr	10	# Index.pm --
3			# ITIID : $ITI$ $Header $__Header$
4			# Author : Ulrich Pfeifer
5			# Created On : Thu Aug 8 13:05:10 1996
6			# Last Modified By: Ulrich Pfeifer
7	ulpfr	85	# Last Modified On: Sat Apr 27 18:06:47 2002
8	ulpfr	10	# Language : CPerl
9	ulpfr	85	# Update Count : 128
10	ulpfr	10	# Status : Unknown, Use with caution!
11			#
12			# Copyright (c) 1996-1997, Ulrich Pfeifer
13			#
14
15			package WAIT::Index;
16			use WAIT::IndexScan;
17			use strict;
18	ulpfr	85	use BerkeleyDB;
19	ulpfr	10	use Fcntl;
20	laperla	29	use vars qw($VERSION);
21	ulpfr	10
22	laperla	29	$VERSION = "1.801"; # Table.pm tests if we are loaded by checking $VERSION
23
24	ulpfr	10	sub new {
25			my $type = shift;
26			my %parm = @_;
27			my $self = {};
28
29	ulpfr	13	unless ($self->{file} = $parm{file}) {
30			require Carp;
31			Carp::croak("No file specified");
32			}
33	ulpfr	85	unless ($self->{name} = $parm{name}) {
34			require Carp;
35			Carp::croak("No name specified");
36			}
37	ulpfr	13	unless ($self->{attr} = $parm{attr}) {
38			require Carp;
39			Carp::croak("No attributes specified");
40			}
41	ulpfr	10	bless $self, ref($type) \|\| $type;
42			}
43
44			sub drop {
45			my $self = shift;
46			if ((caller)[0] eq 'WAIT::Table') { # Table knows about this
47			my $file = $self->{file};
48			! (!-e $file or unlink $file);
49	ulpfr	13	} else { # notify our database
50			require Carp;
51			Carp::croak(ref($self)."::drop called directly");
52	ulpfr	10	}
53			}
54
55			sub open {
56			my $self = shift;
57			my $file = $self->{file};
58
59	ulpfr	85	if ($self->{dbh}) {
60	ulpfr	10	$self->{dbh};
61			} else {
62	ulpfr	85	my $dbmode = ($self->{mode} & O_CREAT) ? DB_CREATE : 0;
63			$self->{dbh} = tie(%{$self->{db}}, 'BerkeleyDB::Btree',
64			-Filename => $self->{file},
65			-Subname => 'records',
66			-Flags => $dbmode,
67			-Mode => 0664);
68	ulpfr	10	}
69			}
70
71			sub insert {
72			my $self = shift;
73			my $key = shift;
74			my %parm = @_;
75
76			defined $self->{db} or $self->open;
77
78			my $tuple = join($;, map($parm{$_}, @{$self->{attr}}));
79
80			if (exists $self->{db}->{$tuple}) {
81			# duplicate entry
82			return undef;
83			}
84	ulpfr	85	print STDERR "$tuple => $key\n";
85	ulpfr	10	$self->{db}->{$tuple} = $key;
86			}
87
88			sub have {
89			my $self = shift;
90			my %parm = @_;
91
92			defined $self->{db} or $self->open;
93
94			my $tuple = join($;, map($parm{$_}, @{$self->{attr}}));
95
96	ulpfr	85	print STDERR "$tuple <= ", $self->{db}->{$tuple}, "\n";
97	ulpfr	82	$self->{db}->{$tuple};
98	ulpfr	10	}
99
100			sub fetch {
101			my $self = shift;
102			my %parm = @_;
103			my @keys = @{$self->{attr}->[0]};
104	ulpfr	13
105	ulpfr	10	defined $self->{db} or $self->open;
106
107			my $key = join($;, map($parm{$_}, @keys));
108			$self->{db}->{$key};
109			}
110
111			sub delete {
112			my $self = shift;
113			my $key = shift;
114			my %parm = @_;
115
116			defined $self->{db} or $self->open;
117
118	ulpfr	19	my $tuple = join($;, map($parm{$_}\|\|"", @{$self->{attr}}));
119	ulpfr	13
120	ulpfr	10	delete $self->{db}->{$tuple};
121			}
122
123			sub sync {
124			my $self = shift;
125	ulpfr	85	$self->{dbh}->db_sync if $self->{dbh};
126	ulpfr	10	}
127
128			sub close {
129			my $self = shift;
130
131			delete $self->{scans} if defined $self->{scans};
132
133			if ($self->{dbh}) {
134			delete $self->{dbh};
135			delete $self->{db};
136	ulpfr	85	#untie %{$self->{db}};
137	ulpfr	10	}
138			}
139
140			#sub DESTROY { $_[0]->close }
141
142			sub open_scan {
143			my $self = shift;
144			my $code = shift;
145	ulpfr	13
146	ulpfr	10	$self->{dbh} or $self->open;
147			new WAIT::IndexScan $self, $code;
148			}
149
150			1;