You could do

my ($query, $sth, $rv);

$query = ...;
$sth   = ...;
$rv    = ...;
...

$query = ...;
$sth   = ...;
$rv    = ...;
...
[download]

I did that in a .t file recently. The complexity of the alternative was immense.

Of course, in your specific case, you could write

my $first_result = $dbh->selectrow_hashref(
   "SELECT something FROM somewhere"
);


my $second_result = $dbh->selectrow_hashref(
   "SELECT somethingelse FROM somewhereelse"
);
[download]

what is actually happening in memory

Two different variables are created, as if they had different names.

$ perl -MO=Concise -e'my $x; my $x; my $y;' 2>&1 | grep padsv
3     <0> padsv[$x:1,4] vM/LVINTRO ->4
5     <0> padsv[$x:2,4] vM/LVINTRO ->6
7     <0> padsv[$y:3,4] vM/LVINTRO ->8
[download]

sub first_row {
    my ($dbh, $query, @args) = @_
    my $sth = $dbh->prepare($query);
    my $rv = $sth->execute(@args);
    my $first_row = $sth->fetchrow_hashref;
    return ($rv, $first_row);
}

my ($success, $first_result) = first_row($dbh, "SELECT ... ");
# and if you don't want to actually check success
my $second_result = first_row(...);
[download]

(Update: or as ikegami points out, just use $dbh->fetchrow_hashref($query) in the first place.)

(Even more elegant if you don't check for $rv, but instead die on errors, and catch them where appropriate).

If you insist on your current pattern, you can use warnings, but disable single warnings that bother you - read perllexwarn for more details. Or simply put a block around the declarations.

I like to run with warnings on. But sometimes I don't see them, like for instance, when I was editing a fairly substantial mod_perl script, which printed a whole bunch of stuff to the log, hiding any warnings in the scrollback.

Because I didn't see the warnings, I spent some frustrating time trying to discover what is going on in code that went something like this:

  my $some_index = 0;
  while ($thing = $thingies->next) {
    my $some_index = $thing->something_or_other;
    last if (test_for_fitness($some_index));
  }
[download]

Yeah, I had originally declared the variable in the loop, but then I realized I would need it outside the loop, moved the declaration out, and forgot to remove the inner my. The loop worked perfectly, but the moment the program left the loop, $some_index was restored to 0 again.

And that is why I like perl warning me about a re-used my declaration.

I know it's not what you asked, just some food for thought

Is this really *that* bad? If so why?

Short version: I think it's clear that

my $x = 'string';
my $x = 17;
[download]

Long version: It's nice to have some imperative semblance of referential transparency—when I see a variable, I like to know what it means (even if I can't quite translate

my $x = 5;
$x += 1;
print $x;
[download]

my $x = 5;
$x += 1;
print 5;
[download]