shapeshifter.se » PHP

UUID generator for PHP

fli — Mon, 29 Sep 2008 18:48:44 +0000

UUID (Universally Unique Identifier) is standard (part of ISO/IEC 11578:1996) to create “universally unique” identifiers to identify objects within a system or across system boundaries. The identifiers are 128-bit in length (that’s 16 bytes) and while there really is no way to guarantee global uniqueness the probability of colissions are very small both thanks to the number of bits and the way the identifiers are created.

The UUID generation algorithms are specified in RFC4122 and I’ve created a static PHP class that implements version 1 which is time based UUID, version 4 which is truly psuedo random UUID and version 3 and 5 which are named based UUID, using either MD5 (version 3) or SHA-1 (version 5).

I know there is a PECL package around the original uuidlib but this class have no external dependencies. The full source is available at the bottom of the page.

The class has the following public functions, their return value depends on the format argument.

$mixed generate($type, $fmt = self::FMT_BYTE, $node = "", $ns = "")
$mixed convert($uuid, $from, $to)

UUID version constants where each constant represents a specific UUID version

UUID_TIME, UUID_NAME_MD5, UUID_RANDOM, UUID_NAME_SHA1

UUID format constants

FMT_BYTE is the default and returns a array of bytes that represents the 128-bit UUID.
FMT_FIELD returns a associative array with individual fields as the format specified in RFC4122.
FMT_STRING returns the familiar ASCII representation of a UUID (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxx).
FMT_BINARY returns a raw 128-bit binary representation of the UUID.

The convert method can be used to convert between these representations.

UUID version 1 example

xxxxxxxxx-xxxx-1xxx-xxxx-xxxxxxxxxxxx
Version 1 UUIDs are timed based with the node constant. The name space argument is ignored and is not used in the generation. The node identifier (”abcdef” in this case) should identify the node or object, only 6 bytes (or characters) are used from the node id.

require_once('class.uuid.php');
$str = UUID::generate(UUID::UUID_TIME, UUID::FMT_STRING, "abcdef");
print "$str\n";

Example output, the last part is the node id and will remain constant (as long as the node id is the same), the first part will change according to time while the middle part is pseudo random.

1b55e723-578b-4e34-d5cf-616263646566

The class does not fully implement version 1 as described in the RFC. The clock sequence is generated from a psuedo random generator each time a new UUID is generated and not written and read from a stable storage as described in the RFC.

UUID version 4 example

xxxxxxxxx-xxxx-4xxx-xxxx-xxxxxxxxxxxx
Version 4 is a fully pseudo random where all fields are randomly generated.

require_once('class.uuid.php');
$str = UUID::generate(UUID::UUID_RANDOM, UUID::FMT_STRING);
print "$str\n";

Kind of useless example output

d8988842-43d5-42b3-9049-af4bbc694dbe

UUID version 3/5 example

xxxxxxxxx-xxxx-3/5xxx-xxxx-xxxxxxxxxxxx
The main difference is that a node id is unique within a name space and a UUID generated from the same node id and name space is always the same. The generation algorithm is the same for both version 3 and 5 with the only difference being the hash method used (MD5 versus SHA1).
This is the example from the RFC.

require_once('class.uuid.php');
 
/*
 * 6ba7b810-9dad-11d1-80b4-00c04fd430c8 is the DNS name space
 */
$md5 = UUID::generate(UUID::UUID_NAME_MD5, UUID::FMT_STRING,
    "www.widgets.com", '6ba7b810-9dad-11d1-80b4-00c04fd430c8');
$sha1  = UUID::generate(UUID::UUID_NAME_SHA1, UUID::FMT_STRING,
    "www.widgets.com", '6ba7b810-9dad-11d1-80b4-00c04fd430c8');
print "MD5: $md5\n";
print "SHA1: $sha1\n";

Example output

MD5: e902893a-9d22-3c7e-a7b8-d6e313b71d9f
SHA1: 13726f09-44a9-5eeb-8910-3525a23fb23b

Final notes

This class have been tested with PHP 5.2.x on both little and big endian machines. While there could be bugs in the algorithm implementation at least they are consistent across platforms

Get from github

class.uuid.php

Asynchronous background execution with PHP

fli — Mon, 04 Aug 2008 08:23:12 +0000

If you ever worked with threads and particular work queues you know how convenient they can be.
Have some demanding work that needs to be done but no time to do it yourself? No problem, just put it on the work queue and continue with whatever we were doing, some other thread will come along and do the dirty work for you.

