use strict;

my (@line,@last);
while (<DATA>) {
   @line = split('\|',$_,8);
   @last = map { $line[$_] || $last[$_] } (0..$#line);
   print join('|',@last);
}

__DATA__
1|krazken|123 Main|BFE|AR|72210|555-2345|1
2|kraken||||||1
3|krayken|||||555-2345|1
[download]

jeffa

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

I would use a database for this, but I already have it in a flat file, and the program that assigns that matchkey runs on a flat file as well, so instead of wasting time trying to load millions of records into a database, I just work on the flat file. Plus the file is already sorted on the matchkey coming out the previous program. I probably need to take the approach of taking advantage of the fact that the file is sorted and read until my matchkey changes then process that matchgroup and then read the next. But, there are times when I /try/ to write flexible code to where it wouldn't matter if the file was sorted or not. I would like it to work either way. make sense?

I think with your DB_File approach, the biggest problem is one read/write for every record. I had a similar problem with a search index for 5,000,000 books. The thing took around 18 hours to finish. Taking advantage or sorting it and working with the current record cut it down to 17 minutes.

One thing I thought of (I don't know if someone else has done it. Couldn't find it at the time.) was to subclass tie DB_File and make a hash that wouldn't always read and write on every access. It would have an intermidiate cache. If you implemented caching behavior like this, it would probably speed it up an order of magnitude when the data was fairly sorted and still work about the same for the general case all while being nice and generic.

-Lee

"To be civilized is to deny one's nature."

What you need is a hash of hashes with one of the values is an array of names. The keys of the hash are the matchkeys and the values would be references to arrays holding the values.

#!/usr/bin/perl -w
use strict;
use Data::Dumper;


my @FLDS = qw(ID name address city state zip phone matchkey);
my @RFLDS = qw(address city state zip phone);
my @UFLDS = qw(ID name);


my %records;
for(<DATA>){
  chomp;
  my %rec;
  @rec{@FLDS} = split/\|/;
  my %urec;
  @urec{@UFLDS} = @rec{@UFLDS};
  my $key = $rec{matchkey};
  defined($key) or die "This record has no key";
  push @{ $records{$key}{'records'} }, \%urec;
  for(@RFLDS){
       $records{$key}{$_} = $rec{$_} unless exists $records{$key}{$_};
  }
}

for my $key (sort keys %records){
    my %master = %{$records{$key}};
    for(@{ $master{records} }){
        my %rec = (%master, %$_);
        $rec{matchkey} = $key;
        print join('|', @rec{@FLDS}) . "\n";
    }
}
print Dumper(\%records);

__DATA__
1|krazken|123 Main|BFE|AR|72210|555-2345|1
2|kraken||||||1
3|krayken|||||555-2345|1
[download]

Here is a dump of the data structure to make you believe what the code is doing:

1|krazken|123 Main|BFE|AR|72210|555-2345|1
2|kraken|123 Main|BFE|AR|72210|555-2345|1
3|krayken|123 Main|BFE|AR|72210|555-2345|1
$VAR1 = {
          '1' => {
                   'state' => 'AR',
                   'zip' => '72210',
                   'address' => '123 Main',
                   'city' => 'BFE',
                   'phone' => '555-2345',
                   'records' => [
                                  {
                                    'ID' => '1',
                                    'name' => 'krazken'
                                  },
                                  {
                                    'ID' => '2',
                                    'name' => 'kraken'
                                  },
                                  {
                                    'ID' => '3',
                                    'name' => 'krayken'
                                  }
                                ]
                 }
        };
[download]

Update2: The code presented assumes nothing about the order at which records appear on the file. The runtime and memory requirements can be reduces dramatically IF there are some assumptions about the records (e.g. Records with data always appear before records with missing data. Or records with the same matchkey always appear grouped together.) If you sort your data beforehand, then you can achieve better runtime.

Hope this helps,,,

Aziz,,,

A compromise might be to make a pass over the file once and make a DB_File database of the canonical information. Then run over the file again, and when there's missing fields consult the db for the information. That way you reduce the amount of info you have to keep in memory, at the cost of running over the file twice.