Simple PHP Object Persistence
BaseVO.class.php
First of all let’s define the common variables that we will need in each and every class:
var $table = null;
var $className = __CLASS__;
var $id = null;
While $id can be left as is in this class, $className and $table will have to be set in every descending class.
Next we need a way to retrieve the object from the database:
/**
* Loads an entry given it's id.
*/
function load($id){
global $db;
$this->loadFromArray($db->queryArray("SELECT * FROM ".$this->table." WHERE id='".$id."';"));
}
/**
* Loads the object from an array, possibly from an SQL-ResultSet.
*/
function loadFromArray($arr){
if(count($arr)<2)
return;
foreach($arr as $k =>; $v){
$this->$k = $v;
}
}
Now that we can load the objects from the database, what would be more obvious than trying to save them back to the Database? Here you go:
function save(){
global $db;
// Get the fields.
$rs =& mysql_query("DESCRIBE ".$this->table.";");
while($t = mysql_fetch_assoc($rs)){
$fields[$t["Field"]] = $this->$t["Field"];
}
$db->saveArray($this->table,$fields);
}
Anyway let’s move on to relations. First there is the many-to-one relation which means that the table has a foreign key pointing to another table. This is quite easy to implement, but I decided to give it an extra feature: caching. Let’s see how it’s done:
function setForeign($className,$key,$value){
$cacheName = "_".$key;
if(is_numeric($value)){
$this->$key =& $value;
$this->$cacheName = null;
}else{
$this->$key = $value->id;
$this->$cacheName =& $value;
}
}
function getForeign($className,$key){
$cacheName = "_".$key;
if(empty($this->$cacheName)){
$o =& new $className();
$o->load($this->$key);
$this->$cacheName =& $o;
}
return $this->$cacheName;
}
setForeign works in a similar fashion, but unsets the cache if the passed value is an id and not an instance of the object.
Ok, we’re almoset done with the BaseVO, last thing we have to look at is getMany which represents the one-to-many relation:
function &getMany($className,$options){
global $db;
$data =& $db->queryAllArray("SELECT * FROM ".(empty($options['table'])?$className."s":$options['table'])." WHERE ".(empty($options['foreign'])?$this->className:$options['foreign'])."='".$this->id."';");
$res = array();
foreach($data as $d){
$o =& new $className();
$o->loadFromArray($d);
$res[]=& $o;
}
return $res;
}
Database.class.php
As this is simply a wrapper to the mysql-functions I’ll just post it here and comment only the saveArray function.
< ?php
/**
* BaseVO, Basic Virtual Object, abstraction for object persistence.
* Copyright (C) 2007 Christian Decker
*
* @author Christian Decker <decker.christian@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http ://www.gnu.org/licenses/>.
*/
class Database {
var $fd = null;
function Database($host, $username, $password, $dbname){
$this->fd =& mysql_pconnect($host, $username, $password) or die(mysql_error());
mysql_select_db($dbname,$this->fd) or die(mysql_error());
}
function close(){
return mysql_close($this->fd);
}
function &query($sql){
print($sql."\n");
$rs =& mysql_query($sql) or die(mysql_error());
return $rs;
}
function queryArray($sql){
return mysql_fetch_assoc($this->query($sql));
}
function exec($sql){
$this->query($sql);
}
/**
* @return bool - Was the saved array new or did it matched an existing one?
*/
function saveArray($table, $arr){
$atoms = array();
foreach($arr as $k => $v){
$atoms[] = $k."='".$v."'";
}
$sql = "";
$new = !$arr['id'] || $arr['id'] == null;
if($new){
// INSERT
unset($arr['id']);
$sql = "INSERT INTO ".$table." SET ".implode(',',$atoms).";";
}else{
// UPDATE
$sql = "UPDATE ".$table." SET ".implode(',',$atoms)." WHERE id='".$arr['id']."';";
}
$this->exec($sql);
return $new?mysql_insert_id():null;
}
function &queryAllArray($sql){
$res = array();
$rs =& $this->query($sql);
while($t = mysql_fetch_assoc($rs))
$res[] = $t;
return $res;
}
}
?>
saveArray takes an array of key-value-pairs and saves it into the table. If the id is not set it inserts a new row, otherwise the existing row is updated.
Example
As the above makes no sense at all by itself here comes a bit of code I’m currently working on that uses it. First is a User-class that is used to represent the sites users. A user has many bank accounts:
require_once('BaseVO.class.php');
require_once('Account.class.php');
class User extends BaseVO {
var $username = null;
var $password = null;
var $email = null;
var $accounts = null;
var $table = "users";
var $className = "User";
function getAccounts(){
return $this->getMany("Account",array('table' => 'accounts','foreign' => 'owner'));
}
}
This uses the getMany-function to retrieve all the accounts a user may have. Let’s see these accounts:
require_once('BaseVO.class.php');
require_once('User.class.php');
require_once('Entry.class.php');
class Account extends BaseVO {
var $owner = null;
var $name = null;
// Cached items
var $_owner = null;
var $table = "accounts";
var $className = "Account";
function setOwner($user){
return $this->setForeign("User","owner",$user);
}
function getOwner(){
return $this->getForeign("User","owner");
}
function getEntries(){
return $this->getMany("Entry",array('table' => 'entries'));
}
}
Besides the normal variable and function declaration there are the functions that rely on setForeign, getForeign and getMany to work on the related objects. Pretty simple, huh?,
Now to complete the relations I’ll just put the Entry class too, but by now you should be able to write it yourself
require_once('BaseVO.class.php');
require_once('User.class.php');
class Entry extends BaseVO {
var $account = null;
var $amount = 0;
var $description = '';
// Cached items
var $_account = null;
var $table = "entries";
var $className = __CLASS__;
function setAccount($account){
$this->setForeign("Account","account",$account);
}
function getAccount(){
return $this->getForeign("Account","account");
}
}
Ok, that’s it for now. Any feedback is very welcome
And for all of those that don’t want to reconstruct my files using the above here’s all the code in their files:
) and I can keep it on all night once again.