Consider the following scenario. Actions and inputs from a web page triggers something that might take a (very) long time to execute and if executed during the browser session which besides annoying the user who has to wait for a page to load, might cause a time out and interrupt the processing. How do we solve this?

I’ll use the term job to indicate some work that needs to be execution, in practice this is an isolated PHP function which takes an unspecified time to execute.

Some possible solutions

Store job information somewhere (like a SQL database) have a separate script, PHP or in some other language, running on the host, either continuously or from crontab. The obvious flaw is that it requires additional administrative maintenance to keep the script running and if executed from crontab, will cause an additional delay before the job is executed.
Use pcntl_fork from inside the (web page) PHP script and execute the job function in the child, problem is that this will fork an entire Apache (or whatever web server you’re using) processes which can cause all sorts of problems.
Some other solution I didn’t think about?

My solution ended up being a mix of the two above. It consists of three major parts and, a bit simplified, works like this

Job information is stored in a SQL database.
An external CLI-based worker PHP-script is launched from inside the web page script using proc_open.
The worker script, which is running in an isolated PHP process calls pcntl_fork to create a duplicate of itself. The parent returns directly to the web page script.
The child process of the worker script now runs free of any webserver process and can now retrieve job information from the SQL database. When all jobs are executed it kills itself.

Here is a nice block diagram that shows the interaction of the components

And viola, we have asynchronous background execution of (almost) arbitrary PHP functions. There are a few problems left to solve, we’ll tackle those further down.

Requirements

PHP 5 built with CLI support
The PHP module pcntl
The classes SQLConnector and Prefs published in earlier posts.

SQL database

First, we’ll need some database support. I’ve used MySQL, but any database should work fine. One simple table is required, it’s called jobs and looks like this

+-------+---------------------+------+-----+---------+----------------+
| FIELD | Type                | NULL | KEY | DEFAULT | Extra          |
+-------+---------------------+------+-----+---------+----------------+
| jid   | bigint(20) UNSIGNED | NO   | PRI | NULL    | AUTO_INCREMENT | 
| DATA  | text                | YES  |     | NULL    |                | 
+-------+---------------------+------+-----+---------+----------------+

The column jid is an arbitrary job id and the column data contains job information (more on what exactly job information is will be covered further down). You can create this table with the following SQL command

CREATE TABLE jobs (jid bigint UNSIGNED AUTO_INCREMENT,
    DATA text, PRIMARY KEY (jid))

PHP implementation

The implementation consists of three files, we’ll focus on the class jobs first. This leads us into what exactly the data column should contain. Since the job (PHP function) will execute in a new context the worker must be able to bring in PHP files so that required functions and classes can be resolved. So, in addition to the actual job function and an opaque argument we also need to store a list of PHP files to include at execution time.

The complete data structure stored in the data column looks like this.

$data = array(
    /* Version identifier of job structure */
    'version' => 1,
    /* Array of PHP files to include at execution time */
    'include' => array(),
    /* Name of actual job function */
    'callback' => '',
    /* Opaque argument passed to callback function */
    'args' => null,
);

A dedicated class calls jobs manages jobs and allows enqueuing and dequeuing of jobs. For clarity, only the function prototypes are shown here, the full source code can be found at the bottom of the pafe.

class jobs {
    private $m_con; /* SQL Connector */
    const jobversion = '1'; /* Job structure version */
 
    private $m_data = array(
        'version' => self::jobversion,
        'include' => array(),
        'callback' => '',
        'args' => null,
    );
 
    /*
     * Enqueue a job for execution
     *  cb - Name of PHP function to execute
     *  args - Arguments to pass to 'cb'
     *  incs - Array of PHP files to include before execution
     */
    public function enqueue($cb, $args, $incs);
 
    /*
     * Return the job identifier (integer) of
     * next available job or -1 if no new jobs are
     * available.
     */
    public function nextJob();
 
    /*
     * Dequeue job with id 'jid' for execution,
     * if no such job is available null is returned.
     *
     * An array with the following keys are returned
     *  (jid, include, callback, args)
     */
    public function dequeue($jid);
 
    /*
     * Attempt to launch worker process if not already running
     */
    private function startWorker();
}

The callback function ‘cb’ will be called like this, cb(args), before this call all files listed in the array incs will be included using require_once.
The functions enqueue, dequeue and nextJob are nothing special, they simply do normal SQL manipulation (inserts and removes job from the table). However the routine startWorker might deserve some attention (it’s called internally from enqueue)

