I'd go for a HoH, although a HoA would work. Consider:

use strict;
use warnings;
use Text::CSV;

my %lookup;
my $csv = Text::CSV->new ();
my $filename = 'DATA';

while (<DATA>) {
    next unless $csv->parse ($_);

    my @row = $csv->fields ();
    next unless @row >= 7;
    
    my $key = $row[0];
    next if exists $lookup{$key} && $row[7] <= $lookup{$key}{max};
    
    $lookup{$key} = {max => $row[7], line => $., file => $filename};
}


print "Following maximums found:\n";

print "$_ = $lookup{$_}{max} in file $lookup{$_}{file}, line $lookup{$
+_}{line}\n"
    for sort keys %lookup;
    

__DATA__
DOW,Sep,18,09:31:16,440,29,142,10148,4
Russell2000,Sep,18,09:31:16,440,29,142,10148,4
RussellComposite,Sep,18,09:31:16,440,29,142,10148,4
Russell1000,Sep,18,09:31:16,440,29,142,10148,4
SP500,Sep,18,09:31:16,440,29,142,10148,4
Russell2000,Sep,18,09:31:16,440,29,142,10120,4
SP500,Sep,18,09:31:16,440,29,142,10160,4
[download]

Prints:

Following maximums found:
DOW = 10148 in file DATA, line 1
Russell1000 = 10148 in file DATA, line 4
Russell2000 = 10148 in file DATA, line 2
RussellComposite = 10148 in file DATA, line 3
SP500 = 10160 in file DATA, line 7
[download]

My apology for being a bit unclear on the requirements..

I'm better with examples: I need to process multiple log files containing thousands of 'DOW' related records each. (same data structure as shown in my original post). My goal is to determine if any record in the new log files contain a value in the 7th element that is greater than the current maximum value stored in the 'DOW' record of an index maximum CSV file. That CSV file will contain only 1 record per financial index. (ie DOW, SP500)

The while loop doesn't care if the lines come from one file or many, but the sample code is much more concise if I use a single 'file' with duplicated lines. You could:

@ARGV = @filenames;
while (<>) {
    $filename = shift @filenames if $. == 1;
    ...
}
[download]

to process a swag of files.

---

Perl is environmentally friendly - it saves trees

You may want to consider dumping the logs into a database and manipulating the data there. Then you can export what you need back into a CSV file. This would give you much more flexibility if your requirements change later on.

Look at MySql, SQLite or others. The DBI/DBD modules can interface a large number of databases. Of course this would mean learning some SQL, but the basics are not difficult.

You may also want to look at DBD::CSV which appears to let you treat CSV files as a database, and manipulate them using SQL statements through DBI (disclaimer: I have not tried this module myself).

In the code that I use to try and find a profitable way to trade options, I load the stock into a hash of arrays. The keys to the hash is date, open, high, low, close and volume. I have actually wrapped the hash up in a class for convenience and to handle any possible changes to the data that might cause a change to the implementation.

This method has worked well for me over a number of years and I would recommend doing something similar.

My 2 cents.....I'm barely a Monk's novice's assitant helper (in perl terms)...but I would try a hash with an anonymous array...since each item has a unique key value (DOW, SP500, Russel2000) and discrete values. The anonymous array allows you to associate multiple values with a single hash key. It's also more intiutive.<\p>

Accessing the 7th value is straight forward from there. The hash can be sorted based on the 7th value.<\p>

#Begin code example
my %hash = (
    'Dow' , [99,123,345,567,678, 756, 202],
    'SP500', [88,55,55,677,843, 987, 345],
    'Russell1000',[456,788,990,889,876,234,456],
    );

#access 7th value

print $hash{'Dow'}[7],"\n";

#should equal 202
[download]