/[webpac2]/trunk/lib/WebPAC/Input.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 /trunk/lib/WebPAC/Input.pm

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

revision 483 by dpavlin, Sun May 14 09:34:05 2006 UTC revision 800 by dpavlin, Sun Feb 4 23:10:18 2007 UTC
# Line 3  package WebPAC::Input; Line 3  package WebPAC::Input;
3  use warnings;  use warnings;
4  use strict;  use strict;
5    
6  use WebPAC::Common 0.03;  use blib;
7    
8    use WebPAC::Common;
9  use base qw/WebPAC::Common/;  use base qw/WebPAC::Common/;
10  use Text::Iconv;  use Data::Dump qw/dump/;
11  use Data::Dumper;  use Encode qw/from_to/;
12    
13  =head1 NAME  =head1 NAME
14    
# Line 14  WebPAC::Input - read different file form Line 16  WebPAC::Input - read different file form
16    
17  =head1 VERSION  =head1 VERSION
18    
19  Version 0.04  Version 0.17
20    
21  =cut  =cut
22    
23  our $VERSION = '0.04';  our $VERSION = '0.17';
24    
25  =head1 SYNOPSIS  =head1 SYNOPSIS
26    
# Line 37  C<fetch_rec> and optional C<init> functi Line 39  C<fetch_rec> and optional C<init> functi
39    
40  Perhaps a little code snippet.  Perhaps a little code snippet.
41    
42      use WebPAC::Input;          use WebPAC::Input;
43    
44      my $db = WebPAC::Input->new(          my $db = WebPAC::Input->new(
45          module => 'WebPAC::Input::ISIS',                  module => 'WebPAC::Input::ISIS',
46                  config => $config,          );
                 lookup => $lookup_obj,  
                 low_mem => 1,  
     );  