/* Should be set to the path of the CLI PHP binary */
define("PHP_PATH",      "/usr/local/bin/php");
 
private function startWorker() {
    /*
     * Attempt to read the preference
     * 'worker_pid' to check if the worker is
     * already running.
     */
    $prefs = new Prefs($this->m_con, 'jobs');
    $pid = $prefs->worker_pid;
    if ($pid != null)
        return;
 
    /* Get our working directory */
    $cwd = getcwd();
 
    /*
     * Construct a command such as the following
     *  /usr/local/bin/php /working/path/worker.php
     */
    $cmd = escapeshellcmd(PHP_PATH ." $cwd/worker.php");
    $desc = array();
 
    /* Execute the command and wait for it to finish */
    $proc = proc_open($cmd, $desc, $pipes, NULL, NULL);
    proc_close($proc);
}

The startWorker function is executed in the context of a web page (from inside the Apache PHP module for example) and as you can see it doesn’t call pcntl_fork directly. Technically it still forks, otherwise it wouldn’t be able to execute another process. But we let the PHP module deal with that mess.

This leads us to worker.php
File: worker.php

require_once('jobs.inc');
require_once('prefs.inc');
require_once('db_mysql.inc');
define("PHP_PATH",      "/usr/local/bin/php");
 
if (!isset($argv)) {
    exit("Don't call me from a browser");
}
 
/*
 * Fork our self and let the parent return directly to startWorker
 */
$pid = pcntl_fork();
if ($pid == -1) {
   die("could not fork");
} else if ($pid) {
    /*
     * This is the parent process. Record the child pid so that we
     * don't launch more processes than wanted.
     */
    $con = new MySQLConnector('localhost', 'user', 'pwd', 'db');
    $prefs = new Prefs($con, 'jobs');
    $prefs->worker_pid = $pid;
    $prefs->Flush();
    /*
     * Exit the script, it runs in a separate
     * PHP process NOT inside Apache
     */
    exit;
}
 
$con = new MySQLConnector('localhost', 'user', 'pwd', 'db')
$jobs = new jobs($con);
 
$cwd = getcwd();
if ($cwd == false)
    exit("can't get working directory");
 
/*
 * Loop over all available jobs
 */
$pjid = -1;
for (;;) {
    $jid = $jobs->nextJob();
    if ($jid == -1 || $jid == $pjid)
        break;
 
    /*
     * Execute each job in a clean environment
     */
    $cmd = escapeshellcmd(PHP_PATH . " $cwd/job_execute.php $jid");
    $desc = array();
    $proc = proc_open($cmd, $desc, $pipes);
    proc_close($proc);
 
    $pjid = $jid;
}
 
/* Tell the world that we aren't executing any more */
$prefs = new Prefs($con, 'jobs');
$prefs->worker_pid = null;

The first thing that happens is that worker.php forks itself and lets the parent return directly to the caller, which in this case is startWorker. This allows startWorker and thus enqueue to finish and the calling PHP script can resume with what ever it was doing (creating a web page etc).

Also note that worker.php doesn’t execute the job functions directly, instead it hands the jid number to a second script called job_execute.php. There is a good reason for this, since we must include PHP files (with require_once) to be able to execute the job function the namespace of the worker would be contaminated quite fast and with that comes the risk of name collisions. By letting each job execute in a totally clean environment they can include only the files needed for their execution and thus avoid any name collisions.

job_execute.php takes a job id (jid) as argument, dequeues the job, includes all required files, calls the job function and then terminates.

File: job_execute.php

require_once('jobs.inc');
require_once('db_mysql.inc');
 
if (!isset($argv)) {
    exit("Don't call me from a browser");
}
 
if (!isset($argv[1])) {
    exit("Job missing");
}
$jid = $argv[1];
 
$con = new MySQLConnector('localhost', 'user', 'pwd', 'db');
$jobs = new jobs($con);
$job = $jobs->dequeue($jid);
if ($job == null)
    exit("Job dequeue failed");
 
/*
 * Include required files
 */
foreach ($job['include'] as $inc) {
    require_once($inc);
}
 
/* Execute the job handler */
$cb = $job['callback'];
$cb($job['args']);

Okay, that should be all. Are you still with me?

Using it

After all this…how do one use this then? First of all we need one or more job functions that we would like to be background executed. The prototype for such a function looks like this

function myBgFunc($args) { ... }

