class MysqlCounter
{
    public function __construct($host, $username, $password)
    {
        $this->conn = mysql_connect($host, $username, $password, true);
           
        if($this->conn === false)
        {
            throw new Exception("Unable to connect to Mysql server: " . mysql_error());
        }
           
        $this->num_databases = 0;
        $this->num_tables = 0;
        $this->num_rows = 0;
    }
       
    private function query($sql)
    {
        $query = mysql_query($sql, $this->conn);
           
        if($query === false)
        {
            throw new Exception("Unable to run query: $sql\n" . mysql_error($this->conn));
        }
           
        if($query === true)
        {
            return array();
        }
           
        $rows = array();
           
        while ($row = mysql_fetch_array($query))
        {
            $rows[] = $row;
        }
           
        return $rows;
    }
       
    public function gather_stats($callback = false)
    {
        foreach($this->query("SHOW DATABASES") as $row_database)
        {
            $this->num_databases++;
               
            $this->query("USE `{$row_database['Database']}`");
               
            foreach($this->query("SHOW TABLE STATUS") as $row_table)
            {
                $this->num_tables++;
                $this->num_rows += $row_table['Rows'];
                   
                if($callback !== false)
                {
                    $args = array($row_database['Database'], $row_table['Name'], $row_table['Rows']);
                    call_user_func_array($callback, $args);
                }
            }
        }
    }
       
    public static function default_callback($database, $table, $rows)
    {
        printf("%s %s %d\n", $database, $table, $rows);
    }
}

$counter = new MysqlCounter('hostname', 'username', 'password');
$counter->gather_stats(array('MysqlCounter', 'default_callback'));
   
echo "Databases {$counter->num_databases}\n";
echo "Tables    {$counter->num_tables}\n";
echo "Rows      {$counter->num_rows}\n";

<?php
/*

    qpsmon.php  v0.1

    This is an (extremely) simple script that will get the average
    number of queries/second for several MySQL databases.


    Example Output:

        qpsmon v0.1
        Sample size 120 seconds.  [60 times every 2 seconds]
       
          Margaret   176 qps
             Yarra    11 qps
            Murray  1066 qps

*/


    error_reporting(E_ALL | E_STRICT);


    define('NUMBER_SAMPLES', 60);   //  Number of samples to keep
    define('PEROID_LENGTH', 2);     //  How often (in seconds) to take a simple
    define('AUTO_CLEAR', true);     //  Automatically clear the screen each refresh


    define('PROGRAM_NAME', 'qpsmon');
    define('PROGRAM_VERSION', '0.1');

   
    $databases = array
    (
        //  Define you MySQL databases here.  E.G.
        'My Server' => new MysqlConn('localhost', 'username', 'password', MysqlConn::MYSQL_VERSION_5),
    );


    class LimBuffer
    {
        private $maxSize;
        private $buffer = array();

        public function __construct($maxSize = 20)
        {
            $this->maxSize = $maxSize;
        }

        public function add($v)
        {
            $this->buffer[] = $v;

            if(count($this->buffer) > $this->maxSize)
            {
                $this->buffer = array_slice($this->buffer, -$this->maxSize);
            }
        }

        public function get()
        {
            return $this->buffer;
        }

        public function first()
        {
            return $this->buffer[0];
        }

        public function last()
        {
            return $this->buffer[count($this->buffer) - 1];
        }
    }

    class MysqlConn
    {
        const MYSQL_VERSION_4 = 1010;
        const MYSQL_VERSION_5 = 2020;
       
        private $host;
        private $username;
        private $password;
        private $mysqlVersion;

        private $conn = false;

        public function __construct($host, $username, $password, $mysqlVersion = self::MYSQL_VERSION_5)
        {
            if(!in_array($mysqlVersion, array(self::MYSQL_VERSION_4, self::MYSQL_VERSION_5)))
            {
                die("Invalid mysql version specified\n");
            }

            $this->host         = $host;
            $this->username     = $username;
            $this->password     = $password;
            $this->mysqlVersion = $mysqlVersion;
        }

        public function getQueryCount()
        {
            if(!$this->conn)
            {
                $this->connect();
            }

            $sql    = ($this->mysqlVersion == self::MYSQL_VERSION_4) ? ' SHOW STATUS' : 'SHOW GLOBAL STATUS';

            $query  = mysql_query($sql, $this->conn);

            while(($row = mysql_fetch_row($query)) !== false)
            {
                if($row[0] == 'Questions')
                {
                    return $row[1];
                }
            }

            return 0;
        }

        private function connect()
        {
            $this->conn = mysql_connect($this->host, $this->username, $this->password, true);
        }
    }

    function printHeader()
    {
        printf("%s v%s\n", PROGRAM_NAME, PROGRAM_VERSION);
        printf("Sample size %d seconds.  [%d times every %d seconds]\n", NUMBER_SAMPLES * PEROID_LENGTH, NUMBER_SAMPLES, PEROID_LENGTH);
        printf("\n");
    }


    //  For nicer formatting, here we get the maximum length of the
    //  databases names.
    $maxDatabaseNameSize = 0;
    foreach($databases as $name => $connection)
    {
        $maxDatabaseNameSize = (strlen($name) > $maxDatabaseNameSize) ? strlen($name) : $maxDatabaseNameSize;
    }


    if(!AUTO_CLEAR)
    {
        printHeader();
    }


    //  Our main loop
    $stats = array();

    while(true)
    {
        foreach($databases as $name => $connection)
        {
            //  First time round we need to init our stats array with
            //  a new Limit buffer with the correct sample size
            if(!isset($stats[$name]))
            {
                $stats[$name] = new LimBuffer(NUMBER_SAMPLES);
            }

            //  Add a new item, with the current time, and the total number
            //  of queries
            $stats[$name]->add(array('time' => time(), 'count' => $connection->getQueryCount()));
        }

        //  No point doing anything on the first run through
        //  Abusing scope here: $name is the from the last loop for the for statement above
        if(count($stats[$name]->get()) == 1)
        {
            sleep(PEROID_LENGTH);
            continue;
        }

        if(AUTO_CLEAR)
        {
            system("clear");
            printHeader();
        }
   
        foreach($stats as $name => $stat)
        {
            $first  = $stat->first();
            $last   = $stat->last();

            $period     = $last['time'] - $first['time'];
            $queryCount = $last['count'] - $first['count'];
            $qps        = $queryCount / ($period == 0 ? 1 : $period);

            printf("  %{$maxDatabaseNameSize}s %5d qps\n", $name, $qps);
        }

        printf("\n");

        //  Warn the user that we have yet to fill up out buffer
        if(count($stats[$name]->get()) != NUMBER_SAMPLES)
        {
            printf("Warming up...\n");
            printf("\n");
        }

        sleep(PEROID_LENGTH);
    }

?>