Not golfing, because you won't get decent code from golfing horrible code.

I'd rather see this code as a spot-the-mistakes execise.

Thus, here come my changes:

my @quarters = qw/none first second third fourth/;

sub termgrades {
    my ($period, $quarter) = @_;
    $sth = $dbh->prepare_cached(
            qq{SELECT *
               FROM $quarters[$quarter]quarter 
               WHERE userid = ? AND period = ? AND gradetype = ?}
            )
        or &error( "2",  "$userdata[0] $quarters[$quarter] quarter "
                   . "grades database search failed: $DBI::errstr" );

    $sth->execute( $userdata[0], $period, 2 )
        or &error( "2", "$userdata[0] quarter grades "
                        ." database search failed: $DBI::errstr" );
}
[download]

update
Changed the @quarters array to avoid a minor bug. Thanks to itub.

However, the first blunder, the one that eventually led to the current horrible code, is that there are four database tables instead of one.

Thus the first order of business would be to merge those four tables into one, adding a "quarter" column.

With that in mind, you could rewrite the above function as follows:

sub termgrades {
    my ($period, $quarter) = @_;
    $sth = $dbh->prepare_cached(
            qq{SELECT *
               FROM quarters 
               WHERE userid = ? AND period = ? 
                     AND gradetype = ? and quarter = ?}
            )
        or &error( "2",  "$userdata[0] quarter $quarter grades "
                   . "database search failed: $DBI::errstr" );

    $sth->execute( $userdata[0], $period, 2, $quarter  )
        or &error( "2", "$userdata[0] quarter grades "
                        ." database search failed: $DBI::errstr" );
    return $sth; # perhaps ... see text
}
[download]

That said, this function, in its original form, is completely useless, because it is executing a SELECT request from a locally scoped statement handler, and its result would be simply lost. A returning statement for such a handler is needed, if you want to pursue any practical purpose.

What else? Ah, yes, the global @userdata array, of which we have just to assume it exists and has valid data in it. It should be passed as an argument as well.

FInally, that naked numeric literal "2" used as an argument to "execute" and "error" should be turned into a variable, so that whoever has to maintain the code knows what it is about.

There is one minor error: your @quarters array is zero-based, but the quarter as passed to the method counts from 1 ($quarters[1] is "second").

Should the "2" passed to "error" be a named constant instead of a magic number? Who knows, perhaps if this is an error level number a number is not that bad. If you turn the error levels into names, make sure that they are clear, unlike the US Homeland Security Advisory System (I always have trouble remembering whether "high" is higher than "elevated" or the other way around ;-) )

That said, this function, in its original form, is completely useless, because it is executing a SELECT request from a locally scoped statement handler, and its result would be simply lost.

Oh, there's more fun than that, my friend! There are some databases where you can set up a view in such a way that a SELECT against it actually makes changes to stuff. In Oracle 9, you can actually have it do literally anything, including executing Perl code.

Being right, does not endow the right to be rude; politeness costs nothing.
Being unknowing, is not the same as being stupid.
Expressing a contrary opinion, whether to the individual or the group, is more often a sign of deeper thought than of cantankerous belligerence.
Do not mistake your goals as the only goals; your opinion as the only opinion; your confidence as correctness. Saying you know better is not the same as explaining you know better.

That's some messy programming-by-side-effect there. Sure, calling an external database is already a side-effect, but it's the sort you pretty much have to live with. If the posted code is using such a view, I wouldn't consider it an improvement.

"There is no shame in being self-taught, only in not trying to learn in the first place." -- Atrus, Myst: The Book of D'ni.

I read the first line of cchampion's reply but not the rest, so I thought I'd take a stab myself.

Like the OP, I presume the variable $dbh, the array @userdata and the subroutine error() to be predefined. However, it appears that the OP is using this subroutine to set a global variable called $sth from which results are later retrieved. I find this upsetting so I'm going to have the subroutine termgrades() return it instead, and return undef in case of errors. I also changed the messages so that an prepare error would not return the same message as an execute error.

my %quarternames = (1 => 'first',  2 => 'second', 3 => 'third', 4 => '
+fourth');

my %tablenames = map { $_ => "$quarternames{$_}quarter" } 
                      keys %quarternames;

my %queries = map { $_ => " SELECT * FROM $tablenames{$_} WHERE 
                            userid = ? AND period = ? AND gradetype = 
+? " 
                  } keys %tablenames;

sub termgrades {
    my $period  = shift;
    my $quarter = shift;
    my $sth;
 
    return undef unless exists $queries{$quarter};
    $sth = $dbh->prepare_cached($queries{$quarter})
           or do { error ("2", "Could not prepare query for $quarterna
+mes{$quarter} quarter for $userdata[0]: $dbh->errstr");
                   return undef;
    };

    $sth->execute($userdata[0], $period, 2)
         or error("2", "Could not execute query for $quarternames{$qua
+rter} quarter for $userdata[0]: $sth->errstr");
    return $sth;
}
[download]

Update: Made hash initialization slightly more clever.

While I get a sick kind of pleasure ripping on someone else's work, I have to admit that I used to write stuff like that. In fact, I still might. But I wouldn't know it unless I published it at a place like the monastery and had the good Monks critique it--which has happened many times, which is why I'm a better programmer than I was 3000 XP ago. It's how I learned about taint, and strict, and references, and placeholders.

I'm sure this has come up around here before, but I wish there was an designated "safe" area here at PM's to post code and have it critiqued. That's how ya learn. It would be invaluable to me who is passionate about doing it correctly, but not always understanding how.

And it would be faster. I remember asking a teacher back in college why I needed a teacher. He admitted I could probably learn it myself, but it would take 10 times longer.

Would anyone else benefit from this?

That place already exists: Seekers of Perl Wisdom.

WTF? There's this .NET stack trace staring back at me. Only slightly ironic :)

Server Error in '/' Application.
Timeout expired. The timeout period elapsed prior to completion of the
+ operation
or the server is not responding. General network error. Check your net
+work 
documentation.
[download]

It's like those recurring Java stack traces over at Artima

/J