create table measurements (
    name varchar
   ,measurement int
   ,quality1 int
   ,quality2 int
   ,quality3 int
);
[download]

Obviously, you'd substitute quality1/quality2/etc. with the names of the qualities.

Then, if you want the five measurements for Name1 ordered by size, you use the following SQL statement:

SELECT measurement, size
  FROM measurements
 WHERE name = 'Name1'
 ORDER BY size
[download]

Easy as pie.

read a file line into $line, then:
  my @arry = split(/==/, $line); #recent==pop==commandname
  $myhash{$arry[$#arry]} = [$arry[0], $arry[1]];
loop until done

to sort:

    my @recentkeys = sort by_HoA_0_asc keys(%myhash);
    my @popkeys = sort by_HoA_1_desc keys(%myhash);

# sort Hash of Arrays by numeric value of first 
# array value(history), ascending

sub by_HoA_0_asc
{
    if ($myhash{$a}[0] < $myhash{$b}[0]) 
    { 
    return -1; 
    }
    elsif ($myhash{$a}[0] > $myhash{$b}[0])
    {
    return 1;
    }
    return 0;
}

# sort Hash of Arrays by numeric value of second 
# array value (popularity), descending. If equal, 
# sort by first array value (history), ascending.

sub by_HoA_1_desc
{
    if ($myhash{$a}[1] > $myhash{$b}[1]) 
    { 
    return -1; 
    }
    elsif ($myhash{$a}[1] < $myhash{$b}[1])
    {
    return 1;
    }
    if ($myhash{$a}[0] < $myhash{$b}[0])
    {
    return -1;
    }
    elsif ($myhash{$a}[0] < $myhash{$b}[0])
    {
    return 1;
    }
    return 0;
}
[download]

by_HoA_1_desc can be written more succinctly as

   $myhash{$a}[1] <=> $myhash{$b}[1]
|| $myhash{$a}[0] <=> $myhash{$b}[0]
[download]

Dave.

True. I'm still getting used to da spaceship. :)

One question, how does it compare efficiency-wise to if-elseif chains?

Ummm... in my case, since popularity is sorted in descending order and history needs to be sorted in ascending order, shouldn't it be:

   $myhash{$b}[1] <=> $myhash{$a}[1]
|| $myhash{$a}[0] <=> $myhash{$b}[0]
[download]

?

In any event, thanks for suggesting the improvement. In my long-winded if-elsif chained version, I had one of the >'s reversed, leading to a very dirty bug.

I'd create a hash of indexes. The key is the property and the value is an array of primary keys in your main hash, ordered by the property in question. It's very fast and reasonable straight forward.

Most of the following code is creating the test data and then displaying the results. It's just the middle of the 3 blocks that does all the work setting up the indexes.

#! perl -slw
use strict;
use Data::Dumper;
use List::Util qw[ shuffle ];

## An array of properties
my @props = map{ "prop$_" } 1 .. 10;

## Gerate some test data
my %things = map {
    +"thing$_" => {
        map{ $_ => int rand 1000 } ( shuffle @props )[ 0 .. 4 ]
    }
} '0001' .. '3000';

## Create a hash of indexes sorted by the the values of the properties
my %orderings = map{ 
    my $prop = $_;
    $prop => [     
        sort { 
            $things{ $a }{ $_ } <=> $things{ $b }{ $_ } 
        } map{ 
            exists $things{ $_ }{ $prop }
                ? $_
                : ()
        } keys %things
    ]
} @props;

## Display everything, in every order
for my $prop ( @props ) {
    print "\nThings ordered by $prop\n";
    for my $thing (  @{ $orderings{ $prop } } ) {
        print $thing, ' => { ',  
            join( '', map{ 
                sprintf "%6.6s: %3.3s, ", 
                    exists $things{ $thing }{ $_ }
                    ? ( $_, $things{ $thing }{ $_ } )
                    : ( '', '' ) 
            } @props
        ) . ' }';
    }
}
[download]

Demo run with to 50 items and 2/4 properties to keep the volume of output down but it handles 10,000 items and 10 properties near instantly.