47    
48      $db->open('/path/to/database');          $db->open( path => '/path/to/database' );
49          print "database size: ",$db->size,"\n";          print "database size: ",$db->size,"\n";
50          while (my $rec = $db->fetch) {          while (my $rec = $db->fetch) {
51                  # do something with $rec                  # do something with $rec
# Line 62  Create new input database object. Line 61  Create new input database object.
61    
62    my $db = new WebPAC::Input(    my $db = new WebPAC::Input(
63          module => 'WebPAC::Input::MARC',          module => 'WebPAC::Input::MARC',
64          code_page => 'ISO-8859-2',          encoding => 'ISO-8859-2',
         low_mem => 1,  
65          recode => 'char pairs',          recode => 'char pairs',
66          no_progress_bar => 1,          no_progress_bar => 1,
67    );    );
68    
69  C<module> is low-level file format module. See L<WebPAC::Input::Isis> and  C<module> is low-level file format module. See L<WebPAC::Input::ISIS> and
70  L<WebPAC::Input::MARC>.  L<WebPAC::Input::MARC>.
71    
72  Optional parametar C<code_page> specify application code page (which will be  Optional parametar C<encoding> specify application code page (which will be
73  used internally). This should probably be your terminal encoding, and by  used internally). This should probably be your terminal encoding, and by
74  default, it C<ISO-8859-2>.  default, it C<ISO-8859-2>.
75    
 Default is not to use C<low_mem> options (see L<MEMORY USAGE> below).  
   
76  C<recode> is optional string constisting of character or words pairs that  C<recode> is optional string constisting of character or words pairs that
77  should be replaced in input stream.  should be replaced in input stream.
78    
# Line 94  sub new { Line 90  sub new {
90    
91          my $log = $self->_get_logger;          my $log = $self->_get_logger;
92    
93          $log->logconfess("specify low-level file format module") unless ($self->{module});          $log->logconfess("code_page argument is not suppored any more. change it to encoding") if ($self->{lookup});
94          my $module = $self->{module};          $log->logconfess("lookup argument is not suppored any more. rewrite call to lookup_ref") if ($self->{lookup});
95          $module =~ s#::#/#g;          $log->logconfess("low_mem argument is not suppored any more. rewrite it to load_row and save_row") if ($self->{low_mem});
         $module .= '.pm';  
         $log->debug("require low-level module $self->{module} from $module");  
   
         require $module;  
         #eval $self->{module} .'->import';  
   
         # check if required subclasses are implemented  
         foreach my $subclass (qw/open_db fetch_rec init/) {  
                 my $n = $self->{module} . '::' . $subclass;  
                 if (! defined &{ $n }) {  
                         my $missing = "missing $subclass in $self->{module}";  
                         $self->{$subclass} = sub { $log->logwarn($missing) };  
                 } else {  
                         $self->{$subclass} = \&{ $n };  
                 }  
         }  
   
         if ($self->{init}) {  
                 $log->debug("calling init");  
                 $self->{init}->($self, @_);  
         }  
   
         $self->{'code_page'} ||= 'ISO-8859-2';  
   
         # running with low_mem flag? well, use DBM::Deep then.  
         if ($self->{'low_mem'}) {  
                 $log->info("running with low_mem which impacts performance (<32 Mb memory usage)");  
   
                 my $db_file = "data.db";  
   
                 if (-e $db_file) {  
                         unlink $db_file or $log->logdie("can't remove '$db_file' from last run");  
                         $log->debug("removed '$db_file' from last run");  
                 }  
   
                 require DBM::Deep;  
   
                 my $db = new DBM::Deep $db_file;  
96    
97                  $log->logdie("DBM::Deep error: $!") unless ($db);          $log->logconfess("specify low-level file format module") unless ($self->{module});
98            my $module_path = $self->{module};
99            $module_path =~ s#::#/#g;
100            $module_path .= '.pm';
101            $log->debug("require low-level module $self->{module} from $module_path");
102    
103                  if ($db->error()) {          require $module_path;
                         $log->logdie("can't open '$db_file' under low_mem: ",$db->error());  
                 } else {  
                         $log->debug("using file '$db_file' for DBM::Deep");  
                 }  
104    
105                  $self->{'db'} = $db;          $self->{'encoding'} ||= 'ISO-8859-2';
         }  
106    
107          $self ? return $self : return undef;          $self ? return $self : return undef;
108  }  }
# Line 154  sub new { Line 111  sub new {
111    
112  This function will read whole database in memory and produce lookups.  This function will read whole database in memory and produce lookups.
113    
114     my $store;     # simple in-memory hash
115    
116   $input->open(   $input->open(
117          path => '/path/to/database/file',          path => '/path/to/database/file',
118          code_page => '852',          code_page => 'cp852',
119          limit => 500,          limit => 500,
120          offset => 6000,          offset => 6000,
121          lookup => $lookup_obj,          stats => 1,
122            lookup_coderef => sub {
123                    my $rec = shift;
124                    # store lookups
125            },
126            modify_records => {
127                    900 => { '^a' => { ' : ' => '^b' } },
128                    901 => { '*' => { '^b' => ' ; ' } },
129            },
130            modify_file => 'conf/modify/mapping.map',
131            save_row => sub {
132                    my $a = shift;
133                    $store->{ $a->{id} } = $a->{row};
134            },
135            load_row => sub {
136                    my $a = shift;
137                    return defined($store->{ $a->{id} }) &&
138                            $store->{ $a->{id} };
139            },
140    
141   );   );
142    
143  By default, C<code_page> is assumed to be C<852>.  By default, C<code_page> is assumed to be C<cp852>.
144    
145  C<offset> is optional parametar to position at some offset before reading from database.  C<offset> is optional parametar to position at some offset before reading from database.
146    
147  C<limit> is optional parametar to read just C<limit> records from database  C<limit> is optional parametar to read just C<limit> records from database
148    
149    C<stats> create optional report about usage of fields and subfields
150    
151    C<lookup_coderef> is closure to called to save data into lookups
152    
153    C<modify_records> specify mapping from subfields to delimiters or from
154    delimiters to subfields, as well as oprations on fields (if subfield is
155    defined as C<*>.
156    
157    C<modify_file> is alternative for C<modify_records> above which preserves order and offers
158    (hopefully) simplier sintax than YAML or perl (see L</modify_file_regex>). This option
159    overrides C<modify_records> if both exists for same input.
160    
161    C<save_row> and C<load_row> are low-level implementation of store engine. Calling convention
162    is documented in example above.
163    
164  Returns size of database, regardless of C<offset> and C<limit>  Returns size of database, regardless of C<offset> and C<limit>
165  parametars, see also C<size>.  parametars, see also C<size>.
166    
# Line 179  sub open { Line 172  sub open {
172    
173          my $log = $self->_get_logger();          my $log = $self->_get_logger();
174    
175            $log->logconfess("lookup argument is not suppored any more. rewrite call to lookup_coderef") if ($arg->{lookup});
176            $log->logconfess("lookup_coderef must be CODE, not ",ref($arg->{lookup_coderef}))
177                    if ($arg->{lookup_coderef} && ref($arg->{lookup_coderef}) ne 'CODE');
178    
179            $log->debug( $arg->{lookup_coderef} ? '' : 'not ', "using lookup_coderef");
180    
181          $log->logcroak("need path") if (! $arg->{'path'});          $log->logcroak("need path") if (! $arg->{'path'});
182          my $code_page = $arg->{'code_page'} || '852';          my $code_page = $arg->{'code_page'} || 'cp852';
183    
184          # store data in object          # store data in object
185          $self->{'input_code_page'} = $code_page;          $self->{'input_code_page'} = $code_page;
# Line 188  sub open { Line 187  sub open {
187                  $self->{$v} = $arg->{$v} if ($arg->{$v});                  $self->{$v} = $arg->{$v} if ($arg->{$v});
188          }          }
189    
190          # create Text::Iconv object          if ($arg->{load_row} || $arg->{save_row}) {
191          $self->{iconv} = Text::Iconv->new($code_page,$self->{'code_page'});                  $log->logconfess("save_row and load_row must be defined in pair and be CODE") unless (
192                            ref($arg->{load_row}) eq 'CODE' &&
193                            ref($arg->{save_row}) eq 'CODE'
194                    );
195                    $self->{load_row} = $arg->{load_row};
196                    $self->{save_row} = $arg->{save_row};
197                    $log->debug("using load_row and save_row instead of in-memory hash");
198            }
199    
200          my $filter_ref;          my $filter_ref;
201            my $recode_regex;
202            my $recode_map;
203    
204          if ($self->{recode}) {          if ($self->{recode}) {
205                  my @r = split(/\s/, $self->{recode});                  my @r = split(/\s/, $self->{recode});
206                  if ($#r % 2 != 1) {                  if ($#r % 2 != 1) {
207                          $log->logwarn("recode needs even number of elements (some number of valid pairs)");                          $log->logwarn("recode needs even number of elements (some number of valid pairs)");
208                  } else {                  } else {
                         my $recode;  
209                          while (@r) {                          while (@r) {
210                                  my $from = shift @r;                                  my $from = shift @r;
211                                  my $to = shift @r;                                  my $to = shift @r;
212                                  $recode->{$from} = $to;                                  $recode_map->{$from} = $to;
213                          }                          }
214    
215                          my $regex = join '|' => keys %{ $recode };                          $recode_regex = join '|' => keys %{ $recode_map };
   
                         $log->debug("using recode regex: $regex");  
                           
                         $filter_ref = sub {  
                                 my $t = shift;  
                                 $t =~ s/($regex)/$recode->{$1}/g;  
                                 return $t;  
                         };  
216    
217                            $log->debug("using recode regex: $recode_regex");
218                  }                  }
219    
220          }          }
221    
222          my ($db, $size) = $self->{open_db}->( $self,          my $rec_regex;
223            if (my $p = $arg->{modify_file}) {
224                    $log->debug("using modify_file $p");
225                    $rec_regex = $self->modify_file_regexps( $p );
226            } elsif (my $h = $arg->{modify_records}) {
227                    $log->debug("using modify_records ", sub { dump( $h ) });
228                    $rec_regex = $self->modify_record_regexps(%{ $h });
229            }
230            $log->debug("rec_regex: ", sub { dump($rec_regex) }) if ($rec_regex);
231    
232            my $class = $self->{module} || $log->logconfess("can't get low-level module name!");
233    
234            my $ll_db = $class->new(
235                  path => $arg->{path},                  path => $arg->{path},
236                  filter => $filter_ref,  #               filter => sub {
237    #                       my ($l,$f_nr) = @_;
238    #                       return unless defined($l);
239    #                       from_to($l, $code_page, $self->{'encoding'});
240    #                       $l =~ s/($recode_regex)/$recode_map->{$1}/g if ($recode_regex && $recode_map);
241    #                       return $l;
242    #               },
243                    %{ $arg },
244          );          );
245    
246          unless ($db) {          unless (defined($ll_db)) {
247                  $log->logwarn("can't open database $arg->{path}, skipping...");                  $log->logwarn("can't open database $arg->{path}, skipping...");
248                  return;                  return;
249          }          }
250    
251            my $size = $ll_db->size;
252    
253          unless ($size) {          unless ($size) {
254                  $log->logwarn("no records in database $arg->{path}, skipping...");                  $log->logwarn("no records in database $arg->{path}, skipping...");
255                  return;                  return;
# Line 238  sub open { Line 259  sub open {
259          my $to_rec = $size;          my $to_rec = $size;
260    
261          if (my $s = $self->{offset}) {          if (my $s = $self->{offset}) {
262                  $log->info("skipping to MFN $s");                  $log->debug("skipping to MFN $s");
263                  $from_rec = $s;                  $from_rec = $s;
264          } else {          } else {
265                  $self->{offset} = $from_rec;                  $self->{offset} = $from_rec;
# Line 253  sub open { Line 274  sub open {
274          # store size for later          # store size for later
275          $self->{size} = ($to_rec - $from_rec) ? ($to_rec - $from_rec + 1) : 0;          $self->{size} = ($to_rec - $from_rec) ? ($to_rec - $from_rec + 1) : 0;
276    
277          $log->info("processing $self->{size}/$size records [$from_rec-$to_rec] convert $code_page -> $self->{code_page}");          $log->info("processing $self->{size}/$size records [$from_rec-$to_rec] convert $code_page -> $self->{encoding}", $self->{stats} ? ' [stats]' : '');
278    
279          # read database          # read database
280          for (my $pos = $from_rec; $pos <= $to_rec; $pos++) {          for (my $pos = $from_rec; $pos <= $to_rec; $pos++) {
281    
282                  $log->debug("position: $pos\n");                  $log->debug("position: $pos\n");
283    
284                  my $rec = $self->{fetch_rec}->($self, $db, $pos );                  my $rec = $ll_db->fetch_rec($pos, sub {
285                                    my ($l,$f_nr,$debug) = @_;
286    #                               return unless defined($l);
287    #                               return $l unless ($rec_regex && $f_nr);
288    
289                                    warn "-=> $f_nr ## |$l|\n" if ($debug);
290                                    $log->debug("-=> $f_nr ## $l");
291    
292                                    # codepage conversion and recode_regex
293                                    from_to($l, $code_page, $self->{'encoding'});
294                                    $l =~ s/($recode_regex)/$recode_map->{$1}/g if ($recode_regex && $recode_map);
295    
296                                    # apply regexps
297                                    if ($rec_regex && defined($rec_regex->{$f_nr})) {
298                                            $log->logconfess("regexps->{$f_nr} must be ARRAY") if (ref($rec_regex->{$f_nr}) ne 'ARRAY');
299                                            my $c = 0;
300                                            foreach my $r (@{ $rec_regex->{$f_nr} }) {
301                                                    my $old_l = $l;
302                                                    $log->logconfess("expected regex in ", dump( $r )) unless defined($r->{regex});
303                                                    eval '$l =~ ' . $r->{regex};
304                                                    if ($old_l ne $l) {
305                                                            my $d = "|$old_l| -> |$l| "; # . $r->{regex};
306                                                            $d .= ' +' . $r->{line} . ' ' . $r->{file} if defined($r->{line});
307                                                            $d .= ' ' . $r->{debug} if defined($r->{debug});
308                                                            $log->debug("MODIFY $d");
309                                                            warn "*** $d\n" if ($debug);
310    
311                                                    }
312                                                    $log->error("error applying regex: $r") if ($@);
313                                            }
314                                    }
315    
316                                    $log->debug("<=- $f_nr ## |$l|");
317                                    warn "<=- $f_nr ## $l\n" if ($debug);
318                                    return $l;
319                    });
320    
321                  $log->debug(sub { Dumper($rec) });                  $log->debug(sub { dump($rec) });
322    
323                  if (! $rec) {                  if (! $rec) {
324                          $log->warn("record $pos empty? skipping...");                          $log->warn("record $pos empty? skipping...");
# Line 270  sub open { Line 326  sub open {
326                  }                  }
327    
328                  # store                  # store
329                  if ($self->{low_mem}) {                  if ($self->{save_row}) {
330                          $self->{db}->put($pos, $rec);                          $self->{save_row}->({
331                                    id => $pos,
332                                    row => $rec,
333                            });
334                  } else {                  } else {
335                          $self->{data}->{$pos} = $rec;                          $self->{data}->{$pos} = $rec;
336                  }                  }
337    
338                  # create lookup                  # create lookup
339                  $self->{'lookup'}->add( $rec ) if ($rec && $self->{'lookup'});                  $arg->{'lookup_coderef'}->( $rec ) if ($rec && $arg->{'lookup_coderef'});
340    
341                    # update counters for statistics
342                    if ($self->{stats}) {
343    
344                            # fetch clean record with regexpes applied for statistics
345                            my $rec = $ll_db->fetch_rec($pos);
346    
347                            foreach my $fld (keys %{ $rec }) {
348                                    $self->{_stats}->{fld}->{ $fld }++;
349    
350                                    $log->logdie("invalid record fild $fld, not ARRAY")
351                                            unless (ref($rec->{ $fld }) eq 'ARRAY');
352            
353                                    foreach my $row (@{ $rec->{$fld} }) {
354    
355                                            if (ref($row) eq 'HASH') {
356    
357                                                    foreach my $sf (keys %{ $row }) {
358                                                            next if ($sf eq 'subfields');
359                                                            $self->{_stats}->{sf}->{ $fld }->{ $sf }->{count}++;
360                                                            $self->{_stats}->{sf}->{ $fld }->{ $sf }->{repeatable}++
361                                                                            if (ref($row->{$sf}) eq 'ARRAY');
362                                                    }
363    
364                                            } else {
365                                                    $self->{_stats}->{repeatable}->{ $fld }++;
366                                            }
367                                    }
368                            }
369                    }
370    
371                  $self->progress_bar($pos,$to_rec) unless ($self->{no_progress_bar});                  $self->progress_bar($pos,$to_rec) unless ($self->{no_progress_bar});
372    
# Line 290  sub open { Line 379  sub open {
379          $self->{max_pos} = $to_rec;          $self->{max_pos} = $to_rec;
380          $log->debug("max_pos: $to_rec");          $log->debug("max_pos: $to_rec");
381    
382            # save for dump
383            $self->{ll_db} = $ll_db;
384    
385          return $size;          return $size;
386  }  }
387    
# Line 329  sub fetch { Line 421  sub fetch {
421    
422          my $rec;          my $rec;
423    
424          if ($self->{low_mem}) {          if ($self->{load_row}) {
425                  $rec = $self->{db}->get($mfn);                  $rec = $self->{load_row}->({ id => $mfn });
426          } else {          } else {
427                  $rec = $self->{data}->{$mfn};                  $rec = $self->{data}->{$mfn};
428          }          }
# Line 385  First record in database has position 1. Line 477  First record in database has position 1.
477    
478  sub seek {  sub seek {
479          my $self = shift;          my $self = shift;
480          my $pos = shift || return;          my $pos = shift;
481    
482          my $log = $self->_get_logger();          my $log = $self->_get_logger();
483    
484            $log->logconfess("called without pos") unless defined($pos);
485    
486          if ($pos < 1) {          if ($pos < 1) {
487                  $log->warn("seek before first record");                  $log->warn("seek before first record");
488                  $pos = 1;                  $pos = 1;
# Line 400  sub seek { Line 494  sub seek {
494          return $self->{pos} = (($pos - 1) || -1);          return $self->{pos} = (($pos - 1) || -1);
495  }  }
496    
497    =head2 stats
498    
499    Dump statistics about field and subfield usage
500    
501      print $input->stats;
502    
503    =cut
504    
505    sub stats {
506            my $self = shift;
507    
508            my $log = $self->_get_logger();
509    
510            my $s = $self->{_stats};
511            if (! $s) {
512                    $log->warn("called stats, but there is no statistics collected");
513                    return;
514            }
515    
516            my $max_fld = 0;
517    
518            my $out = join("\n",
519                    map {
520                            my $f = $_ || die "no field";
521                            my $v = $s->{fld}->{$f} || die "no s->{fld}->{$f}";
522                            $max_fld = $v if ($v > $max_fld);
523    
524                            my $o = sprintf("%4s %d ~", $f, $v);
525    
526                            if (defined($s->{sf}->{$f})) {
527                                    map {
528                                            $o .= sprintf(" %s:%d%s", $_,
529                                                    $s->{sf}->{$f}->{$_}->{count},
530                                                    $s->{sf}->{$f}->{$_}->{repeatable} ? '*' : '',
531                                            );
532                                    } sort keys %{ $s->{sf}->{$f} };
533                            }
534    
535                            if (my $v_r = $s->{repeatable}->{$f}) {
536                                    $o .= " ($v_r)" if ($v_r != $v);
537                            }
538    
539                            $o;
540                    } sort { $a cmp $b } keys %{ $s->{fld} }
541            );
542    
543            $log->debug( sub { dump($s) } );
544    
545            return $out;
546    }
547    
548    =head2 dump_ascii
549    
550    Display humanly readable dump of record
551    
552    =cut
553    
554    sub dump_ascii {
555            my $self = shift;
556    
557            return unless $self->{ll_db};
558    
559            if ($self->{ll_db}->can('dump_rec')) {
560                    return $self->{ll_db}->dump_ascii( $self->{pos} );
561            } else {
562                    return dump( $self->{ll_db}->fetch_rec( $self->{pos} ) );
563            }
564    }
565    
566    =head2 modify_record_regexps
567    
568    Generate hash with regexpes to be applied using L<filter>.
569    
570      my $regexpes = $input->modify_record_regexps(
571                    900 => { '^a' => { ' : ' => '^b' } },
572                    901 => { '*' => { '^b' => ' ; ' } },
573      );
574    
575    =cut
576    
577    sub _get_regex {
578            my ($sf,$from,$to) = @_;
579    
580            # protect /
581            $from =~ s!/!\\/!gs;
582            $to =~ s!/!\\/!gs;
583    
584            if ($from =~ m/^regex:(.+)$/) {
585                    $from = $1;
586            } else {
587                    $from = '\Q' . $from . '\E';
588            }
589            if ($sf =~ /^\^/) {
590                    return
591                            's/\Q'. $sf .'\E([^\^]*?)'. $from .'([^\^]*?)/'. $sf .'$1'. $to .'$2/';
592            } else {
593                    return
594                            's/'. $from .'/'. $to .'/g';
595            }
596    }
597    
598    sub modify_record_regexps {
599            my $self = shift;
600            my $modify_record = {@_};
601    
602            my $regexpes;
603    
604            my $log = $self->_get_logger();
605    
606            foreach my $f (keys %$modify_record) {
607                    $log->debug("field: $f");
608    
609                    foreach my $sf (keys %{ $modify_record->{$f} }) {
610                            $log->debug("subfield: $sf");
611    
612                            foreach my $from (keys %{ $modify_record->{$f}->{$sf} }) {
613                                    my $to = $modify_record->{$f}->{$sf}->{$from};
614                                    #die "no field?" unless defined($to);
615                                    my $d = "|$from| -> |$to|";
616                                    $log->debug("transform: $d");
617    
618                                    my $regex = _get_regex($sf,$from,$to);
619                                    push @{ $regexpes->{$f} }, { regex => $regex, debug => $d };
620                                    $log->debug("regex: $regex");
621                            }
622                    }
623            }
624    
625            return $regexpes;
626    }
627    
628    =head2 modify_file_regexps
629    
630    Generate hash with regexpes to be applied using L<filter> from
631    pseudo hash/yaml format for regex mappings.
632    
633    It should be obvious:
634    
635  =head1 MEMORY USAGE          200
636              '^a'
637                ' : ' => '^e'
638                ' = ' => '^d'
639    
640  C<low_mem> options is double-edged sword. If enabled, WebPAC  In field I<200> find C<'^a'> and then C<' : '>, and replace it with C<'^e'>.
641  will run on memory constraint machines (which doesn't have enough  In field I<200> find C<'^a'> and then C<' = '>, and replace it with C<'^d'>.
642  physical RAM to create memory structure for whole source database).  
643      my $regexpes = $input->modify_file_regexps( 'conf/modify/common.pl' );
644  If your machine has 512Mb or more of RAM and database is around 10000 records,  
645  memory shouldn't be an issue. If you don't have enough physical RAM, you  On undef path it will just return.
646  might consider using virtual memory (if your operating system is handling it  
647  well, like on FreeBSD or Linux) instead of dropping to L<DBM::Deep> to handle  =cut
 parsed structure of ISIS database (this is what C<low_mem> option does).  
   
 Hitting swap at end of reading source database is probably o.k. However,  
 hitting swap before 90% will dramatically decrease performance and you will  
 be better off with C<low_mem> and using rest of availble memory for  
 operating system disk cache (Linux is particuallary good about this).  
 However, every access to database record will require disk access, so  
 generation phase will be slower 10-100 times.  
   
 Parsed structures are essential - you just have option to trade RAM memory  
 (which is fast) for disk space (which is slow). Be sure to have planty of  
 disk space if you are using C<low_mem> and thus L<DBM::Deep>.  
   
 However, when WebPAC is running on desktop machines (or laptops :-), it's  
 highly undesireable for system to start swapping. Using C<low_mem> option can  
 reduce WecPAC memory usage to around 64Mb for same database with lookup  
 fields and sorted indexes which stay in RAM. Performance will suffer, but  
 memory usage will really be minimal. It might be also more confortable to  
 run WebPAC reniced on those machines.  
648    
649    sub modify_file_regexps {
650            my $self = shift;
651    
652            my $modify_path = shift || return;
653    
654            my $log = $self->_get_logger();
655    
656            my $regexpes;
657    
658            CORE::open(my $fh, $modify_path) || $log->logdie("can't open modify file $modify_path: $!");
659    
660            my ($f,$sf);
661    
662            while(<$fh>) {
663                    chomp;
664                    next if (/^#/ || /^\s*$/);
665    
666                    if (/^\s*(\d+)\s*$/) {
667                            $f = $1;
668                            $log->debug("field: $f");
669                            next;
670                    } elsif (/^\s*'([^']*)'\s*$/) {
671                            $sf = $1;
672                            $log->die("can't define subfiled before field in: $_") unless ($f);
673                            $log->debug("subfield: $sf");
674                    } elsif (/^\s*'([^']*)'\s*=>\s*'([^']*)'\s*$/) {
675                            my ($from,$to) = ($1, $2);
676    
677                            $log->debug("transform: |$from| -> |$to|");
678    
679                            my $regex = _get_regex($sf,$from,$to);
680                            push @{ $regexpes->{$f} }, {
681                                    regex => $regex,
682                                    file => $modify_path,
683                                    line => $.,
684                            };
685                            $log->debug("regex: $regex");
686                    }
687            }
688    
689            return $regexpes;
690    }
691    
692  =head1 AUTHOR  =head1 AUTHOR
693    
# Line 438  Dobrica Pavlinusic, C<< <dpavlin@rot13.o Line 695  Dobrica Pavlinusic, C<< <dpavlin@rot13.o
695    
696  =head1 COPYRIGHT & LICENSE  =head1 COPYRIGHT & LICENSE
697    
698  Copyright 2005 Dobrica Pavlinusic, All Rights Reserved.  Copyright 2005-2006 Dobrica Pavlinusic, All Rights Reserved.
699    
700  This program is free software; you can redistribute it and/or modify it  This program is free software; you can redistribute it and/or modify it
701  under the same terms as Perl itself.  under the same terms as Perl itself.
Legend:
Removed from v.483  
changed lines
  Added in v.800
  ViewVC Help
Powered by ViewVC 1.1.26