Where args can be anything you like (as long as PHP allows it). Put the function inside a file and include (preferably with require_once) any other files that you might need. For example like this, not the best example, but anyway.

File: myfunc.php


/* $args is an integer in this case */
function test1($args) {
    $j = 1;
    for ($i = 0; $i < $args; $i++) {
       $j *= 1.00001;
    }
    /* Report result somewhere */
}
?>

Now, from your run-of-the-mill PHP script, create a jobs object and enqueue the function test1.

require_once('db_mysql.inc');
require_once('jobs.inc');
$con = new MySQLConnector('localhost', 'user', 'pwd', 'db');
$jobs = new jobs($con);
/* Remember, "function", "argument", "files needed" */
$jobs->enqueue("test1", rand() * 1000, array('myfunc.php'));
print "Job enqueued";

Even if test1 takes ages to execute, the enqeue function will execute in a fraction of a second and report back directly to the web browser. You can enqueue any number of functions, they will be executed on a first-come first-serve basis.

Improvements

I’ve tested this a bit and it seems to work, however I haven’t put it through some real situation test yet. With some additional locking it should be possible to run multiple instances of worker.php to take advantage of SMP systems.

There is no built-in mechanism to know when a job has finished. The job function will need to report its results to a SQL database for example. If browser feedback is needed an AJAX solution could poll the database for the execution status.

Files

Files with complete source code

If you found this useful consider putting a link back to this article from your own blog/website, thanks.

SQL backed preference system for PHP

fli — Sat, 02 Aug 2008 12:30:27 +0000

Sometimes you need to store information and settings that really doesn’t fit into any other SQL table, in these situations it’s nice to have a generic key-value driven preference system.

The preference system consists of multiple stores or trunks, each store is identified by a unique, arbitrary string and each store has multiple key-value pairs. The key-value pairs are dynamically created and flushed to database when the preference object is destroyed or when an explicit flush is requested.

This offers a very flexible system, illustrated by this example

$c = new MySQLConnector('localhost', 'username', 'password', 'db');
/* Create a preference store called 'store1' */
$store1 = new Prefs($c, 'store1');
/* Create a preference store called 'myprefs' */
$myprefs = new Prefs($c, 'myprefs');
 
$store1->some_setting = 10;
$myprefs->abcd = 1234;
$store1->abcd = 4321;
$myprefs->a_list = array(1, 2, 3, 4);
 
print $myprefs->abcd * $store1->some_setting;
 
/* Do an explicit write to the database */
$store1->Flush();

To build a system like this you’ll first need a SQL table in some database, I’ve called the table prefs. The table layout is very simple and only consists of two columns, the first is the store identifier and the second contains key-value pairs.

+-------+-------------+------+-----+---------+-------+
| FIELD | Type        | NULL | KEY | DEFAULT | Extra |
+-------+-------------+------+-----+---------+-------+
| ident | varchar(64) | NO   | PRI |         |       | 
| DATA  | text        | YES  |     | NULL    |       | 
+-------+-------------+------+-----+---------+-------+

You can create this table with the following SQL command

CREATE TABLE prefs (ident varchar(64), DATA text, PRIMARY KEY (ident))

The class itself Prefs is shown below

Note that this requires the SQL connector classes published earlier, if you don’t want to use those you’ll need to modify all SQL queries below to suite your needs.

File: prefs.inc


require_once('db_iface.inc');
 
/*
 * Automatic SQL-backed preference system
 */
class Prefs {
    /* Connection handle */
    private $m_con;
    /* Store identifier */
    private $m_ident;
    /* Contains key-value pairs */
    private $m_data = array();
 
    private $m_dirty = false;
    private $m_fetched = false;
 
    public function __construct($connector, $ident) {
        $this->m_con = $connector;
        $this->m_ident = addslashes($ident);
    }
 
    /* Write changes to database when object is destroyed */
    public function __destruct() {
        $this->doflush();
    }
 
    private function __get($nm) {
        $this->dofetch();
        if (!isset($this->m_data[$nm]))
            return null;
        else
            return $this->m_data[$nm];
    }
 
    private function __set($nm, $val) {
        $this->dofetch();
        $this->m_data[$nm] = $val;
        $this->m_dirty = true;
    }
 
    /* Do an explicit flush to the database */
    public function Flush()
    {
        $this->doflush();
    }
 
