/[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 636 by dpavlin, Wed Sep 6 19:25:22 2006 UTC revision 868 by dpavlin, Thu Jun 21 21:26:17 2007 UTC
# Line 7  use blib; Line 7  use blib;
7    
8  use WebPAC::Common;  use WebPAC::Common;
9  use base qw/WebPAC::Common/;  use base qw/WebPAC::Common/;
10  use Data::Dumper;  use Data::Dump qw/dump/;
11  use Encode qw/from_to/;  use Encode qw/from_to/;
12    
13  =head1 NAME  =head1 NAME
# Line 16  WebPAC::Input - read different file form Line 16  WebPAC::Input - read different file form
16    
17  =head1 VERSION  =head1 VERSION
18    
19  Version 0.12  Version 0.18
20    
21  =cut  =cut
22    
23  our $VERSION = '0.12';  our $VERSION = '0.18';
24    
25  =head1 SYNOPSIS  =head1 SYNOPSIS
26    
# Line 43  Perhaps a little code snippet. Line 43  Perhaps a little code snippet.
43    
44          my $db = WebPAC::Input->new(          my $db = WebPAC::Input->new(
45                  module => 'WebPAC::Input::ISIS',                  module => 'WebPAC::Input::ISIS',
                 low_mem => 1,  
46          );          );
47    
48          $db->open( path => '/path/to/database' );          $db->open( path => '/path/to/database' );
# Line 63  Create new input database object. Line 62  Create new input database object.
62    my $db = new WebPAC::Input(    my $db = new WebPAC::Input(
63          module => 'WebPAC::Input::MARC',          module => 'WebPAC::Input::MARC',
64          encoding => '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            input_config => {
68                    mapping => [ 'foo', 'bar', 'baz' ],
69            },
70    );    );
71    
72  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
# Line 75  Optional parametar C<encoding> specify a Line 76  Optional parametar C<encoding> specify a
76  used internally). This should probably be your terminal encoding, and by  used internally). This should probably be your terminal encoding, and by
77  default, it C<ISO-8859-2>.  default, it C<ISO-8859-2>.
78    
 Default is not to use C<low_mem> options (see L<MEMORY USAGE> below).  
   
79  C<recode> is optional string constisting of character or words pairs that  C<recode> is optional string constisting of character or words pairs that
80  should be replaced in input stream.  should be replaced in input stream.
81    
# Line 96  sub new { Line 95  sub new {
95    
96          $log->logconfess("code_page argument is not suppored any more. change it to encoding") if ($self->{lookup});          $log->logconfess("code_page argument is not suppored any more. change it to encoding") if ($self->{lookup});
97          $log->logconfess("lookup argument is not suppored any more. rewrite call to lookup_ref") if ($self->{lookup});          $log->logconfess("lookup argument is not suppored any more. rewrite call to lookup_ref") if ($self->{lookup});
98            $log->logconfess("low_mem argument is not suppored any more. rewrite it to load_row and save_row") if ($self->{low_mem});
99    
100          $log->logconfess("specify low-level file format module") unless ($self->{module});          $log->logconfess("specify low-level file format module") unless ($self->{module});
101          my $module = $self->{module};          my $module_path = $self->{module};
102          $module =~ s#::#/#g;          $module_path =~ s#::#/#g;
103          $module .= '.pm';          $module_path .= '.pm';
104          $log->debug("require low-level module $self->{module} from $module");          $log->debug("require low-level module $self->{module} from $module_path");
   
         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 };  
                 }  
         }  
105    
106          if ($self->{init}) {          require $module_path;
                 $log->debug("calling init");  
                 $self->{init}->($self, @_);  
         }  
107    
108          $self->{'encoding'} ||= 'ISO-8859-2';          $self->{'encoding'} ||= 'ISO-8859-2';
109    
         # 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;  
   
                 $log->logdie("DBM::Deep error: $!") unless ($db);  
   
                 if ($db->error()) {  
                         $log->logdie("can't open '$db_file' under low_mem: ",$db->error());  
                 } else {  
                         $log->debug("using file '$db_file' for DBM::Deep");  
                 }  
   
                 $self->{'db'} = $db;  
         }  
   
