/[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 761 by dpavlin, Wed Oct 25 17:10:08 2006 UTC
# 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.14
20    
21  =cut  =cut
22    
23  our $VERSION = '0.12';  our $VERSION = '0.14';
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    );    );
# Line 75  Optional parametar C<encoding> specify a Line 73  Optional parametar C<encoding> specify a
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 96  sub new { Line 92  sub new {
92    
93          $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});
94          $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});
95            $log->logconfess("low_mem argument is not suppored any more. rewrite it to load_row and save_row") if ($self->{low_mem});
96    
97          $log->logconfess("specify low-level file format module") unless ($self->{module});          $log->logconfess("specify low-level file format module") unless ($self->{module});
98          my $module = $self->{module};          my $module_path = $self->{module};
99          $module =~ s#::#/#g;          $module_path =~ s#::#/#g;
100          $module .= '.pm';          $module_path .= '.pm';
101          $log->debug("require low-level module $self->{module} from $module");          $log->debug("require low-level module $self->{module} from $module_path");
102    
103          require $module;          require $module_path;
         #eval $self->{module} .'->import';  
104    
105          # check if required subclasses are implemented          # check if required subclasses are implemented
106          foreach my $subclass (qw/open_db fetch_rec init/) {          foreach my $subclass (qw/open_db fetch_rec init dump_rec/) {
107                  my $n = $self->{module} . '::' . $subclass;                  # FIXME
                 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, @_);  
108          }          }
109    
110          $self->{'encoding'} ||= 'ISO-8859-2';          $self->{'encoding'} ||= 'ISO-8859-2';
111    
         # 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;  
         }  
   
