my @infile = <>; # Reads file
[download]

And you sort only by 17 resp. 2 bytes?

   ### Define the sort key here ###
   # Sorts in ascending order.
    sub key1  { ( substr( $a, 3, 17 )) cmp ( substr( $b, 3, 17 )); }
     # Sorts  descending order.
    sub key2  { ( substr( $b, 20, 2 )) cmp ( substr( $a, 20, 2 )); }
    #
[download]

doing two substr() calls for each comparison? Heck, that's inefficient. You could calculate the comparison data for each record once, use that as key and store the records in a DB_File of type DB_BTREE. Then you iterate over that DB_BTREE hash with each, output the value for each tuple - and voilà - you get your records in sorted order. Memory requirements should be minimal, and DB_File is pretty fast.

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

Thanks for the suggestions. I will try out C-ISAM route but for time being, I have reverted back to AIX COBOL to do the sort. Actually , we are converting MVS COBOL to AIX and I thought I can use PERL.

#!/usr/bin/perl -w

=head1
by david
with 20million rows, you probably don't want to store
everything in memory and then sort them. what you have 
to do is sort the
data file segment by segment and then merge them back. 
merging is the real
tricky business. the following script
(which i did for someone a while ago)
will do that for you. what it does is break the file 
into multiple chunks
of 100000 lines, sort the chunks in a disk 
tmp file and then merge all the
chunks back together. when i sort the file, 
i keep the smallest boundary
ofeach chunk and use this number to sort 
the file so you don't have to
compare all the tmp files.
there is also a merge sort in 
the PPT Perl Power Tools on cpan
=cut

use strict;
my @buffer  = ();
my @tmps    = ();
my %bounds  = ();
my $counter = 0;
open( FILE, "file.txt" ) || die $!;
while (<FILE>) {
    push ( @buffer, $_ );
    if ( @buffer > 100000 ) {
        my $tmp = "tmp" . $counter++ . ".txt";
        push ( @tmps, $tmp );
        sort_it( \@buffer, $tmp );
        @buffer = ();
    }
}
close(FILE);
merge_it( \%bounds );
unlink(@tmps);

#-- DONE --#
sub sort_it {
    my $ref   = shift;
    my $tmp   = shift;
    my $first = 1;
    open( TMP, ">$tmp" ) || die $!;
    for (
        sort {
            my @fields1 = split ( /\s/, $a );
            my @fields2 = split ( /\s/, $b );
            $fields1[2] <=> $fields2[2]
        } @{$ref}
      )
    {
        if ($first) {
            $bounds{$tmp} = ( split (/\s/) )[2];
            $first = 0;
        }
        print TMP $_;
    }
    close(TMP);
}

sub merge_it {
    my $ref       = shift;
    my @files     = sort { $ref->{$a} <=> $ref->{$b} } keys %{$ref};
    my $merged_to = $files[0];
    for ( my $i = 1 ; $i < @files ; $i++ ) {
        open( FIRST, $merged_to ) || dir $!;
        open( SECOND, $files[$i] ) || dir $!;
        my $merged_tmp = "merged_tmp$i.txt";
        open( MERGED, ">$merged_tmp" ) || die $!;
        my $line1 = <FIRST>;
        my $line2 = <SECOND>;
        while (1) {
            if ( !defined($line1) && defined($line2) ) {
                print MERGED $line2;
                print MERGED while (<SECOND>);
                last;
            }
            if ( !defined($line2) && defined($line1) ) {
                print MERGED $line1;
                print MERGED while (<FIRST>);
                last;
            }
            last if ( !defined($line1) && !defined($line2) );
            my $value1 = ( split ( /\s/, $line1 ) )[2];
            my $value2 = ( split ( /\s/, $line2 ) )[2];
            if ( $value1 == $value2 ) {
                print MERGED $line1;
                print MERGED $line2;
                $line1 = <FIRST>;
                $line2 = <SECOND>;
            }
            elsif ( $value1 > $value2 ) {
                while ( $value1 > $value2 ) {
                    print MERGED $line2;
                    $line2 = <SECOND>;
                    last unless ( defined $line2 );
                    $value2 = ( split ( /\s/, $line2 ) )[2];
                }
            }
            else {
                while ( $value1 < $value2 ) {
                    print MERGED $line1;
                    $line1 = <FIRST>;
                    last unless ( defined $line1 );
                    $value1 = ( split ( /\s/, $line1 ) )[2];
                }
            }
        }
        close(FIRST);
        close(SECOND);
        close(MERGED);
        $merged_to = $merged_tmp;
    }
}
[download]

What I am not sure about is the maximum size. Sort::Maker appeared to be the closest match to the OP needs of the namespace you refer to, but even that didn't make it clear enough to me what the filesize limits are for the OP's particular key definitions for a particular CPAN module. The OP is partly at fault there for not giving that much info in regard to the distribution of information - two example records ain't much to go on.
__________________________________________________________________________________

^M Free your mind!

Sort::Maker memory requirements are quite high so I don't think it could be a good solution.

Sort::External does the sorting on disk, so it is not limited by the memory size and it is very easy to use for simple cases but for complex cases a transformation similar to the GRT is required.

Another way is to use the external sort program that uses on-disk sorting algorithms:

# untested ...

use Encode qw(encode decode);
use MIME::Base64 qw(encode_base64);

my $tempfn = "sort.temp"; # better use File::Temp!
open my $tmp, ">", $tempfn or die ...;

while(<>) {
  my $k0 = encode_base64(encode(cp1047 => substr($_, 3, 17)), "");
  my $k1 = encode_base64("\xff\xff" ^ encode(cp1047 => substr($_, 20, 
+2)));
  print $tmp join("\0", $k0, $k1, $_);
}

close $tmp or die "...";

open my $sorted, "-|", sort => $tempfn or die "...";
while(<$sorted>) {
  print((split /\x00/, $_, 3)[2]);
}
[download]

CREATE DATABASE sorter;
USE sorter;
CREATE TABLE t619575 (
  c01 varchar(2), -- SK
  c02 integer,    -- 1242
  c03 integer,    -- 0180010100
  c04 varchar(3), -- AAR
  c05 varchar(3), -- CPH
  c06 varchar(3), -- AAR
  c07 integer,    -- 0735
  c08 varchar(3), -- CPH
  c09 integer,    -- 0810001
  c10 bigint(25), -- 20070521200705211
  c11 varchar(2), -- SK
  c12 integer     -- 1242
);

-- Assuming tab separated columns
LOAD DATA LOCAL INFILE '619575.csv'
  INTO TABLE t619575
    FIELDS TERMINATED BY '\t'
      ENCLOSED BY ''
      ESCAPED BY '\\';

-- Add index on the fields to sort
ALTER TABLE t619575 ADD INDEX idx_c02_c03_c04 (c02, c03, c04);

-- Create sorted output
SELECT * 
  INTO OUTFILE '619575.sorted.csv' 
  FROM t619575 
 ORDER BY c02, c03, c04 ;
[download]

Did you read Re^2: EBCDIC sort (/bin/sort) ? I posted it after you asked me to write up my suggestion from the chatterbox. If there was something about it that you had problems with, it would be polite to mention those.

You may be better using an external sorting routine, such as syncsort, or possibly even sort.