110          $self ? return $self : return undef;          $self ? return $self : return undef;
111  }  }
112    
# Line 157  sub new { Line 114  sub new {
114    
115  This function will read whole database in memory and produce lookups.  This function will read whole database in memory and produce lookups.
116    
117     my $store;     # simple in-memory hash
118    
119   $input->open(   $input->open(
120          path => '/path/to/database/file',          path => '/path/to/database/file',
121          code_page => 'cp852',          code_page => 'cp852',
122          limit => 500,          limit => 500,
123          offset => 6000,          offset => 6000,
         lookup => $lookup_obj,  
124          stats => 1,          stats => 1,
125          lookup_ref => sub {          lookup_coderef => sub {
126                  my ($k,$v) = @_;                  my $rec = shift;
127                  # store lookup $k => $v                  # store lookups
128          },          },
129          modify_records => {          modify_records => {
130                  900 => { '^a' => { ' : ' => '^b' } },                  900 => { '^a' => { ' : ' => '^b' } },
131                  901 => { '*' => { '^b' => ' ; ' } },                  901 => { '*' => { '^b' => ' ; ' } },
132          },          },
133          modify_file => 'conf/modify/mapping.map',          modify_file => 'conf/modify/mapping.map',
134            save_row => sub {
135                    my $a = shift;
136                    $store->{ $a->{id} } = $a->{row};
137            },
138            load_row => sub {
139                    my $a = shift;
140                    return defined($store->{ $a->{id} }) &&
141                            $store->{ $a->{id} };
142            },
143    
144   );   );
145    
146  By default, C<code_page> is assumed to be C<cp852>.  By default, C<code_page> is assumed to be C<cp852>.
# Line 183  C<limit> is optional parametar to read j Line 151  C<limit> is optional parametar to read j
151    
152  C<stats> create optional report about usage of fields and subfields  C<stats> create optional report about usage of fields and subfields
153    
154  C<lookup_coderef> is closure to call when adding C<< key => 'value' >> combinations to  C<lookup_coderef> is closure to called to save data into lookups
 lookup.  