112          $self ? return $self : return undef;          $self ? return $self : return undef;
113  }  }
114    
# Line 157  sub new { Line 116  sub new {
116    
117  This function will read whole database in memory and produce lookups.  This function will read whole database in memory and produce lookups.
118    
119     my $store;     # simple in-memory hash
120    
121   $input->open(   $input->open(
122          path => '/path/to/database/file',          path => '/path/to/database/file',
123          code_page => 'cp852',          code_page => 'cp852',
124          limit => 500,          limit => 500,
125          offset => 6000,          offset => 6000,
         lookup => $lookup_obj,  
126          stats => 1,          stats => 1,
127          lookup_ref => sub {          lookup_coderef => sub {
128                  my ($k,$v) = @_;                  my $rec = shift;
129                  # store lookup $k => $v                  # store lookups
130          },          },
131          modify_records => {          modify_records => {
132                  900 => { '^a' => { ' : ' => '^b' } },                  900 => { '^a' => { ' : ' => '^b' } },
133                  901 => { '*' => { '^b' => ' ; ' } },                  901 => { '*' => { '^b' => ' ; ' } },
134          },          },
135          modify_file => 'conf/modify/mapping.map',          modify_file => 'conf/modify/mapping.map',
136            save_row => sub {
137                    my $a = shift;
138                    $store->{ $a->{id} } = $a->{row};
139            },
140            load_row => sub {
141                    my $a = shift;
142                    return defined($store->{ $a->{id} }) &&
143                            $store->{ $a->{id} };
144            },
145    
146   );   );
147    
148  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 153  C<limit> is optional parametar to read j
153    
154  C<stats> create optional report about usage of fields and subfields  C<stats> create optional report about usage of fields and subfields
155    
156  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.  
157    
158  C<modify_records> specify mapping from subfields to delimiters or from  C<modify_records> specify mapping from subfields to delimiters or from
159  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 163  C<modify_file> is alternative for C<modi
163  (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
164  overrides C<modify_records> if both exists for same input.  overrides C<modify_records> if both exists for same input.
165    
166    C<save_row> and C<load_row> are low-level implementation of store engine. Calling convention
167    is documented in example above.
168    
169  Returns size of database, regardless of C<offset> and C<limit>  Returns size of database, regardless of C<offset> and C<limit>
170  parametars, see also C<size>.  parametars, see also C<size>.
171    
# Line 209  sub open { Line 181  sub open {
181          $log->logconfess("lookup_coderef must be CODE, not ",ref($arg->{lookup_coderef}))          $log->logconfess("lookup_coderef must be CODE, not ",ref($arg->{lookup_coderef}))
182                  if ($arg->{lookup_coderef} && ref($arg->{lookup_coderef}) ne 'CODE');                  if ($arg->{lookup_coderef} && ref($arg->{lookup_coderef}) ne 'CODE');
183    
184            $log->debug( $arg->{lookup_coderef} ? '' : 'not ', "using lookup_coderef");
185    
186          $log->logcroak("need path") if (! $arg->{'path'});          $log->logcroak("need path") if (! $arg->{'path'});
187          my $code_page = $arg->{'code_page'} || 'cp852';          my $code_page = $arg->{'code_page'} || 'cp852';
188    
# Line 218  sub open { Line 192  sub open {
192                  $self->{$v} = $arg->{$v} if ($arg->{$v});                  $self->{$v} = $arg->{$v} if ($arg->{$v});
193          }          }
194    
195            if ($arg->{load_row} || $arg->{save_row}) {
196                    $log->logconfess("save_row and load_row must be defined in pair and be CODE") unless (
197                            ref($arg->{load_row}) eq 'CODE' &&
198                            ref($arg->{save_row}) eq 'CODE'
199                    );
200                    $self->{load_row} = $arg->{load_row};
201                    $self->{save_row} = $arg->{save_row};
202                    $log->debug("using load_row and save_row instead of in-memory hash");
203            }
204    
205          my $filter_ref;          my $filter_ref;
206          my $recode_regex;          my $recode_regex;
207          my $recode_map;          my $recode_map;
# Line 250  sub open { Line 234  sub open {
234          }          }
235          $log->debug("rec_regex: ", Dumper($rec_regex)) if ($rec_regex);          $log->debug("rec_regex: ", Dumper($rec_regex)) if ($rec_regex);
236    
237          my ($db, $size) = $self->{open_db}->( $self,          my $class = $self->{module} || $log->logconfess("can't get low-level module name!");
238    
239            my $ll_db = $class->new(
240                  path => $arg->{path},                  path => $arg->{path},
241  #               filter => sub {  #               filter => sub {
242  #                       my ($l,$f_nr) = @_;  #                       my ($l,$f_nr) = @_;
# Line 262  sub open { Line 248  sub open {
248                  %{ $arg },                  %{ $arg },
249          );          );
250    
251          unless (defined($db)) {          unless (defined($ll_db)) {
252                  $log->logwarn("can't open database $arg->{path}, skipping...");                  $log->logwarn("can't open database $arg->{path}, skipping...");
253                  return;                  return;
254          }          }
255    
256            my $size = $ll_db->size;
257    
258          unless ($size) {          unless ($size) {
259                  $log->logwarn("no records in database $arg->{path}, skipping...");                  $log->logwarn("no records in database $arg->{path}, skipping...");
260                  return;                  return;
# Line 298  sub open { Line 286  sub open {
286    
287                  $log->debug("position: $pos\n");                  $log->debug("position: $pos\n");
288    
289                  my $rec = $self->{fetch_rec}->($self, $db, $pos, sub {                  my $rec = $ll_db->fetch_rec($pos, sub {
290                                  my ($l,$f_nr) = @_;                                  my ($l,$f_nr) = @_;
291  #                               return unless defined($l);  #                               return unless defined($l);
292  #                               return $l unless ($rec_regex && $f_nr);  #                               return $l unless ($rec_regex && $f_nr);
# Line 335  sub open { Line 323  sub open {
323                  }                  }
324    
325                  # store                  # store
326                  if ($self->{low_mem}) {                  if ($self->{save_row}) {
327                          $self->{db}->put($pos, $rec);                          $self->{save_row}->({
328                                    id => $pos,
329                                    row => $rec,
330                            });
331                  } else {                  } else {
332                          $self->{data}->{$pos} = $rec;                          $self->{data}->{$pos} = $rec;
333                  }                  }
# Line 348  sub open { Line 339  sub open {
339                  if ($self->{stats}) {                  if ($self->{stats}) {
340    
341                          # fetch clean record with regexpes applied for statistics                          # fetch clean record with regexpes applied for statistics
342                          my $rec = $self->{fetch_rec}->($self, $db, $pos);                          my $rec = $ll_db->fetch_rec($pos);
343    
344                          foreach my $fld (keys %{ $rec }) {                          foreach my $fld (keys %{ $rec }) {
345                                  $self->{_stats}->{fld}->{ $fld }++;                                  $self->{_stats}->{fld}->{ $fld }++;
# Line 385  sub open { Line 376  sub open {
376          $self->{max_pos} = $to_rec;          $self->{max_pos} = $to_rec;
377          $log->debug("max_pos: $to_rec");          $log->debug("max_pos: $to_rec");
378    
379            # save for dump
380            $self->{ll_db} = $ll_db;
381    
382          return $size;          return $size;
383  }  }
384    
# Line 424  sub fetch { Line 418  sub fetch {
418    
419          my $rec;          my $rec;
420    
421          if ($self->{low_mem}) {          if ($self->{load_row}) {
422                  $rec = $self->{db}->get($mfn);                  $rec = $self->{load_row}->({ id => $mfn });
423          } else {          } else {
424                  $rec = $self->{data}->{$mfn};                  $rec = $self->{data}->{$mfn};
425          }          }
# Line 546  sub stats { Line 540  sub stats {
540          return $out;          return $out;
541  }  }
542    
543    =head2 dump
544    
545    Display humanly readable dump of record
546    
547    =cut
548    
549    sub dump {
550            my $self = shift;
551    
552            return $self->{ll_db}->dump_rec( $self->{pos} );
553    
554    }
555    
556  =head2 modify_record_regexps  =head2 modify_record_regexps
557    
558  Generate hash with regexpes to be applied using l<filter>.  Generate hash with regexpes to be applied using l<filter>.
# Line 627  sub modify_file_regexps { Line 634  sub modify_file_regexps {
634    
635          my $regexpes;          my $regexpes;
636    
637          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: $!");
638    
639          my ($f,$sf);          my ($f,$sf);
640    
# Line 657  sub modify_file_regexps { Line 664  sub modify_file_regexps {
664          return $regexpes;          return $regexpes;
665  }  }
666    
 =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.  
   
   
667  =head1 AUTHOR  =head1 AUTHOR
668    
669  Dobrica Pavlinusic, C<< <dpavlin@rot13.org> >>  Dobrica Pavlinusic, C<< <dpavlin@rot13.org> >>
Legend:
Removed from v.636  
changed lines
  Added in v.761
  ViewVC Help
Powered by ViewVC 1.1.26