blib/lib/Uplug/IO/DBM.pm untested

filter: Statementstmt 0.0% 0 / 318 Branchbran 0.0% 0 / 116 Conditioncond 0.0% 0 / 9 MC/DCmcdc 0.0% 0 / 6 Subroutinesub 0.0% 0 / 25 Podpod 0.0% 0 / 17 totaltotal 0.0% 0 / 491 CC 59 SCAR 47.8
CC
59
Cov
0%
open
342.0
select
132.0
JoinComplexHashs
132.0
CRAP 119.6
1 ####################################################################
2 # Copyright (C) 2004 Jörg Tiedemann <joerg@stp.ling.uu.se>
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 2 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, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 #
18 # Uplug::IO::DBM
19 #
20 # simple module for storing uplug-data in DBM-files
21 #
22 #####################################################################
23 # $Author$
24 # $Id$
25  
26  
27  
28 package Uplug::IO::DBM;
29  
30 # use utf8;
31 # use bytes;
32 use strict;
33 use vars qw(@ISA $DEFAULTMODE $DEFAULTCACHESIZE);
34 use Uplug::IO;
35 use Uplug::Data;
36 use Uplug::Encoding;
37 use Data::Dumper;
38  
39 @ISA = qw( Uplug::IO );
40  
41 BEGIN { @AnyDBM_File::ISA=qw(DB_File GDBM_File SDBM_File NDBM_File ODBM_File) }
42 # BEGIN { @AnyDBM_File::ISA=qw(SDBM_File GDBM_File_ NDBM_File ODBM_File) }
43 use AnyDBM_File;
44 use POSIX;
45  
46 #---------------------------------------------------------------------------
47 # simple caching: the first selected items get chached
48 # nothing will be added if the cache is full until the DBM is opened again
49  
50 $DEFAULTCACHESIZE=200000; # max number of items cached by GetKeyData
51 #$DEFAULTCACHESIZE=0;
52 $DEFAULTMODE=0644; # default file mode for tie
53  
54  
55  
56 sub open{
57 my $self = shift;
58 $self->{AccessMode} = shift;
59 my $HeaderHash = $_[0];
60 if (not $self->{AccessMode}){$self->{AccessMode}='read';}
61 if ($self->{AccessMode} eq 'write'){
62 if (defined $HeaderHash->{'write_mode'}){
63 $self->{AccessMode}=$HeaderHash->{'write_mode'};
64 }
65 }
66  
67 $self->{CACHED}=0;
68 $self->{CACHESIZE}=$DEFAULTCACHESIZE;
69 $self->SUPER::init($HeaderHash);
70  
71 if ((not defined $self->{StreamOptions}->{FileName}) and
72 (defined $self->{StreamOptions}->{file})){
73 $self->{StreamOptions}->{FileName}=$self->{StreamOptions}->{file};
74 }
75 $self->{FileName}=$self->{StreamOptions}->{FileName};
76 $self->{StreamOptions}->{file}=$self->{StreamOptions}->{FileName};
77  
78  
79 if (defined $self->{FileName}){
80 $self->{DBMhash}={};
81 if (not defined $self->{StreamOptions}->{'file mode'}){
82 $self->{StreamOptions}->{'file mode'}=$Uplug::IO::DBM::DEFAULTMODE;
83 }
84 if (-e $self->{'FileName'}){
85 if ($self->{AccessMode} eq 'write'){
86 warn "Cannot open $self->{'FileName'} for writing!";
87 return 0;
88 }
89 if ($self->{AccessMode} eq 'overwrite'){
90 unlink $self->{'FileName'};
91 }
92 }
93 if ($self->{AccessMode} eq 'read'){
94 if (not $self->{DBH}=tie %{$self->{DBMhash}},
95 'AnyDBM_File',
96 $self->{'FileName'},
97 O_RDONLY,
98 $self->{StreamOptions}->{'file mode'}){
99 return 0;
100 }
101 }
102 elsif (not $self->{DBH}=tie %{$self->{DBMhash}},
103 'AnyDBM_File',
104 $self->{'FileName'},
105 O_RDWR|O_CREAT,
106 $self->{StreamOptions}->{'file mode'}){
107 return 0;
108 }
109  
110  
111 ## JT 2005-03-14:
112
113 if ($]>=5.006){
114 my $mod=qw( Encode );
115 eval "require $mod";
116 if ($@){warn $@;exit;}
117 # $self->{DBH}->filter_store_key(sub {Encode::_utf8_off($_)});
118 # $self->{DBH}->filter_store_value(sub{Encode::_utf8_off($_)});
119 # $self->{DBH}->filter_fetch_key(sub{Encode::_utf8_off($_)});
120 # $self->{DBH}->filter_fetch_value(sub {Encode::_utf8_off($_)});
121 $self->{DBH}->filter_store_key(sub {$_=Encode::encode('utf8',$_)});
122 $self->{DBH}->filter_store_value(sub{$_=Encode::encode('utf8',$_)});
123 $self->{DBH}->filter_fetch_key(sub{$_=Encode::decode('utf8',$_)});
124 $self->{DBH}->filter_fetch_value(sub {$_=Encode::decode('utf8',$_)});
125 }
126 }
127 if (defined $HeaderHash->{'key'}){
128 if (ref($HeaderHash->{'key'}) eq 'ARRAY'){
129 my @arr=@{$HeaderHash->{'key'}};
130 $self->{'key'}=[];
131 @{$self->{'key'}}=@arr;
132 }
133 else{
134 if ($HeaderHash->{'key'}=~/^\((.*)\)$/){
135 my @arr=split(/\s*,\s*/,$1);
136 $self->{'key'}=[];
137 @{$self->{'key'}}=@arr;
138 }
139 else{
140 $self->{'key'}=[];
141 @{$self->{'key'}}=($HeaderHash->{'key'});
142 }
143 }
144 }
145 my %HeaderOptions=('FileName' => $self->{FileName}.'.head');
146 $self->{HeaderStream}=Uplug::IO::Text->new;
147 $self->{HeaderStream}->open($self->{AccessMode},\%HeaderOptions);
148 $self->addheader($self->{HeaderStream}->header);
149 return $self->SUPER::open($self->{AccessMode},$HeaderHash);
150 }
151  
152  
153  
154 sub close{
155 my $self=shift;
156 $self->{HeaderStream}->close;
157 untie %{$self->{DBMhash}};
158 return 1;
159 }
160  
161  
162 sub read{
163 my ($self,$TreeData)=@_;
164  
165 $TreeData->init;
166  
167 my $data={};
168 my ($key,$val)=each %{$self->{DBMhash}};
169  
170 if ((not defined $key) and (not defined $val)){
171 return 0;
172 }
173  
174 my @keyval=split(/\x00/,$key);
175 %{$data}=split(/\x00/,$val);
176 if ($val=~/\|/){
177 foreach (keys %{$data}){
178 if ($data->{$_}=~/\|/){
179 my @arr=split(/\|/,$data->{$_});
180 $data->{$_}=undef;
181 @{$data->{$_}}=@arr;
182 }
183 }
184 }
185 if (defined $self->{key}){
186 foreach (@{$self->{'key'}}){
187 $data->{$_}=shift(@keyval);
188 }
189 }
190 %{$data}=&expandData($data);
191 $TreeData->setData($data);
192 return 1;
193 }
194  
195  
196  
197 sub write{
198 my ($self,$TreeData)=@_;
199  
200 $self->SUPER::write($TreeData);
201 my $data=$TreeData->data;
202 if (ref($data) ne 'HASH'){return;}
203  
204 my %dat=%{$data};
205 my $key;
206 my @fields=();
207 if (defined $self->{key}){
208 foreach (@{$self->{'key'}}){
209 push (@fields,$dat{$_});
210 delete $dat{$_};
211 }
212 }
213 $key=join ("\x00",@fields);
214 if (not $key){
215 $self->{'LastNr'}++;
216 $key=$self->{'LastNr'};
217 }
218  
219 my %TmpData=$self->GetKeyValue($key);
220 if (keys %TmpData){
221 my $NewData=&JoinComplexHashs(\%TmpData,\%dat);
222 %dat=%{$NewData};
223 }
224 foreach (keys %dat){if ($dat{$_} eq ''){$dat{$_}=' ';}}
225  
226 %dat=&dumpData(\%dat);
227 my $d=join ("\x00",%dat);
228  
229 eval { $self->{DBMhash}->{$key}=$d; };
230 return 1;
231 }
232  
233  
234 sub count{
235 my $self=shift;
236 my $records=keys %{$self->{DBMhash}};
237 return $records;
238 }
239  
240  
241  
242 #-----------------------------------------------------------------------------
243  
244 sub select{
245 my $self=shift;
246 my ($data,
247 $Query,
248 $ListOfAttr,
249 $CmpOperator)=@_;
250  
251 if (not ref($data)){return;} # no return data object found
252 if (ref($Query) ne 'HASH'){return;} # query pattern is no hash
253 my %Pattern=%{$Query}; # save query in a new hash
254  
255 my @keys;
256 if (defined $self->{'key'}){ # hash-key fields
257 @keys=@{$self->{'key'}};
258 }
259 if (not @keys){ # if no hash keys specified:
260 return $self->SUPER::select($data, # use standard select
261 $Query, # (read sequentially through
262 $ListOfAttr, # the database --> slow!)
263 $CmpOperator);
264 }
265 my $key;
266 my $keycomplete=1; # hash-key is complete
267 my @fields=();
268 foreach my $k (@keys){ # check all key-fields
269 if (not defined $Pattern{$k}){ # if one of them is not
270 $keycomplete=0; # specified --> reset flag
271 push (@fields,'.*'); # and create a wild-card-key
272 }
273 else{
274 push(@fields,$Pattern{$k}); # otherwise: save key-field
275 delete $Pattern{$k}; # and delete pattern
276 }
277 }
278 $key=join ("\x00",@fields); # join all keys together
279  
280 #-------------------------------------------------------------------------
281 my %hash=();
282 if ($keycomplete){ # if the key is complete:
283 %hash=$self->GetKeyData($key); # * get data from hash
284 }
285 else{ # key is not complete!
286 $key=qr/^$key\$/; # make regular expression
287 my ($k,$v);
288 while (($k,$v)=$self->getNext()){ # run through all keys
289 if ($k=~/$key/){ # and try to match the key!
290 %hash=$self->GetKeyData($k); # - get the data
291 }
292 if (keys %hash){last;}
293 }
294 }
295 #-------------------------------------------------------------------------
296 if (not keys %hash){return 0;} # - key not found -> return
297 if (not &MatchQuery(\%Pattern,\%hash)){ # - other attr don't match
298 return 0;
299 }
300 $data->setData(\%hash);
301 return 1;
302 }
303  
304 #-----------------------------------------------------------------------------
305  
306  
307 sub getNext{
308 my $self=shift;
309 return each %{$self->{DBMhash}};
310 }
311  
312 sub getValue{
313 return $_[0]->{DBMhash}->{$_[1]};
314 }
315  
316 #-------------------------------------------------------------------
317 # match a query pattern with a data structure
318 # ... this is much too simple ...
319 # ... should be improved in many ways
320 #
321  
322 sub MatchQuery{
323 my ($query,$data)=@_;
324  
325 if (ref($query) ne ref($data)){return 0;}
326 if (not ref($query)){
327 return $data=~/^$query$/;
328 }
329 if (ref($query) eq 'ARRAY'){
330 foreach my $a (@{$query}){
331 if (not &MatchQuery($query->[$a],$data->[$a])){
332 return 0;
333 }
334 }
335 }
336 foreach my $a (keys %{$query}){
337 if (not &MatchQuery($query->{$a},$data->{$a})){
338 return 0;
339 }
340 }
341 return 1;
342 }
343  
344  
345 sub readheader{
346 my $self=shift;
347 $self->{HeaderStream}->readheader;
348 $self->addheader($self->{HeaderStream}->header);
349 }
350  
351 sub writeheader{
352 my $self=shift;
353 $self->{HeaderStream}->addheader($self->header);
354 $self->{HeaderStream}->writeheader;
355 }
356  
357  
358  
359  
360 sub GetKeyData{
361 my ($self,$key)=@_;
362  
363 #-----------------------------------------------
364 if (defined $self->{DBMcache}->{$key}){
365 # print STDERR "found $key in cache ($self->{CACHED})!\n";
366 return %{$self->{DBMcache}->{$key}};
367 }
368 #-----------------------------------------------
369  
370 if (defined $self->{DBMhash}->{$key}){
371 my $dat=$self->{DBMhash}->{$key};
372 my @keyval=split(/\x00/,$key);
373 my %FoundData=split(/\x00/,$dat);
374 &expandData(\%FoundData);
375 foreach (@{$self->{'key'}}){
376 $FoundData{$_}=shift(@keyval);
377 }
378 #-----------------------------------------------
379 if ($self->{CACHED}<$self->{CACHESIZE}){
380 %{$self->{DBMcache}->{$key}}=%FoundData;
381 $self->{CACHED}++;
382 }
383 #-----------------------------------------------
384 return %FoundData;
385 }
386 #-----------------------------------------------
387 # JT 14-11-2004: cache even not-found keys
388 if ($self->{CACHED}<$self->{CACHESIZE}){
389 %{$self->{DBMcache}->{$key}}=();
390 $self->{CACHED}++;
391 }
392 #-----------------------------------------------
393 return ();
394 }
395  
396 sub GetKeyValue{
397 my ($self,$key)=@_;
398 if (defined $self->{DBMhash}->{$key}){
399 my $dat=$self->{DBMhash}->{$key};
400 my %FoundData=split(/\x00/,$dat);
401 &expandData(\%FoundData);
402 return %FoundData;
403 }
404 return ();
405 }
406  
407  
408  
409 ####################################################
410 # put 2 hash-structures together
411  
412 sub JoinComplexHashs{
413  
414 my ($data1,$data2)=@_;
415 if (not defined $data2->{freq}){$data2->{freq}=1;}
416 if (not defined $data1->{freq}){$data1->{freq}=1;}
417 $data1->{freq}+=$data2->{freq};
418 foreach my $key (keys %{$data2}){
419 if ($key eq 'freq'){next;}
420 if (defined $data1->{$key}){
421 if ((not ref($data2->{$key})) and
422 ($data1->{$key} eq $data2->{$key})){
423 next;
424 }
425 if (not ref($data1->{$key})){
426 my $old=$data1->{$key};
427 $data1->{$key}=[];
428 $data1->{$key}->[0]=$old;
429 }
430 if (not ref($data2->{$key})){
431 my $old=$data2->{$key};
432 $data2->{$key}=[];
433 $data2->{$key}->[0]=$old;
434 }
435 # if (ref($data1->{$key}) ne ref($data2->{$key})){
436 # my $old=$data1->{$key};
437 # my $new=$data2->{$key};
438 # $data1->{$key}=[];
439 # $data1->{$key}->[0]=$old;
440 # $Data::Dumper::Terse=1;
441 # $Data::Dumper::Purity=1;
442 # my $ValString=Dumper($data2->{$key});
443 # $data1->{$key}->[1]=$ValString;
444 # return;
445 # }
446 if (ref($data2->{$key}) eq 'ARRAY'){
447 push (@{$data1->{$key}},@{$data2->{$key}});
448 }
449 if (ref($data2->{$key}) eq 'HASH'){
450 foreach (keys %{$data2->{$key}}){
451 $data1->{$key}->{$_}=$data2->{$key}->{$_};
452 }
453 }
454 # $Data::Dumper::Terse=1;
455 # $Data::Dumper::Purity=1;
456 # my $DataString=Dumper($data1->{$key});
457 # delete $data1->{$key};
458 # $data1->{$key}=eval $DataString;
459 }
460 else{
461 if (ref($data2->{$key})){
462 $Data::Dumper::Terse=1;
463 $Data::Dumper::Purity=1;
464 my $ValString=Dumper($data2->{$key});
465 $data1->{$key}=eval $ValString;
466 }
467 else{
468 $data1->{$key}=$data2->{$key};
469 }
470 }
471 }
472 return $data1;
473 }
474  
475  
476 #######################################
477  
478 sub expandData{
479 my ($data)=@_;
480 my %FlatHash=%{$data};
481 my $VAR1;
482 foreach (keys %FlatHash){
483 if ($FlatHash{$_}=~/^\s*\$VAR1\s*\=/){
484 $data->{$_}=eval $FlatHash{$_};
485 }
486 }
487 return %{$data};
488 }
489  
490 sub dumpData{
491 my ($data)=@_;
492 my %FlatHash;
493 my $VAR1;
494 foreach (keys %{$data}){
495 if (ref($data->{$_})){
496 $Data::Dumper::Indent=0;
497 $Data::Dumper::Terse=0;
498 $Data::Dumper::Purity=1;
499 $FlatHash{$_}=Dumper($data->{$_});
500 }
501 else{
502 $FlatHash{$_}=$data->{$_};
503 }
504 }
505 return %FlatHash;
506 }
507  
508  
509 #######################################
510  
511 1;