155    
156  C<modify_records> specify mapping from subfields to delimiters or from  C<modify_records> specify mapping from subfields to delimiters or from
157  delimiters to subfields, as well as oprations on fields (if subfield is  delimiters to subfields, as well as oprations on fields (if subfield is
# Line 194  C<modify_file> is alternative for C<modi Line 161  C<modify_file> is alternative for C<modi
161  (hopefully) simplier sintax than YAML or perl (see L</modify_file_regex>). This option  (hopefully) simplier sintax than YAML or perl (see L</modify_file_regex>). This option
162  overrides C<modify_records> if both exists for same input.  overrides C<modify_records> if both exists for same input.
163    
164    C<save_row> and C<load_row> are low-level implementation of store engine. Calling convention
165    is documented in example above.
166    
167  Returns size of database, regardless of C<offset> and C<limit>  Returns size of database, regardless of C<offset> and C<limit>
168  parametars, see also C<size>.  parametars, see also C<size>.
169    
# Line 209  sub open { Line 179  sub open {
179          $log->logconfess("lookup_coderef must be CODE, not ",ref($arg->{lookup_coderef}))          $log->logconfess("lookup_coderef must be CODE, not ",ref($arg->{lookup_coderef}))
180                  if ($arg->{lookup_coderef} && ref($arg->{lookup_coderef}) ne 'CODE');                  if ($arg->{lookup_coderef} && ref($arg->{lookup_coderef}) ne 'CODE');
181    
182            $log->debug( $arg->{lookup_coderef} ? '' : 'not ', "using lookup_coderef");
183    
184          $log->logcroak("need path") if (! $arg->{'path'});          $log->logcroak("need path") if (! $arg->{'path'});
185          my $code_page = $arg->{'code_page'} || 'cp852';          my $code_page = $arg->{'code_page'} || 'cp852';
186    
# Line 218  sub open { Line 190  sub open {
190                  $self->{$v} = $arg->{$v} if ($arg->{$v});                  $self->{$v} = $arg->{$v} if ($arg->{$v});
191          }          }
192    
193            if ($arg->{load_row} || $arg->{save_row}) {
194                    $log->logconfess("save_row and load_row must be defined in pair and be CODE") unless (
195                            ref($arg->{load_row}) eq 'CODE' &&
196                            ref($arg->{save_row}) eq 'CODE'
197                    );
198                    $self->{load_row} = $arg->{load_row};
199                    $self->{save_row} = $arg->{save_row};
200                    $log->debug("using load_row and save_row instead of in-memory hash");
201            }
202    
203          my $filter_ref;          my $filter_ref;
204          my $recode_regex;          my $recode_regex;
205          my $recode_map;          my $recode_map;
# Line 245  sub open { Line 227  sub open {
227                  $log->debug("using modify_file $p");                  $log->debug("using modify_file $p");
228                  $rec_regex = $self->modify_file_regexps( $p );                  $rec_regex = $self->modify_file_regexps( $p );
229          } elsif (my $h = $arg->{modify_records}) {          } elsif (my $h = $arg->{modify_records}) {
230                  $log->debug("using modify_records ", Dumper( $h ));                  $log->debug("using modify_records ", sub { dump( $h ) });
231                  $rec_regex = $self->modify_record_regexps(%{ $h });                  $rec_regex = $self->modify_record_regexps(%{ $h });
232          }          }
233          $log->debug("rec_regex: ", Dumper($rec_regex)) if ($rec_regex);          $log->debug("rec_regex: ", sub { dump($rec_regex) }) if ($rec_regex);
234    
235            my $class = $self->{module} || $log->logconfess("can't get low-level module name!");
236    
237          my ($db, $size) = $self->{open_db}->( $self,          my $ll_db = $class->new(
238                  path => $arg->{path},                  path => $arg->{path},
239                    input_config => $arg->{input_config},
240  #               filter => sub {  #               filter => sub {
241  #                       my ($l,$f_nr) = @_;  #                       my ($l,$f_nr) = @_;
242  #                       return unless defined($l);  #                       return unless defined($l);
# Line 262  sub open { Line 247  sub open {
247                  %{ $arg },                  %{ $arg },
248          );          );
249    
250          unless (defined($db)) {          unless (defined($ll_db)) {
251                  $log->logwarn("can't open database $arg->{path}, skipping...");                  $log->logwarn("can't open database $arg->{path}, skipping...");
252                  return;                  return;
253          }          }
254    
255            my $size = $ll_db->size;
256    
257          unless ($size) {          unless ($size) {
258                  $log->logwarn("no records in database $arg->{path}, skipping...");                  $log->logwarn("no records in database $arg->{path}, skipping...");
259                  return;                  return;
# Line 298  sub open { Line 285  sub open {
285    
286                  $log->debug("position: $pos\n");                  $log->debug("position: $pos\n");
287    
288                  my $rec = $self->{fetch_rec}->($self, $db, $pos, sub {                  my $rec = $ll_db->fetch_rec($pos, sub {
289                                  my ($l,$f_nr) = @_;                                  my ($l,$f_nr,$debug) = @_;
290  #                               return unless defined($l);  #                               return unless defined($l);
291  #                               return $l unless ($rec_regex && $f_nr);  #                               return $l unless ($rec_regex && $f_nr);
292    
293                                    return unless ( defined($l) && defined($f_nr) );
294    
295                                    warn "-=> $f_nr ## |$l|\n" if ($debug);
296                                  $log->debug("-=> $f_nr ## $l");                                  $log->debug("-=> $f_nr ## $l");
297    
298                                  # codepage conversion and recode_regex                                  # codepage conversion and recode_regex
# Line 315  sub open { Line 305  sub open {
305                                          my $c = 0;                                          my $c = 0;
306                                          foreach my $r (@{ $rec_regex->{$f_nr} }) {                                          foreach my $r (@{ $rec_regex->{$f_nr} }) {
307                                                  my $old_l = $l;                                                  my $old_l = $l;
308                                                  eval '$l =~ ' . $r;                                                  $log->logconfess("expected regex in ", dump( $r )) unless defined($r->{regex});
309                                                    eval '$l =~ ' . $r->{regex};
310                                                  if ($old_l ne $l) {                                                  if ($old_l ne $l) {
311                                                          $log->debug("REGEX on $f_nr eval \$l =~ $r\n## old l: [$old_l]\n## new l: [$l]");                                                          my $d = "|$old_l| -> |$l| "; # . $r->{regex};
312                                                            $d .= ' +' . $r->{line} . ' ' . $r->{file} if defined($r->{line});
313                                                            $d .= ' ' . $r->{debug} if defined($r->{debug});
314                                                            $log->debug("MODIFY $d");
315                                                            warn "*** $d\n" if ($debug);
316    
317                                                  }                                                  }
318                                                  $log->error("error applying regex: $r") if ($@);                                                  $log->error("error applying regex: $r") if ($@);
319                                          }                                          }
320                                  }                                  }
321    
322                                  $log->debug("<=- $f_nr ## $l");                                  $log->debug("<=- $f_nr ## |$l|");
323                                    warn "<=- $f_nr ## $l\n" if ($debug);
324                                  return $l;                                  return $l;
325                  });                  });
326    
327                  $log->debug(sub { Dumper($rec) });                  $log->debug(sub { dump($rec) });
328    
329                  if (! $rec) {                  if (! $rec) {
330                          $log->warn("record $pos empty? skipping...");                          $log->warn("record $pos empty? skipping...");
# Line 335  sub open { Line 332  sub open {
332                  }                  }
333    
334                  # store                  # store
335                  if ($self->{low_mem}) {                  if ($self->{save_row}) {
336                          $self->{db}->put($pos, $rec);                          $self->{save_row}->({
337                                    id => $pos,
338                                    row => $rec,
339                            });
340                  } else {                  } else {
341                          $self->{data}->{$pos} = $rec;                          $self->{data}->{$pos} = $rec;
342                  }                  }
# Line 348  sub open { Line 348  sub open {
348                  if ($self->{stats}) {                  if ($self->{stats}) {
349    
350                          # fetch clean record with regexpes applied for statistics                          # fetch clean record with regexpes applied for statistics
351                          my $rec = $self->{fetch_rec}->($self, $db, $pos);                          my $rec = $ll_db->fetch_rec($pos);
352    
353                          foreach my $fld (keys %{ $rec }) {                          foreach my $fld (keys %{ $rec }) {
354                                  $self->{_stats}->{fld}->{ $fld }++;                                  $self->{_stats}->{fld}->{ $fld }++;
# Line 385  sub open { Line 385  sub open {
385          $self->{max_pos} = $to_rec;          $self->{max_pos} = $to_rec;
386          $log->debug("max_pos: $to_rec");          $log->debug("max_pos: $to_rec");
387    
388            # save for dump
389            $self->{ll_db} = $ll_db;
390    
391          return $size;          return $size;
392  }  }
393    
# Line 424  sub fetch { Line 427  sub fetch {
427    
428          my $rec;          my $rec;
429    
430          if ($self->{low_mem}) {          if ($self->{load_row}) {
431                  $rec = $self->{db}->get($mfn);                  $rec = $self->{load_row}->({ id => $mfn });
432          } else {          } else {
433                  $rec = $self->{data}->{$mfn};                  $rec = $self->{data}->{$mfn};
434          }          }
# Line 480  First record in database has position 1. Line 483  First record in database has position 1.
483    
484  sub seek {  sub seek {
485          my $self = shift;          my $self = shift;
486          my $pos = shift || return;          my $pos = shift;
487    
488          my $log = $self->_get_logger();          my $log = $self->_get_logger();
489    
490            $log->logconfess("called without pos") unless defined($pos);
491    
492          if ($pos < 1) {          if ($pos < 1) {
493                  $log->warn("seek before first record");                  $log->warn("seek before first record");
494                  $pos = 1;                  $pos = 1;
# Line 518  sub stats { Line 523  sub stats {
523    
524          my $out = join("\n",          my $out = join("\n",
525                  map {                  map {
526                          my $f = $_ || die "no field";                          my $f = $_;
527                            die "no field in ", dump( $s->{fld} ) unless defined( $f );
528                          my $v = $s->{fld}->{$f} || die "no s->{fld}->{$f}";                          my $v = $s->{fld}->{$f} || die "no s->{fld}->{$f}";
529                          $max_fld = $v if ($v > $max_fld);                          $max_fld = $v if ($v > $max_fld);
530    
# Line 538  sub stats { Line 544  sub stats {
544                          }                          }
545    
546                          $o;                          $o;
547                  } sort { $a cmp $b } keys %{ $s->{fld} }                  } sort { $a <=> $b } keys %{ $s->{fld} }
548          );          );
549    
550          $log->debug( sub { Dumper($s) } );          $log->debug( sub { dump($s) } );
551    
552          return $out;          return $out;
553  }  }
554    
555  =head2 modify_record_regexps  =head2 dump_ascii
556    
557  Generate hash with regexpes to be applied using l<filter>.  Display humanly readable dump of record
558    
559    my $regexpes = $input->modify_record_regexps(  =cut
560                  900 => { '^a' => { ' : ' => '^b' } },  
561                  901 => { '*' => { '^b' => ' ; ' } },  sub dump_ascii {
562    );          my $self = shift;
563    
564            return unless $self->{ll_db};
565    
566            if ($self->{ll_db}->can('dump_ascii')) {
567                    return $self->{ll_db}->dump_ascii( $self->{pos} );
568            } else {
569                    return dump( $self->{ll_db}->fetch_rec( $self->{pos} ) );
570            }
571    }
572    
573    =head2 _get_regex
574    
575    Helper function called which create regexps to be execute on code.
576    
577      _get_regex( 900, 'regex:[0-9]+' ,'numbers' );
578      _get_regex( 900, '^b', ' : ^b' );
579    
580    It supports perl regexps with C<regex:> prefix to from value and has
581    additional logic to skip empty subfields.
582    
583  =cut  =cut
584    
585  sub _get_regex {  sub _get_regex {
586          my ($sf,$from,$to) = @_;          my ($sf,$from,$to) = @_;
587    
588            # protect /
589            $from =~ s!/!\\/!gs;
590            $to =~ s!/!\\/!gs;
591    
592            if ($from =~ m/^regex:(.+)$/) {
593                    $from = $1;
594            } else {
595                    $from = '\Q' . $from . '\E';
596            }
597          if ($sf =~ /^\^/) {          if ($sf =~ /^\^/) {
598                    my $need_subfield_data = '*';   # no
599                    # if from is also subfield, require some data in between
600                    # to correctly skip empty subfields
601                    $need_subfield_data = '+' if ($from =~ m/^\\Q\^/);
602                  return                  return
603                          's/\Q'. $sf .'\E([^\^]*?)\Q'. $from .'\E([^\^]*?)/'. $sf .'$1'. $to .'$2/';                          's/\Q'. $sf .'\E([^\^]' . $need_subfield_data . '?)'. $from .'([^\^]*?)/'. $sf .'$1'. $to .'$2/';
604          } else {          } else {
605                  return                  return
606                          's/\Q'. $from .'\E/'. $to .'/g';                          's/'. $from .'/'. $to .'/g';
607          }          }
608  }  }
609    
610    
611    =head2 modify_record_regexps
612    
613    Generate hash with regexpes to be applied using L<filter>.
614    
615      my $regexpes = $input->modify_record_regexps(
616                    900 => { '^a' => { ' : ' => '^b' } },
617                    901 => { '*' => { '^b' => ' ; ' } },
618      );
619    
620    =cut
621    
622  sub modify_record_regexps {  sub modify_record_regexps {
623          my $self = shift;          my $self = shift;
624          my $modify_record = {@_};          my $modify_record = {@_};
# Line 585  sub modify_record_regexps { Line 636  sub modify_record_regexps {
636                          foreach my $from (keys %{ $modify_record->{$f}->{$sf} }) {                          foreach my $from (keys %{ $modify_record->{$f}->{$sf} }) {
637                                  my $to = $modify_record->{$f}->{$sf}->{$from};                                  my $to = $modify_record->{$f}->{$sf}->{$from};
638                                  #die "no field?" unless defined($to);                                  #die "no field?" unless defined($to);
639                                  $log->debug("transform: |$from| -> |$to|");                                  my $d = "|$from| -> |$to|";
640                                    $log->debug("transform: $d");
641    
642                                  my $regex = _get_regex($sf,$from,$to);                                  my $regex = _get_regex($sf,$from,$to);
643                                  push @{ $regexpes->{$f} }, $regex;                                  push @{ $regexpes->{$f} }, { regex => $regex, debug => $d };
644                                  $log->debug("regex: $regex");                                  $log->debug("regex: $regex");
645                          }                          }
646                  }                  }
# Line 599  sub modify_record_regexps { Line 651  sub modify_record_regexps {
651    
652  =head2 modify_file_regexps  =head2 modify_file_regexps
653    
654  Generate hash with regexpes to be applied using l<filter> from  Generate hash with regexpes to be applied using L<filter> from
655  pseudo hash/yaml format for regex mappings.  pseudo hash/yaml format for regex mappings.
656    
657  It should be obvious:  It should be obvious:
# Line 627  sub modify_file_regexps { Line 679  sub modify_file_regexps {
679    
680          my $regexpes;          my $regexpes;
681    
682          CORE::open(my $fh, $modify_path) || $log->die("can't open modify file $modify_path: $!");          CORE::open(my $fh, $modify_path) || $log->logdie("can't open modify file $modify_path: $!");
683    
684          my ($f,$sf);          my ($f,$sf);
685    
# Line 649  sub modify_file_regexps { Line 701  sub modify_file_regexps {
701                          $log->debug("transform: |$from| -> |$to|");                          $log->debug("transform: |$from| -> |$to|");
702    
703                          my $regex = _get_regex($sf,$from,$to);                          my $regex = _get_regex($sf,$from,$to);
704                          push @{ $regexpes->{$f} }, $regex;                          push @{ $regexpes->{$f} }, {
705                                    regex => $regex,
706                                    file => $modify_path,
707                                    line => $.,
708                            };
709                          $log->debug("regex: $regex");                          $log->debug("regex: $regex");
710                  }                  }
711          }          }
# Line 657  sub modify_file_regexps { Line 713  sub modify_file_regexps {
713          return $regexpes;          return $regexpes;
714  }  }
715    
 =head1 MEMORY USAGE  
   
 C<low_mem> options is double-edged sword. If enabled, WebPAC  
 will run on memory constraint machines (which doesn't have enough  
 physical RAM to create memory structure for whole source database).  
   
 If your machine has 512Mb or more of RAM and database is around 10000 records,  
 memory shouldn't be an issue. If you don't have enough physical RAM, you  
 might consider using virtual memory (if your operating system is handling it  
 well, like on FreeBSD or Linux) instead of dropping to L<DBM::Deep> to handle  
 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.  
   
   
716  =head1 AUTHOR  =head1 AUTHOR
717    
718  Dobrica Pavlinusic, C<< <dpavlin@rot13.org> >>  Dobrica Pavlinusic, C<< <dpavlin@rot13.org> >>
Legend:
Removed from v.636  
changed lines
  Added in v.868
  ViewVC Help
Powered by ViewVC 1.1.26