#%hash has been filled with some meta data in an array read in 
#from the smaller flat file 
#The first element is the name we are searching for.  
#the rest are irrelevant to this loop 
# 
#fh_log is a file handle to the large 300mb+ flat file 
#each line may contain references to 1 or more table names, and 
#I need to capture all of them. 
 
while($cur_line=<fh_log>) 
{ 
   foreach $key (keys %hash) 
   { 
      $table = $hash{$key}[0]; 
      if($command[0]=~ m/$table/i)	#If this query contains reference to this table 
      {	 
	  $table_stats{$table}++;	#count up how many times this table is referenced. 
	  $table_refs++;     #total table references (for % calc) 
      } 
   } 
}

#!/usr/bin/perl 
 
use strict; 
use warnings; 
 
# The words are in capitals to highlight the use of the m//i flag in the compiled REs. 
# Note the RE pattern __[^_]+__ in the word list. 
# Note that the word boundaries, \b, to insure that the OR in FOR is not counted as a word. 
# Note that the capture parenthesis in the compiled RE do work. 
# 
my @Words = qw( MY PERL WHILE IF FOR USE OR ELSIF __[^_]+__ ); 
my @Words_re = map { qr/\b($_)\b/i } @Words; 
 
my %Count = (); 
while( <> ){ 
  for my $re ( @Words_re ){ 
    for my $each ( /$re/ ){ 
      $Count{$1} ++; 
    } 
  } 
} 
 
for my $word ( sort keys %Count ){ 
  printf "%5d  %s\n", $Count{$word}, $word; 
} 
 
__END__

my @tables; 
my @tables_re; 
 
#reading in small file 
while($cur_line=<size_log>) 
{ 
   my @command=split(/;;;+/,$cur_line); 
   push @tables, $command[0]; 
   #parse remainder of line... 
} 
push @tables, qw( __[^_]+__ ); 
@tables_re = map { qr/\b($_)\b/i } @tables; 
 
#pattern match against big file 
while(<fh_log>) 
{ 
   for my $re (@tables_re) 
   { 
     for my $each (/$re/ )	#If this query contains reference to this table 
     {	 
	$table_stats{$1}++;	#count up how many times this table is referenced. 
	$table_refs++; 
     } 
   } 
}

   for my $re (@tables_re)  
   {  
     for my $each (/$re/ )	#If this query contains reference to this table  
     {	  
	$table_stats{$1}++;	#count up how many times this table is referenced.  
	$table_refs++;  
     }  
   }

   for my $re (@tables_re)  
   {  
     if (/($re)/ )	#If this query contains reference to this table  
     {	  
	$table_stats{$1}++;	#count up how many times this table is referenced.  
	$table_refs++;  
     }  
   }

my %htable_re; 
  
#reading in small file  
while($cur_line=<size_log>)  
{  
   my @command=split(/;;;+/,$cur_line);  
   $htable_re{$command[0]}=qr/\b($command[0])\b/i 
   #parse remainder of line...  
}   
  
#pattern match against big file  
while(<fh_log>)  
{  
   foreach $key (keys %htable_re) 
   { 
    if(/$htable_re{$key}/ ) #If this query contains reference to this table 
    {  
     $table_stats{$key}++; #count up how many times this table is referenced. 
     $table_refs++; 
    } 
   } 
}

#!/usr/bin/perl 
 
use strict; 
use warnings; 
use utf8; 
 
use Data::Dumper; 
$Data::Dumper::Sortkeys = 1; 
$Data::Dumper::Indent   = 1; 
$Data::Dumper::Maxdepth = 0; 
 
use Benchmark; 
 
my $x = 'a'; 
my @words = (); 
print "Creating words...\n"; 
for ( 1 .. 1_000 ){ 
  push @words, $x; 
  $x ++; 
} 
 
print "creating REs...\n"; 
my @words_re = map { qr/\b($_)\b/i } @words; 
 
 
my @data = <>; 
 
print "timing...\n"; 
timethese( 100, { 
  search => \&search, 
  precompiled => \&precompiled, 
} ); 
 
sub search { 
  my %count = (); 
 
  for ( @data ){ 
    for my $word ( @words ){ 
      if( /$word/ ){ 
        $count{$word} ++; 
      } 
    } 
  } 
} 
 
sub precompiled { 
  my %count = (); 
 
  for ( @data ){ 
    for my $re ( @words_re ){ 
      if( /$re/ ){ 
        $count{$1} ++; 
      } 
    } 
  } 
}

Creating words... 
creating REs... 
timing... 
Benchmark: timing 100 iterations of precompiled, search... 
precompiled: 21 wallclock secs (18.13 usr +  0.00 sys = 18.13 CPU) @  5.52/s (n=100) 
    search: 119 wallclock secs (94.82 usr +  0.08 sys = 94.90 CPU) @  1.05/s (n=100)