Inheriting and overriding PEAR DB

[Catharsis]

Hi there,

Im trying to write a class that uses PEAR's DB layer as a baseline. I wanted to over-ride the prepare, execute and query methods so that I can log everything that goes into and out of the functions to somewhere. I cant for the life of me get it to work.

<?php

require_once ('DB.php');

class MyDB extends DB {

function checkError ( $input ) {
   print "checking error\n";
   if ( PEAR::isError( $input ) ) {
      print( $input->getMessage() );
      print( 'DB Error '.$input->getUserInfo() );
     return 0;
  } else {
     return $this;
  }
}

function prepare ( $QUERY ) {
    print 'ooooooooooooooo';
    $sth = DB::prepare( $QUERY );
    return $this->_checkError( $sth );
   }

   function &execute ( $sth, $data = array() ) {
       $res =& DB::execute( $sth, $data );
       return $this->_checkError( $res );
   }

}

 $dsn = "mysql://something@localhost/db";

 $db =& MyDB::connect( $dsn );
 $UPDATE = "UPDTE table SET something = something + 1";
 $sth = $db->prepare( $UPDATE );
 $res =& $db->execute( $sth );
 print $db->affectedRows(); 

?>

This bit of code uses the DB prepare function and not mine, I know this as it does not print out 'ooooo' and there is a deiberate error in the SQL statement thats not being errored, what am I doing wrong?

Eventually I want override the connect method too, to also automatically use the _checkError when a connection is made.

[bubblenut]

To understand what's happening here you need to know a little about how PEAR:😃B works. Locate DB.php and take a look inside.

DB works on a selection of subclasses which handle the specifics of different databases. The static connect method of DB doesn't just return an instance of DB it analyzes the dsn (DB.php:520) and from that determines which of it's subclasses to instantiate (DB.php:547). So when you connect with

$db =& DB::connect( 'mysql://something@localhost/db' );

You're actually getting an instance of DB_mysql (a subclass of D😎 returned.

In order to have you're logging take place you're going to tackle the problem quite differently. Now would be a good time to go out and buy a design patterns book, or check out www.phppatterns.com.

One particular design pattern concerns itself with this problem almost exactly, it's called Decorator. Now, in your case you want to "decorate" your DB (or subclass thereof) object with logging capabilities. Your decorator class needs to hold the same interface as DB's database specific subclasses do (basically everything except for it's static methods) and then you would instantiate it like this.

$db =& new DBLogger( DB::connect( 'mysql://something@localhost' );

Within each of the methods which you choose to implement in DBLogger it just does what it needs to and then sends it off to the DB object (which it has stored internally as a parameter).

[Catharsis]

Thanks for that, I found the pattern you are talking about. Ive set aside some time later on today to try and give it a whirl. Will let you know how I get on.

[Catharsis]

Well I got a 'bit' of it working, but still not a full implementation as yet. Heres what I have so far.

<?php

require_once 'DB.php';

class Decorator extends DB {
    function Decorator() {}
}

class DBLog extends Decorator {

function prepare( $arg ) {
    $sth = DB_common::prepare( $arg );
    return $this->_checkError( $sth );
}

function &execute ( $sth, $data = array() ) {
    $res =& DB_common::execute( $sth, $data );
    return $this->_checkError( $res );
}

/**
 * Basic checker that returns the Error status back from the Database, 
 * any errors are logged
 * @param DB
 */

function _checkError ( $input ) {
   if ( PEAR::isError( $input ) ) {
      print ( $input->getMessage() );
      print ( 'DB Error '.$input->getUserInfo() );
      return 0;
   } else {
      return $input;
   }
}

}

$dsn = 'mysql://root@localhost/db';

$db =& new DBLog( DB::connect( $dsn ) );
$sth = $db->prepare( 'SELCT NOW()' );
$res =& $db->execute( $sth );

?>

Any further clues appreciated

[bubblenut]

You seem to have got the wrong end of the stick here. As a rule, I don't dish out code but I'm hoping you want to actually learn this (and I think you do) so here is a part completed implementation of DBLog.

class DBLog {
    /**
     * Instance of DB_Common which we're decorating
     */
    var $db;

/**
 * Variable we're going to log the messages to
 */
var $log;

/**
 * Constructor: Accepts an instance of DB_Common.
 * If you look at the DB source in your PEAR directory you'll see that the individual database parts
 * actually extend DB_Common rather than DB.
 *
 * @param DB_Common $db
 */
function DBLog( $db ) {
    // Set the passed in instance to a parameter
    $this->db = $db;
}

/**
  * Private logging method.
  *
  * @param String $msg
  */
function _log( $msg ) {
    // Add a new line onto the end if it doesn't already have one
    if( substr( $msg, -1 ) != "\n" ) $msg .= "\n";

    // Add the message to the log
    $this->log .= date($msg;
}

/**
 * The following methods just wrap those in the individual DB_Common classes and add logging
 */
function disconnect() {
    $this->_log( "Disconnected" );
    return $this->db->disconnect();
}

function simpleQuery( $query ) {
    $this->_log( "Query: $query" );
    return $this->db->simpleQuery( $query );
}

function fetchInfo( $result, $arr, $fetchmode, $rownum = null ) {
    $this->_log( "FetchInfo: $fetchmode, $rownum" );
    return $this->db->fetchInfo( $result, $arr, $fetchmode, $rownum );
}

function freeResult( $result ) {
    $this->_log( "FreeResult" );
    return $this->db->freeResult( $result );
}

function numCols( $result ) {
    $this->_log( "NumCols" );
    return $this->db->numCols( $result );
   }

function numRows( $result ) {
    $this->_log( "NumRows" );
    return $this->db->numRows( $result );
}

function autoCommit( $onoff = false ) {
    return $this->db->autoCommit( $onoff );
}

function commit() {
    return $this->db->commit();
}

function rollback() {
    return $this->db->rollback();
}

function affectedRows() {
    return $this->db->affectedRows();
}

function nextId( $seq_name, $ondemand = true ) {
    $this->_log( "nextId: " . $eq_name );
    return $this->db->nextId( $seq_name, $ondemand );
}
}

Notice that this is a case of composition rather than inheritance. In fact, this is one of the rules of good OO design "Favour composition over inheritance".

You have to implement every method you wish to use through your decrator, as you can see towards the bottom of the class this sometimes means just delegating the task directly. PHP5 makes this much easier with one of it's "magic" methods, __call()

[Catharsis]

Hey, thanks a lot, Your right saying I want to learn, I think I was trying to be too clever and run before I can walk. I appreciate the code. I actually had something like this when I went to bed last night (at about 3am) so after some re-thinking and perseverance I got something more working.

Its still not what you have demonstrated here. I am going to try and implkement the slightly more 'advanced' version that the website talks about. If your interested into what I get working I'll post it back somewhere.

Thank you once again