    /*
     * Write key-value pairs to database
     */
    private function doflush() {
        if (!$this->m_dirty)
            return;
 
        $data = addslashes(serialize($this->m_data));
        $ident = $this->m_ident;
        $this->m_con->query("select count(*) from prefs where ident = '$ident'");
        $res = $this->m_con->fetchRow();
        if ($res[0] == 1) {
            $this->m_con->query("update prefs set data = '$data' where ident = '$ident'");
        }
        else {
            $this->m_con->query("insert into prefs(ident, data) values('$ident', '$data')");
        }
 
        $this->m_dirty = false;
    }
 
    /*
     * Read key-value pairs from database
     */
    private function dofetch() {
        if ($this->m_fetched)
            return;
        $ident = $this->m_ident;
        $this->m_con->query("select data from prefs where ident = '$ident'");
        if ($this->m_con->getNumRows() == 1) {
            $res = $this->m_con->fetchRow();
            $this->m_data = unserialize(stripslashes($res[0]));
        }
        $this->m_fetched = true;
    }
}
 
?>

So how can this work then? the class uses the two magic constructs __set and __get to build automatic properties, there routines are called when an non-existing property is accessed.

For example

$obj->foo = 10;

This code would trigger __set in the class associated with $obj, it would be called with __set(”foo”, 10).
The same goes for

print $obj->foo

which would trigger __get(”foo”) in the class associated with $obj.
These implicit pairs are then stored in an array which is serialized and stored in a SQL database.

Note that this system makes use of serialize which is a PHP specific construct, this might make it difficult to access the data from other languages.

prefs.inc

If you found this helpful, tell a friend or put a link back to this article on your own website/blog.

Generic Object Oriented SQL interface for PHP

fli — Fri, 01 Aug 2008 15:19:34 +0000

This is an extensible object oriented wrapper around the MySQL and MSSQL (Microsoft SQL Server) interfaces provided by PHP. I’ve been using them for a while, it’s nothing new and no rocket science but others might find them useful.

Why do this at all? why just not stick with the API provided by PHP? It’s really nothing else than a more convenient way to interact with a SQL server and exposing it’s interface in a vendor natural way. Instead of writing mysql_query everywhere, one simply writes query.

Having a consistent interface will obviously help if you are using multiple types of database servers or someday would like to migrate to another SQL server (of course, weird and vendor specific SQL code could be a problem in this case). Other advantages are things like automatic disconnection on object destruction etc.

The foundation is an abstract class called SQLConnector and provides the basic interface. The class will connect to the database on creation and disconnect when the object is destroyed, it also implements __sleep and __wakeup so that it’s possible to serialize a SQL connection.

Because SQLConnector is abstract one can’t create objects directly from it, we’ll create child classes for each type of SQL-server we want to connect to. These objects will share the same interface and can be used interchangeably.

File db_iface.inc

<php
abstract class SQLConnector
{
    private $m_dbAddress; /* Address of SQL server */
    private $m_dbAccount; /* Account name (username) */
    private $m_dbPwd;     /* Password */
    private $m_dbName;    /* Initial database */
 
    /* Base constructor */
    public function __construct($address, $account, $pwd, $name) {
        $this->m_dbAddress = $address;
        $this->m_dbAccount = $account;
        $this->m_dbPwd = $pwd;
        $this->m_dbName = $name;
 
        /* Call the connect method in the child class */
        $this->connect($this->m_dbAddress, $this->m_dbAccount,
            $this->m_dbPwd, $this->m_dbName);
    }
 
    /* Let the child disconnect when the object is destroyed */
    public function __destruct() {
        $this->disconnect();
    }
 
    /* We are about to be serialized, disconnect
     * and return data needed for serialization
     */
    public function __sleep() {
        $this->disconnect();
        return array('m_dbAddress', 'm_dbAccount',
            'm_dbPwd', 'm_dbName');
    }
 
    /* We have been unserialized, re-connect */
    public function __wakeup() {
        $this->connect($this->m_dbAddress, $this->m_dbAccount,
            $this->m_dbPwd, $this->m_dbName);
    }
 
    /*
     * Abstract methods that needs to be implemented by child classes
     */
    abstract protected function connect($address, $account,
        $pwd, $name);
    abstract protected function disconnect();
    abstract function query($query);
    abstract function fetchRow();
    abstract function fetchAll();
    abstract function getNumRows();
    abstract function freeResult();
    abstract function getError();
}
?>

The following class implements MySQL connectivity using the interface above

File: db_mysql.inc


 
require_once('db_iface.inc');
 
class MySQLConnector extends SQLConnector
{
    private $m_dbHandle;
    private $m_Result;
 
