$sth->selectrow_arrayref(...)
[download]

$dbh->selectrow_arrayref($sth, ...)
[download]

Here's the approach I took:

use strict;
use warnings;

use DBI qw( );

# ----------------------------------------

BEGIN {
   package MyDBI;

   our @ISA = 'DBI';
}

# ----------------------------------------

BEGIN {
   package MyDBI::db;

   our @ISA = 'DBI::db';
}

# ----------------------------------------

BEGIN {
   package MyDBI::st;

   our @ISA = 'DBI::st';

   sub bind_params {
      my $sth = $_[0];
      for my $i (1..$#_) {
         $sth->bind_param($i, $_[$i])
            or return;
      }
      return 1;
   }

   sub _do_selectrow {
      my ($method, $sth, $attr) = splice(@_, 0, 3);
      $sth->execute(@_)
         or return;
      my $row = $sth->$method()
         or return;
      $sth->finish();
      return $row;
   }

   sub _do_firstrow {
      my ($method, $sth, $attr) = splice(@_, 0, 3);
      $sth->execute(@_)
         or return;
      my $row = $sth->$method()
         or return $sth->set_err($DBI::stderr, "No rows returned");
      $sth->finish();
      return $row;
   }

   sub selectrow_hashref  { return _do_selectrow('fetchrow_hashref', @
+_); }
   sub firstrow_hashref   { return _do_firstrow ('fetchrow_hashref', @
+_); }

   sub selectrow_arrayref { return _do_selectrow('fetchrow_arrayref', 
+@_); }
   sub firstrow_arrayref  { return _do_firstrow ('fetchrow_arrayref', 
+@_); }

   sub selectrow_array    { my $row = _do_selectrow('fetchrow_arrayref
+', @_) or return;  return wantarray ? @$row : $row->[0]; }
   sub firstrow_array     { my $row = _do_firstrow ('fetchrow_arrayref
+', @_) or return;  return wantarray ? @$row : $row->[0]; }
}

# ----------------------------------------

1;
[download]

You could surely override do using this method. Create the three classes, setup their inheritance relationship, and override do in ::db.

This points out why my attempts failed! Three classes not just one!

Thank you, ikegami, thank you!

Database handles and statement handles have different methods, so they are two different classes (::db and ::st). DBI itself provides global static methods. There's a fourth class (::dr) for database drivers.

DBI determines the name of the database handle class and the statement handle class based on the package used to create the connection ($pkg->connect), so there's no need to tell DBI about your ::db and ::st class. On the flip side, you need to create all three subclasses even if you only want to subclass one.

I wouldn't.

Just create classes that delegate to DBI and wrap DBI, potentially via AUTOLOAD. You will need:

1. One DBI-delegator, mainly implementing ->connect , returning
2. One DBH-delegator, mainly implementing ->prepare and ->do, likely via ->prepare->execute, and
3. One STH-delegator, mainly implementing ->execute and ->fetchall_*

I would stay away from inheritance and just store the DBI::* instances, as you seem to be mostly interested in the user side of interactions and not so much in actually modifying the behaviour of DBI and its components.

Thanks for the suggestion. I hadn't thought of delegation.

You might be able to use DBI callbacks to do what you want to do. They weren't documented but I believe they are now documented in the subversion tree of DBI. Just read the DBI docs for where to get DBI from subversion and read the docs on callbacks with perldoc -F DBI.pm

Thank you! Found Tim Bunce's blog that covers that here.

(Okay, assume, just for fun, that I wish to log the sql statement.)

Then you'd use DBI's logging facility. Search for trace in the DBI docs.

Mea maxima culpa! I should have looked!