    /* 
     * Connect function, also selects correct database
     * Returns 1 upon success, otherwise 0
     */
    function connect($address, $account, $pwd, $name) {
        $this->m_dbHandle = @mysql_connect($address, $account, $pwd);
 
        if ($this->m_dbHandle != 0) {
            if (mysql_select_db($name, $this->m_dbHandle)) {
                return 1;
            }
            else {
                return 0;
            }
        }
        else {
            return 0;
        }
    }
 
    /*
     * Disconnect function
     * Returns 1 upon success, otherwise 0
     */
    function disconnect() {
        if (@mysql_close($this->m_dbHandle) != 0) {
            return 1;
        }
        else {
 
            return 0;
        }
    }
 
    /*
     * Does a mysql-query, returns 1 upon sucess otherwise 0
     */
    function query($query) {
        $this->m_Result = mysql_query($query, $this->m_dbHandle);
 
        if ($this->m_Result != 0) {
            return 1;
        }
        else {
            return 0;
        }
    }
 
    /*
     * Fetches an array row
     */
    function fetchRow() {
        return mysql_fetch_array($this->m_Result);
    }
 
    function fetchAll() {
        while ($row = mysql_fetch_array($this->m_Result)) {
            $a_rs[] = $row;
        }
        mysql_free_result($this->m_Result);
        return $a_rs;
    }
    /*
     * Get number of rows
     */
    function getNumRows() {
        return mysql_num_rows($this->m_Result);
    }
 
    /*
     * Free resources allocated by a query 
     */
    function freeResult() {
        mysql_free_result($this->m_Result);
    }
 
    /*
     * Get errorstring
     */
    function getError() {
        return mysql_error($this->m_dbHandle);
    }
}

A (very) similar class for MSSQL connectivity
File: db_mssql.inc


require_once('db_iface.inc');
 
class MSSQLConnector extends SQLConnector
{
    private $m_dbHandle;
    private $m_Result;
 
    /*
     * Connect function, also selects correct database
     * Returns 1 upon success, otherwise 0
     */
    function connect($address, $account, $pwd, $name) {
        $this->m_dbHandle = @mssql_connect($address, $account, $pwd);
 
        if ($this->m_dbHandle != 0) {
            if (mssql_select_db($name, $this->m_dbHandle)) {
                return 1;
            }
            else {
                return 0;
            }
        }
        else {
            return 0;
        }
    }
 
    /*
     * Disconnect function
     * Returns 1 upon success, otherwise 0
     */
    function disconnect() {
        if (@mssql_close($this->m_dbHandle) != 0) {
            return 1;
        }
        else {
            return 0;
        }
    }
    /*
     * Does a mssql-query, returns 1 upon success otherwise 0
     */
    function query($query) {
        $this->m_Result = mssql_query($query, $this->m_dbHandle);
 
        if ($this->m_Result != 0) {
            return 1;
        }
        else {
            return 0;
        }
    }
 
    /*
     * Fetches an array row
     */
    function fetchRow()
    {
        return mssql_fetch_array($this->m_Result);
    }
 
    function fetchAll()
    {
        while ($row = mssql_fetch_array($this->m_Result)) {
            $a_rs[] = $row;
        }
        mssql_free_result($this->m_Result);
        return $a_rs;
    }
 
    /*
     * Get number of rows
     */
    function getNumRows()
    {
        return mssql_num_rows($this->m_Result);
    }
 
    /*
     * Free resources allocated by a query
     */
    function freeResult()
    {
        mssql_free_result($this->m_Result);
    }
    /*
     * Get errorstring
     */
    function getError()
    {
        return mssql_error($this->m_dbHandle);
    }
}
?>

So, how do one use this then? It’s quite simple

require_once('db_mysql.inc');
require_once('db_mssql.inc');
 
$c1 = new MySQLConnector('mysql-host', 'username', 'password', 'mydb');
$c2 = new MSSQLConnector('mssql-host', 'username', 'password', 'mydb');
 
$c1->query("select something from somewhere");
while ($row = $c1->fetchRow()) {
 ...
}
 
$c2->query("select somethingelse from somewhereelse");

Improvements, oh yes. The connect functions should really throw an error if things doesn’t work.
Also, wrappers for any SQL server should be quite easy to implement.

db_iface.inc – Abstract interface
db_mysql.inc – MySQL interface
db_mssql.inc – MSSQL interface

If this article was usable or otherwise helpful for you, tell a friend or put a link back from your own website/blog.