<?php
require_once dirname(dirname(__FILE__)) . '/config.inc.php';

/* Required Pear Files*/
require_once 'PEAR.php';
require_once 'MDB2.php';

/* Required files */
require_once APPROOT . 'msgController.class.php';

/**
 * tableRender defines appropriate renders for 
 * the table class to using for rendering it's data
 *
 * @package default
 * @author Matthieu Lalonde
 */
interface tableRenderer
{
	/**
	 * Called when ever the first overload is received by the table class
	 *
	 * @param (tableAbstract object) &$myThis: reference to the table class for access to table information
	 * @return void
	 * @author Matthieu Lalonde
	 */
	public	function _init($myThis);
	
	/**
	 * Returns the inited state if the render implements such a state
	 * 
	 * @param BOOL $mode: allows false to be passed so to reset the init state of the renderer
	 * @return void
	 * @author Matthieu Lalonde
	 */
	public	function isInited($mode = -1);
	
	/**
	 * Outputs the current overloaded data from the tableAbstract.
	 * The tableAbstract uses this function for __toString if it is available
	 *
	 * @param (BOOL) $asText 
	 * @return void
	 * @author Matthieu Lalonde
	 */
	public	function Output($asText = false);
		
	/**
	 * Called when ever the tableAbstract overloads with __set()
	 *
	 * @param (string) $node: node name
	 * @param (string) $value: node value
	 * @param (array) $myFields: fields definition
	 * @param (string) $id: passed ID if rendering multiple nodes at the same time
	 * @return void
	 * @author Matthieu Lalonde
	 */
	public	function onSet($node, $value, $myFields, $myRow);
	
	/**
	 * Called whenever the tableAbstract overloads with __unset()
	 *
	 * @param (string) $node: node name
	 * @param (bool) $isAttribute: whether or not the name is an attribute of the content
	 * @param (string) $id: passed ID if rendering multiple nodes at the same time
	 * @return void
	 * @author Matthieu Lalonde
	 */
	public	function onUnset($node, $isAttribute, $myRow);
	
	/**
	 * Allows for populating data from an array
	 *
	 * @param string $entries 
	 * @param string $myFields 
	 * @return void
	 * @author Matthieu Lalonde
	 */
	public	function setEntries($entries, $myFields, $numRows);
}

class defaultRenderer implements tableRenderer
{
	public	function _init($myThis) {}
	public	function isInited($mode = -1) {return true;}
	public	function Output($asText = false) {}
	public	function onSet($node, $value, $myFields, $myRow) {}
	public	function onUnset($node, $isAttribute, $myRow) {}
	public	function setEntries($entries, $myFields, $numRows) {}
}

/**
* Table to JSON renderer
*/
class jsonRenderer implements tableRenderer
{
	private $myThis = null;
	
	function _init($myThis)
	{
		if (!function_exists('json_encode')) return false;
		
		$this->myThis =& $myThis;
	}
	
	
	public	function isInited($mode = -1) {return true;}
	public	function onSet($node, $value, $myFields, $myRow) {}
	public	function onUnset($node, $isAttribute, $myRow) {}
	public	function setEntries($entries, $myFields, $numRows) {}
	
	public	function Output($asText = false)
	{
		if (!function_exists('json_encode')) return false;
		
		if (!isset($this->myThis) && !is_object($this->myThis)) return false;
		
		return json_encode($this->myThis->getEntries());
	}
}


class xmlRenderer implements tableRenderer
{	
	public			$isInited	= false;
	private			$myDoc		= null;
	private			$myRow		= null;
	private			$myRowNum	= 0;
	private			$myRoot		= 'docRoot';
	private			$myRowName	= 'entryRow';
	
	/**
	 * Initializes a SimpleXMLElement object
	 *
	 * @return void
	 * @author Matthieu Lalonde
	 **/
	public	function __construct() {}
	
	public	function isInited($mode = -1)
	{
		if ($mode == false) {
			$this->isInited = false;
		}
		
		return $this->isInited;
	}
	
	/**
	 * undocumented function
	 *
	 * @return void
	 * @author Matthieu Lalonde
	 **/
	public	function _init($myThis)
	{
		$this->myRow	= null;
		$this->myRowNum	= null;
		
		if (!isset($myThis->rootXPath))
		{
			$this->myRowName	= $myThis->tableName;
			$this->myRoot		= 'appData';
		} else
		{
			$xpathParts	= explode('/', removeLeadingSlash($myThis->rootXPath));
			$this->myRoot		= $xpathParts[0];
			$this->myRowName	= $xpathParts[1];
		}
		
		$myRoot		= $this->myRoot;
		$myXML		= <<<XML
<?xml version="1.0" encoding="UTF-8"?>
<${myRoot}/>
XML;
		$this->myDoc		= new SimpleXMLElement($myXML);
		
		$this->isInited	= true;
		
		return true;
	}
	
	/**
	 * onSet whenever the table class sets an overloads
	 *
	 * @return void
	 * @author Matthieu Lalonde
	 * @param  Takes the name of the node as a string and a mixed value
	 **/
	public	function onSet($node, $value, $myFields, $myRow)
	{	
		if (!$this->isInited()) {
			return null;
		}
		if (!isset($this->myDoc->{$this->myRowName}[$myRow])) {
			if (version_compare(phpversion(), '5.1.3') == -1) {
				throw new appException('The XML Renderer requires PHP 5.1.3 or above to function properly', MSG_FATAL);
			} else {
				$myXMlEntry	= $this->myDoc->addChild($this->myRowName);
			}
		} else {
			$myXMlEntry		= $this->myDoc->{$this->myRowName}[$myRow];
		}
		
		if ($value == 'NOW()') $value = dbAbstract::getNOW();
		
		$fieldName = self::cleanXMLTag($node);
		if (!tableAbstract::isAttribute($node, $myFields)) {
			$myXMlEntry->$fieldName	= $value;
		} else {
			$myXMlEntry[$fieldName]	= $value;
		}
		
		$this->myRowNum = $myRow;
		
		return true;
	}
	
	/**
	 * onUnset whenever the table class unsets an overloads
	 *
	 * @return void
	 * @author Matthieu Lalonde
	 * @param  Takes the name of the node as a string
	 **/
	public	function onUnset($node, $isAttribute, $myRow)
	{
		if (!$this->isInited) return null;
		
		if (!isset($this->myDoc->{$myRowName[$myRow]})) false;
		
		if (!$isAttribute)
		{
			unset($this->myDoc->{$myRowName[$myRow]});
		} elseif ($isAttribute && isset($this->myDoc->{$myRowName[$myRow]}[$node]))
		{
			unset($this->myDoc->{$myRowName[$myRow]}[$node]);
		}
		
		return false;
	}
	
	/**
	 * Takes an array of entries and populates the XML with it
	 *
	 * @param array $entries 
	 * @param array $myFields: list of data fields
	 * @return void
	 * @author Matthieu Lalonde
	 */
	public	function setEntries($entries, $myFields, $numRows)
	{
		for ($i = 0;$i < $numRows;$i++)
		{
			if (!isset($entries[$i])) {
				foreach ($myFields as $myField => $fieldInfo)
				{
					if (!array_key_exists($myField, $entries))
					{
						$this->onSet($myField, '', $myFields, 0);
					}
				}
			
				foreach ($entries as $entryNode => $entryValue)
				{
					$this->onSet($entryNode, $entryValue, $myFields, 0);
				}
			} else {
				foreach ($myFields as $myField => $fieldInfo)
				{
					if (!array_key_exists($myField, $entries[$i]))
					{
						$this->onSet($myField, '', $myFields, $i);
					}
				}
				
				foreach ($entries[$i] as $entryNode => $entryValue)
				{
					$this->onSet($entryNode, $entryValue, $myFields, $i);
				}
			}
		}
	}
	
	final	public	function Output($asText = false)
	{
		if (!$this->isInited()) return false;
		return self::outputXML($this->myDoc, $asText);
	}

	final	private	static	function outputXML($myXMLDoc, $asText = null)
	{
		if ($asText) {
			$xmlDoc = new DOMDocument;
			$xmlDoc->formatOutput		= true;
			$xmlDoc->preserveWhiteSpace	= false;
			$xmlDoc->loadXML($myXMLDoc->asXML());
			return $xmlDoc->saveXML();
		}

		return $myXMLDoc;
	}
	
	final	private	static	function cleanXMLTag(&$tag)
	{
		$tag = trim($tag);
		if (preg_match('/^[0-9](.*)/', $tag)) {
			$tag = '_' . $tag;
		}
		
		return $tag;
	}
	
	final	private	static	function getBaseDoc()
	{
		return <<<XML
<?xml version="1.0" encoding="UTF-8"?>
<request/>
XML;
	}
}

/**
* Models
**/
class activeRecordTest extends tableAbstract
{
	public $rootXPath = '/appData/pageData';
	
	function __construct(tableRenderer &$renderer = null)
	{
		$this->_init(__CLASS__, $renderer);
	}
	
	protected	function onCreate()
	{
		$tableName	= $this->myName;
		$tableSQL	= <<<SQL
CREATE TABLE `${tableName}` (
  `id` mediumint(8) unsigned NOT NULL auto_increment,
  `login` varchar(128) character set latin1 NOT NULL,
  `password` varchar(45) character set latin1 NOT NULL,
  `email` varchar(255) character set latin1 NOT NULL,
  `created` datetime NOT NULL,
  PRIMARY KEY  (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=0 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci
SQL;
		
		return $tableSQL;
	}
		
	public	function loginExists($login)
	{
		if ($this->fetchRow(HP('limit', 1)) > 0) return true;
		else return false;
	}
	
	protected function validate_login($data)
	{
		return false; /*
		if (rand(0, 1) == 0) return true;
		else return false;*/
	}
	
	protected function validate_password($data)
	{
			return false; /*
		if (rand(0, 1) == 0) return true;
		else return false;*/
	}
	
	protected function validate_email($data)
	{
		return false; /*
		if (rand(0, 1) == 0) return true;
		else return false;*/
	}
} // END table model Pages

/**
 * tableAbstract is a simple active record abstraction layer
 *
 * @package SmurfCMS
 * @author Matthieu Lalonde
 */
class tableAbstract
{
	/* Public */
	
	/* Protected */
	
	/**
	 * List of the table's fields name
	 *
	 * @var array
	 * @access protected
	 */
	protected	$myFields			= array();
	/**
	 * Table's fields definition 
	 *
	 * @var array
	 * @access protected
	 */
	protected	$myFieldsDef		= array();
	/**
	 * List of private fields 
	 *
	 * @var array
	 * @access protected
	 */
	protected	$privateFields		= array('id', 'dateCreated', 'dateUpdated');
	/**
	 * Table name from the model 
	 *
	 * @var string
	 * @access protected
	 */
	protected	$tableName			= '';	
	/**
	 * Table's name in the database 
	 *
	 * @var string
	 * @access protected
	 */
	protected	$myName				= '';
	/**
	 * ID of the row in myEntries 
	 *
	 * @var int
	 * @access protected
	 */
	protected	$myRowID			= null;
	/**
	 * Table & Overload entries 
	 *
	 * @var array
	 * @access protected
	 */
	protected	$myEntries			= null;
	/**
	 * Number of rows from the last query 
	 *
	 * @var int
	 * @access protected
	 */
	protected	$numRows			= 0;
	
	
	/* Private */
	/**
	 * Last table query conditions (WHERE...) 
	 *
	 * @var string
	 * @access private
	 */
	private		$lastDBConditions	= null;
	/**
	 * Last query parameters 
	 *
	 * @var array
	 * @access private
	 */
	private		$queryParams		= null;
	/**
	 * Table renderer object
	 *
	 * @var object
	 * @access private
	 */
	private		$myRenderer		= null;
	/**
	 * List of all the table's queries
	 * and whether or not they failed.
	 *
	 * @var array
	 * @access private
	 */
	private		$queriesLog			= array();
	/**
	 * Name of the default renderer 
	 *
	 * @var string
	 * @access private
	 */
	private		$defaultRenderer	= 'defaultRenderer';
	/**
	 * List of default query conditions
	 *
	 * @var array
	 * @access private
	 */
	private static	$queryConditions= array(
												'conditions'	=> '1',					// WHERE $conditions
												'limit'			=> null,
												'orderBy'		=> 'id',
												'order'			=>	'ASC',				// Either nothing or DESC
												'types'			=> false,				// Usually internal!
												'mode'			=> MDB2_FETCHMODE_ASSOC,// Shouldn't change for overload!!!
											);
	
	/**
	 | Basic object methods |
	 **/
	
	/**
	 * __construct() initilizes the table. 
	 * A note of warning: this can be overloaded by a table child!
	 *
	 * @param (string) $tableName: name of this table
	 * @param (string) $tableRenderer: default table renderer object (optional)
	 * @return (bool)  true on success
	 * @author Matthieu Lalonde
	 */
	public	function __construct($tableName, tableRenderer &$renderer = null)
	{
		if(get_class($this) == __CLASS__)
		{
			throw new fatalException('You cannot instanciate this class, please use a model!');
			return null;
		} else {
			return $this->_init($tableName, $renderer);
		}
	}
	
	/**
	 * __destruct() disconnects the database and resets the query
	 *
	 * @return void
	 * @author Matthieu Lalonde
	 */
	final	public	function __destruct()
	{
		$dbAbstract = Singleton::getInstance('dbAbstract');
		$dbAbstract->disconnectDB();
		$this->resetQuery();
	}
	
	/**
	 * _init() initialize the table by fetching the fields
	 * and manipulatin the table (creation as necessary)
	 *
	 * @param (string) $tableName: name of this table
	 * @param (string) $tableRenderer: default table renderer object (optional)
	 * @return (bool)  true on success
	 * @author Matthieu Lalonde
	 */
	final	public	function _init($tableName, tableRenderer &$renderer = null)
	{
		$dbAbstract			= Singleton::getInstance('dbAbstract');
		$this->tableName	= strtolower($tableName);
		$this->myName		= addTrailingChar(dbAbstract::$tablePrefix . strtolower($tableName), 's');
		
		$this->setRenderer($renderer);
		
		$tempFields			= $dbAbstract->fetchTableFields($this->myName);
		if ($tempFields === false)
		{
			// The table does not exist, let's try and create it first.
			if ($this->createTable(/*true to drop first!*/)) {
				$tempFields		= $dbAbstract->fetchTableFields($this->myName);
			}
			
			if ($tempFields === false)
			{
				die('cannot init!');
				//$msgController	= msgController();
				//$msgController->appendMsg(new fatalError('Cannot initialize table `'.$this->myName.'`!', ERROR_CODE_DB));
				return false;
			}
		}
		
		foreach ($tempFields as $field)
		{
			$myTmpField						= $field['Field'];
			$this->myFields[]				= $myTmpField;
			$this->myFieldsDef[$myTmpField] = $field;
		}
		
		return true;
	} // END _init()
	
	/**
	| Class Accessor Methods |
	 **/
	
	/**
	 * getLastQuery returns the last database query to be executed (failure or not)
	 *
	 * @return string
	 * @author Matthieu Lalonde
	 */
	final	public	function getLastQuery()
	{
		$dbAbstract = Singleton::getInstance('dbAbstract');
		
		return $dbAbstract->mdb2->last_query;
	}
	
	/**
	 * getEntries returns the current overload entries
	 *
	 * @return array
	 * @author Matthieu Lalonde
	 */
	final	public	function getEntries()
	{
		return $this->myEntries;
	}
	
	/**
	 * getMyfields returns the name of the table's fields
	 *
	 * @return array
	 * @author Matthieu Lalonde
	 */
	final	public	function getMyfields()
	{
		return $this->myFields;
	}
	
	/**
	 * getMyTableName returns the table's short name
	 *
	 * @return sting
	 * @author Matthieu Lalonde
	 */
	final	public	function getMyTableName()
	{
		return $this->tableName;
	}
	
	/**
	 * getMyName returns the table's full name
	 *
	 * @return string
	 * @author Matthieu Lalonde
	 */
	final	public	function getMyName()
	{
		return $this->myName;
	}
	
	/**
	 * getNumRow returns the current number of rows
	 *
	 * @return int
	 * @author Matthieu Lalonde
	 */
	final	public	function getNumRow()
	{
		return $this->numRows;
	}
	
	/**
	 * getQueryLog return an array containing a log of the queries
	 *
	 * @return (array) array(query, (bool)result)
	 * @author Matthieu Lalonde
	 */
	final	public	function getQueryLog()
	{
		return $this->queriesLog;
	}
	
	/**
	 * getRowID returns the current row number of myEntries
	 *
	 * @return void
	 * @author Matthieu Lalonde
	 */
	final	public	function getRowID()
	{
		return $this->myRowID;
	}
	
	/**
	 * setRowID affects a row number to myEntries
	 *
	 * @param (int) $id: row number
	 * @return (bool) true on success
	 * @author Matthieu Lalonde
	 */
	
	final	public	function setRowID($id)
	{
		if (!isset($id) || !is_numeric($id))
		{
			$this->myRowID = false;
			return false;
		}
			
		if ($id > $this->numRows) {return false;}
		
		$this->myRowID	= $id;
		
		return true;
	}
	
	/**
	 * Resets the current table state
	 * Deletes all information about the current query!
	 * Allows for the same object to be used multiple times
	 * 
	 * @return void
	 * @author Matthieu Lalonde
	 */
	final	public	function resetQuery()
	{
		if ($this->myRenderer)
		{
			$this->myRenderer->_init($this);
		}
		
		$this->myRowID			= null;
		$this->myEntries		= null;
		$this->queryParams		= null;
		$this->numRows			= 0;
		$this->lastDBConditions = '';
		
		//$this->queriesLog[]		= 'Reseted query!';
	}
	
	/**
	 * getMyRenderer returns the current renderer of the default render is there is one
	 *
	 * @return void
	 * @author Matthieu Lalonde
	 */
	final	public function getMyRenderer()
	{
		if (!interface_exists('tableRenderer', true)) return false;
		
		if (!$this->myRenderer) {
			if (empty($this->defaultRenderer) || 
				!class_exists($this->defaultRenderer))
			{
				return false;
			}
			
			$this->myRenderer	= new $this->defaultRenderer;
		}
		
		return $this->myRenderer;
	}
	
	/**
	 * setRenderer allows the table class to receive a new renderer
	 *
	 * @param tableRenderer $renderer 
	 * @return void
	 * @author Matthieu Lalonde
	 */
	final	public	function setRenderer(tableRenderer &$renderer)
	{
		$this->myRenderer = $renderer;
		$this->myRenderer->_init($this);
	}
	
	/**
	| Class Rendering Methods |
	**/
	
	/**
	 * render renders all of the overloads with the external renderer
	 *
	 * @param (bool) $asText: force the renderer to output text if it can.
	 * @return (mix) Renderer output
	 * @author Matthieu Lalonde
	 */
	final	public	function render($asText = false)
	{
		try {
			return $this->getMyRenderer()->Output($asText);
		} catch (Exception $e) {
			throw new fatalException('Unable to load default render!');
		}
		
		return null;
	}
	
	/**
	| Class Overload Methods |
	 **/
	
	/**
	 * __set() overload. Stores the passed information in the myEntries named array
	 *
	 * @param (string) $name: field name
	 * @param (string) $value: field to insert
	 * @return void
	 * @author Matthieu Lalonde
	 */
	final	public	function __set($name, $value)
	{
		return $this->_handleMyEntries($name, $value, 'set');
	}
	
	// TODO This needs to handle "RoR like" A.R. methods
	final	public	function __call($name, $arguments) {}
	
	/**
	 * __get() overload queries the myEntries array for a field of $name
	 *
	 * @param (string) $name: name of the node. but be a valid fields or __get returns false
	 * @return false if anything fails or the entry data
	 * @author Matthieu Lalonde
	 */
	final	public	function __get($name)
	{
		return $this->_handleMyEntries($name, null, 'get');
	}
	
	/**
	 * __toString is delegated to the rendering functions
	 *
	 * @author Matthieu Lalonde
	 */
	final	public	function __toString()
	{
		return $this->render(true);
	}
	
	/**
	 * __isset() overload queries the myEntries array in 
	 * search of a field and returns whether or not it exists
	 *
	 * @param  (string) $name: must be a valid field name
	 * @return true is $name isset in myEntries, false in any other case
	 * @author Matthieu Lalonde
	 */
	final	public	function __isset($name)
	{
		return $this->_handleMyEntries($name, null, 'isset');
	}
	
	/**
	 * __unset() overload unsets the specified entry from myEntries
	 *
	 * @param (string) $name: name of the field
	 * @return void
	 * @author Matthieu Lalonde
	 */
	final	public	function __unset($name)
	{
		return $this->_handleMyEntries($name, null, 'unset');
	}
	
	/**
	 * handles all of the queries to myEntries from the overloads.
	 *
	 * @param (string) $name: name of the field
	 * @param (string) $value: node value (optional)
	 * @param (string) $mode: overload mode
	 * @return Multiple possibilities, false as default and failure
	 * @author Matthieu Lalonde
	 */
	final	private function _handleMyEntries($name, $value = '', $mode = 'set')
	{
		if (($mode == 'set' ||is_array($this->myEntries)) && in_array($name, $this->myFields))
		{
			$myRowID	= $this->myRowID;
			if (!isset($myRowID)) {$myRowID = 0;}
			
			if ($mode == 'set' || isset($this->myEntries[$myRowID]))
			{
				if ($mode == 'set' || array_key_exists($name, $this->myEntries[$myRowID]))
				{
					switch ($mode)
					{
						case 'set':
							if (!in_array($name, $this->privateFields))
							{
								// Call the renderer's onSet event
								if (isset($this->myRenderer))
								{
									$this->myRenderer->onSet($name, $value, $this->myFieldsDef, $myRowID);
								}
								
								$this->myRowID						= $myRowID;
								$this->myEntries[$myRowID][$name]	= $value;
								return true;
							}
							else
							{
								throw new Exception('Cannot access private field!');
								return false;
							}
						break;
						case 'get':
							if (isset($this->myEntries[$myRowID][$name]))
							{
								return $this->myEntries[$myRowID][$name];
							}
						break;
						case 'isset':
							return isset($this->myEntries[$myRowID][$name]);
						break;
						case 'unset':
							if (isset($this->myRenderer))
							{
								// Call the renderer's onUnset event
								$this->myRenderer->onUnset($name, self::isAttribute($name, $this->myFieldsDef), $myRowID);
							}
							
							unset($this->myEntries[$myRowID][$name]);
						break;
					}
				}
			}
		}
		
		return false;
	} // END _handleMyEntries()
	
	/**
	| Class Table Manipulation Methods |
	**/
	
	/**
	 * createTable attempts to create the table in the database if the table's child
	 * provides an sql query for it
	 *
	 * @param (bool) $dropTable: whether or not to drop the table first, mainly unsed internally atm
	 * @return (bool)
	 * @author Matthieu Lalonde
	 */
	/**
	 * onCreate() is to be overloaded by the table's child. 
	 * If it returns it's creation sql query, the table will be created as necessary.
	 */
	protected		function onCreate() {return null;}
	final	private function createTable($dropTable = false)
	{	
		$createTableQuery	= $this->onCreate();
		if ($dropTable == true)
		{
			$createTableQuery = 'DROP TABLE `' . $this->tableName . '`; ' . "\n\n" . $createTableQuery;
		}
		
		if (!empty($createTableQuery)) {
			$dbAbstract = Singleton::getInstance('dbAbstract');
			$dbAbstract->mdb2->exec($createTableQuery);
			
			$this->queriesLog[] = array($dbAbstract->mdb2->last_query, PEAR::isError($dbAbstract->mdb2));
			
			if (PEAR::isError($dbAbstract->mdb2))
			{
				throw new fatalException('Cannot create table `' . $his->tableName . '`');
				return false;
			}
			
			return true;
		}
		
		return false;
	} // END createTableQuery()
	
	/**
	 * deleteData deletes the content of myEntries in the database 
	 * according to the selected row or for all entries with the last query.
	 * A word of warning, this will reset the query with resetQuery() and 
	 * reinit the renderer if one is available!
	 *
	 * @return affected rows if all goes well, false if anything else
	 * @author Matthieu Lalonde
	 */
	// onDelete() is to be overloaded by the table's child for data validation if necessary.
	protected		function onDelete() {}
	final	public	function deleteData()
	{
		$doNotDelete = $this->onDelete();
		
		if (!$doNotDelete && is_array($this->myEntries))
		{
			$dbAbstract = Singleton::getInstance('dbAbstract');
			
			if (isset($this->myRowID) && $this->numRows > 0)
			{
				$myQ = 'DELETE FROM `' . $this->myName . '` WHERE `id` = ' . $this->myEntries[$this->myRowID]['id'] . ';';
			} 
			elseif (!empty($this->lastDBConditions) && $this->numRows > 0)
			{
				$myQ = 'DELETE FROM `' . $this->myName . '` WHERE ' . $this->lastDBConditions . ';';
			} 
			else
			{
				return false;
			}
			
			$dbAbstract->mdb2->setLimit(count($this->myEntries));
			$affected =& $dbAbstract->mdb2->exec($myQ);
			
			$this->queriesLog[] = array($dbAbstract->mdb2->last_query, PEAR::isError($affected));

			// Always check that result is not an error
			if (PEAR::isError($affected)) {
				throw new appException('Error deleting');
				return false;
			}
			
			$this->resetQuery();
			if ($this->myRenderer)
			{
				$this->myRenderer->isInited(false);
			}
			
			return $affected;
		} else 
		{
			return $doNotDelete;
		}
		
		return null;
	} // END deleteData()
	
	/**
	 * saveData saves (update or insert) the content of myEntries to the database 
	 * according to the selected row or for all entries with the last query.
	 *
	 * @return void
	 * @author Matthieu Lalonde
	 */
	// onSave() is to be overloaded by the table's child for data validation if necessary.
	protected		function onSave() {return null;}
	final	public	function saveData()
	{	
		$isNew		= false;
		$doNotSave	= $this->onSave();
		
		if (is_array($this->myEntries) && !$doNotSave)
		{
			for($i=(count($this->myEntries) - 1);$i>=0;$i--)
			{	
				if ($doNotSave) break;
				
				foreach($this->myFieldsDef as $myKey => $myFieldDef)
				{
					if ($doNotSave) break;
					
					if (!is_numeric($myKey) && !in_array($myKey, $this->privateFields) && 
						method_exists($this, ($meth = 'validate_' . $myKey)))
					{
						if (!isset($this->myEntries[$i][$myKey])) {
							$myValBefore	= null;
							$myVal			= null;
						} else {
							$myVal			= $this->myEntries[$i][$myKey];
							$myValBefore	= $this->myEntries[$i][$myKey];
						}
						
						$doNotSave = $this->$meth($myVal);
						
						if ($myVal != $myValBefore)
						{
							$this->myEntries[$i][$myKey] = $myVal;
						}
					}
				}
			}
			
			if (!$doNotSave)
			{
				$dbAbstract = Singleton::getInstance('dbAbstract');
				
				if (is_numeric($this->myRowID) && $this->numRows > 0 && isset($this->myEntries[$this->myRowID]['id']))
				{	
					$myDate		= $this->setDefaultFields('update');
					$myEntry	= array_merge($myDate, $this->myEntries[$this->myRowID]);
					
					$myQ[] = 'UPDATE `' . $this->myName . '` SET ' . 
							self::mysqlUpdateValues($myEntry, $this->myFieldsDef) . 
							' WHERE `id` = ' . $this->myEntries[$this->myRowID]['id'] .';';
			
				} elseif (!empty($this->lastDBConditions) && $this->numRows > 0 && isset($this->myEntries[0]['id']))
				{
					$myQ = array();
					foreach ($this->myEntries as $myEntry)
					{
						$myDate		= $this->setDefaultFields('update');
						$myEntry	= array_merge($myDate, $myEntry);
						
						//if (!isset($myEntry['id'])) continue;
						$myQ[] = 'UPDATE `' . $this->myName . '` SET ' . 
								self::mysqlUpdateValues($myEntry, $this->myFieldsDef) . 
								' WHERE `id` = ' . $myEntry['id'] . ';';
					}
				} else {
					$isNew	= true;
					$myQ	= array();
					foreach ($this->myEntries as $myEntry)
					{
						if (!array_key_exists('id', $myEntry))
						{
							$myEntry	= array_merge(array('id' => ''), $myEntry);
						}
						
						$myDate		= $this->setDefaultFields('create');
						$myEntry	= array_merge($myDate, $myEntry);
						$myQData	= self::getInsertFields($myEntry, $this->myFieldsDef);
						if (empty($myQData['queryKeys']) || empty($myQData['queryValues']))
						{
							continue;
						}
						
						$myQ[]		.='INSERT INTO `' . $this->myName . '` (' . $myQData['queryKeys'] . ') ' . 
							'VALUES (' . $myQData['queryValues'] . ');';
					}
				}
			
				if (!isset($myQ[0]))
				{
					return false;
				}
			
				foreach ($myQ as $myQuery)
				{
					if (!$isNew) $dbAbstract->mdb2->setLimit(1);
					$affected	=& $dbAbstract->mdb2->exec($myQuery);
					$lastQuery	= $dbAbstract->mdb2->last_query;
				
					$this->queriesLog[] = array($lastQuery, PEAR::isError($affected));
				
					if (PEAR::isError($affected)) break;
				}
			
			
				// Always check that result is not an error
				if (PEAR::isError($affected)) {
					throw new appException('Cannot save to table ' . $affected->getMessage() . $lastQuery);
					return false;
				}
			
				if ($isNew) $this->myEntries[0]['id'] = $dbAbstract->mdb2->lastInsertID();
				$this->numRows	= count($this->myEntries);
				return $affected;
			}
		}
		
		return false;
	} // END saveData();
	
	final	private	function setDefaultFields($mode)
	{
		$myKey	= '';
		switch ($mode)
		{
			case 'create':
				$myKey = 'dateCreated';
			break;
			case 'update':
				$myKey = 'dateUpdated';
			break;
			default:
				return array();
			break;
		}
		
		if (!array_key_exists($myKey, $this->myFieldsDef))
		{
			return array();
		}
		
		return array($myKey => dbAbstract::getNOW());
	}
	
	/**
	 * _query generates and fetches a selection query on the table
	 *
	 * @param array $fieldName: specify a list of fields to fetch (option, default to all)
	 * @param array $myConditions: an array containing the search conditions of the query
	 * @return mixed: number of fetched rows on success, false on failure
	 * @author Matthieu Lalonde
	 */
	final	private function _query($fieldName = '*', $myConditions = null)
	{
		$dbAbstract		= Singleton::getInstance('dbAbstract');
		$myConditions	= self::validateQueryConditions($myConditions);
		
		if (!$dbAbstract->isReady())
		{
			return null;
		}
		
		// Check for ordering
		$queryOrder = !empty($myConditions['orderBy']) ? ' ORDER BY `' . $myConditions['orderBy'] . '` ' . $myConditions['order'] : '';
		
		// Build the mySQL query
		$mySQL = 'SELECT '. self::fieldsToCSV($fieldName) .' FROM `' . $this->myName .'` WHERE '. $myConditions['conditions'] . $queryOrder .';';
		
		// Set limit
		if (isset($myConditions['limit']) && is_numeric($myConditions['limit']) && $myConditions['limit'] >= 0) {
			$dbAbstract->mdb2->setLimit($myConditions['limit']);
		}
		
		$res =& $dbAbstract->mdb2->query($mySQL);
		
		$this->lastDBConditions = $myConditions['conditions'];
		$this->queriesLog[]		= array($dbAbstract->mdb2->last_query, PEAR::isError($res));
		
		try {
			if (PEAR::isError($res)) {
				throw new Exception($res->getMessage() .'Unable to query from database table "'.$this->myName.'"', MSG_ERROR);
			}
			
			if (isset($myConditions['types']) && is_array($myConditions['types'])) {
				$res->setResultTypes($myConditions['limit']);
			}
			
			if (isset($myConditions['limit']) && $myConditions['limit'] == 1) {
				$return = $res->fetchRow($myConditions['mode']);
			} else {
				$return = $res->fetchAll($myConditions['mode']);
			}
			
			// Free the result!
			$this->numRows		= count($return);
			$res->free();
			
			if ($this->numRows > 0)
			{
				if (is_object($this->myRenderer))
				{	
					$this->myRenderer->setEntries($return, $this->myFieldsDef, $this->numRows);
				}
				
				if ($this->numRows == 1)
				{
					$this->myRowID	= 0;
				} else {
					$this->myRowID	= null;
				}
				
				$this->myEntries	= $return;
				
				return $this->numRows;
			} else {
				throw new alertException('No result for: ' . $this->getLastQuery() . "\n", MSG_ALERT);//'call_back_error_string');
				return false;
			}
		} catch (Exception $e) { // This really shouldn't happen
			throw new appException($e->getMessage(), $e->getCode());
			
			return false;
		}
	} // End _query()
	
	/**
	 * validateQueryConditions makes sure all the required 
	 * query conditions are listed in the query parameters
	 *
	 * @param array $myConditions: valid set of condition
	 * @param string $array 
	 * @return array
	 * @author Matthieu Lalonde
	 */
	final	private static	function validateQueryConditions(array $myConditions = null)
	{
		$queryConditions	= self::$queryConditions;
		
		if (is_array($myConditions)) {	
			foreach ($queryConditions as $myKey => $myVal)
			{
				if (array_key_exists($myKey, $myConditions) && !empty($myConditions[$myKey])) {
					$queryConditions[$myKey]	= $myConditions[$myKey];
				}
			}
		}
		
		// Override, otherwise... bad for overload!!!
		$queryConditions['mode']		= MDB2_FETCHMODE_ASSOC;
		
		return $queryConditions;
	} // END validateQueryConditions()
	
	/**
	 * fetch, fetchRow(s) allow querying the table
	 * and handle prepartion of the query parameters
	 *
	 * @param array $searchParams: contains a field/match named array, if 'QRelation' is set, the query will use OR instead of AND, if 'QReversed' is set, the search wil be reverse
	 * @param array $queryParams: optional named array containing query parameters (see the validation function)
	 * @return result of _query()
	 * @author Matthieu Lalonde
	 */
	final	public	function fetchRow($searchParams, $queryParams = null) {return $this->fetch($searchParams, $queryParams);}
	final	public	function fetchRows($searchParams, $queryParams = null) {return $this->fetch($searchParams, $queryParams);}
	final	public	function fetch($searchParams, $queryParams = null)
	{
		// First reset the query!
		$this->resetQuery();
		
		if (!is_array($searchParams) && !is_array($queryParams))
		{
			$res = $this->fetchAll();
		} else {	
			$singleArray		= false;
			if (!is_array($queryParams)) {
				$singleArray	= true;
				$queryParams	= $searchParams;
			}
			
			$queryFields = '*';
			if (isset($searchParams['fieldName'])) {
				if (in_array($searchParams['fieldName'], $this->myFields)) {
					$queryFields = $searchParams['fieldName'];
				}	
				unset($searchParams['fieldName']);
				unset($queryParams['fieldName']);
			}
			
			$or = false;
			if (isset($searchParams['QRelation'])) {
				$or = true;
				unset($searchParams['QRelation']);
				unset($queryParams['QRelation']);
			}
			
			$not	= false;
			if (isset($searchParams['QReversed'])) {
				$not	= true;
				unset($searchParams['QReversed']);
				unset($queryParams['QReversed']);
			}
			
			if (!isset($queryParams['conditions']) && isset($searchParams)) {
				if ($singleArray)
				{
					foreach (self::$queryConditions as $key => $value)
					{
						if (isset($searchParams[$key])) unset($searchParams[$key]);
					}
				}
				
				$queryParams['conditions']	= $this->mysqlArrayToWHERE($searchParams, $or, $not);
			}
			
			
			$res						= $this->_query($queryFields, $queryParams);
			if (!$res) {
				$this->queryParams		= null;
			} else {
				$this->queryParams		= $queryParams;
			}
		}
		
		return $res;
	} // END fetch()
	
	/**
	 * fetchAll fetches all entries for the table
	 *
	 * @return _query() result
	 * @author Matthieu Lalonde
	 */
	final	public	function fetchAll()
	{
		// First reset the query!
		$this->resetQuery();
		
		return $this->_query();
	}
	
	/**
	| Class Utilities Methods |
	**/
	
	/**
	 * mysqlArrayToWHERE creates an escaped string for mysql search queries
	 *
	 * @param array $mArray 
	 * @param bool $or: if true use OR instead of AND
	 * @param bool $not: if true reverse the search
	 * @return string
	 * @author Matthieu Lalonde
	 */
	final	private function mysqlArrayToWHERE($mArray, $or = false, $not = false)
	{
		$sFields	= '';
		$i			= 0;
		
		if (!$or) $relation = 'AND';
		else $relation		= 'OR';
		
		foreach($mArray as $key => $val)
		{
			if (is_numeric($key) || !in_array($key, $this->myFields)) unset($mArray[$key]);
		}
		
		if (empty($mArray)) return false;
		
		while (list($paramKey, $value) = each($mArray)) {
			if (dbAbstract::isLike($this->myFieldsDef[$paramKey]['Type'])) {
				$entryRelation	= ($not == true ? 'NOT ' : '') . 'LIKE';
			} else {
				$entryRelation	= ($not == true ? '!' : '') . '=';
			}
			
			$sFields.= '`' . $paramKey . '` '.$entryRelation.' \'' . $value . '\'';
			if(++$i < count($mArray))
			{
				$sFields.= ' ' . $relation . ' ';
			}
		}
		
		return $sFields;
	}
	
	/**
	 * mysqlUpdateValues creates an escaped string for mysql update queries
	 *
	 * @param array $mArray: named array containing the update data
	 * @param array $types: used for quoting
	 * @return string
	 * @author Matthieu Lalonde
	 */
	final	private static	function mysqlUpdateValues($mArray, $types)
	{
		$sValues	= "";
		$i			= 0;
		
		unset($mArray['id']);
		$count		= count($mArray);
		while (list($key, $value) = each($mArray)) {
			$sValues .= "$key = '" . dbAbstract::escapeString($value) . "'";
			if(++$i < $count)
			{
				$sValues .= ", ";
			}
		}
		
		return $sValues;
	}
	
	/**
	 * fieldsToCSV returns a CSV formated string
	 *
	 * @param (array) $mArray: contains a series of field names
	 * @return string
	 * @author JÃ©rÃ©mie Lauzon, Matthieu Lalonde
	 */
	final	private static	function fieldsToCSV($mArray)
	{
		$sFields	= "";
		$i			= 0;
		
		if (!is_array($mArray))
		{
			return $mArray;
		}

		while (list($key, $value) = each($mArray)) {
			$value	  = preg_replace('/![A-Za-z0-9_-]/', '', $value);
			
			$sFields .= '`' . $value . '`';
			if(++$i < count($mArray))
			{
				$sFields .= ", ";
			}
		}

		return $sFields;
	}
	
	/**
	 * valuesToCSV returns a CSV formated string of escaped values
	 *
	 * @param (array) $mArray: contains a series of field names
	 * @param (array) $types: contains the type for each field for quoting purposes
	 * @return string
	 * @author JÃ©rÃ©mie Lauzon, Matthieu Lalonde
	 */
	final	private static	function valuesToCSV($mArray, $types)
	{
		$sValues	= "";
		$i			= 0;
		if (!array_key_exists('id', $mArray)) {
			$mArray		= array_merge(array('id' => ''), $mArray);
		}
		
		foreach ($mArray as $key => $value)
		{
			$quotes		= ($value == 'NOW()' ? '' : '\'');
			$sValues   .= $quotes . dbAbstract::escapeString($value) . $quotes;
			if(++$i < count($mArray))
			{
				$sValues .= ", ";
			}
		}
		
		return $sValues;
	}
	
	/**
	 * getInsertFields returns an array of prepared data
	 * to use for a insertion query
	 *
	 * @param array $recordValues 
	 * @param array or string $types 
	 * @return array array('queryKeys' => fieldsToCSV($recordKeys), 'queryValues' => valuesToCSV($recordValues, $types));
	 * @author Matthieu Lalonde
	 */
	final	private static	function getInsertFields(array $recordValues, $types)
	{
		$recordKeys = array();
		foreach ($recordValues as $recordKey => $recordValue) {
			$recordKeys[]	= $recordKey;
		}
		
		return array('queryKeys' => self::fieldsToCSV($recordKeys), 'queryValues' => self::valuesToCSV($recordValues, $types));
	}
	
	/**
	 * isAttribute returns whether or not a field is an attribute
	 *
	 * @param string $fieldName 
	 * @return bool
	 * @author Matthieu Lalonde
	 */
	final	public	function isAttribute($fieldName, $fieldsDef)
	{
		if (in_array($fieldName, array('id', 'uid')) ||
			!empty($fieldsDef[$fieldName]['Key']) ||
			(isset($fieldsDef[$fieldName]) &&
			preg_match('/(enum\((.*)\))/', $fieldsDef[$fieldName]['Type'])))
		{
			return true;
		}
		
		return false;
	}
	
} // END class tableAbstract

/**
* Load the database config
**/
global $dsn;
initDBConfig();

function initDBConfig()
{
	global $dsn;
	
	include HELPERS . 'dbConf.inc.php';
	if (!isset($dsn) || empty($dsn)) {
		throw new fatalException('Could not find database configuration file!');
	}
}

/**
 * dbAbstract: handles database connection
 *
 * @package SmurfCMS
 * @author Matthieu Lalonde
 **/
class dbAbstract
{	
	/**
	 * Table prefix in the database, if you need one
	 *
	 * @var string
	 * @access public
	 */
	public static	$tablePrefix		= 'xcms_';
	
	/**
	 * Database object
	 *
	 * @var MDB2 object
	 * @access public
	 */
	public			$mdb2;
	/**
	 * MDB2 options
	 *
	 * @var array
	 * @access private
	 */
	private			$dsnOptions			= array('debug'		  => 2);
	/**
	 * Database connection options
	 *
	 * @var array
	 * @access private
	 */
	private			$dsn				= array();
	/**
	 * state of the database connection
	 *
	 * @var string
	 * @access private
	 */
	private			$dbState			= false;
	
	/**
	 * Don't allow the construct to be overwritten
	 *
	 * @return void
	 * @author Matthieu Lalonde
	 * @access public
	 */
	final	public	function __construct() {}
	
	/**
	 * __destruct makes sure the database is disconnected first
	 *
	 * @return void
	 * @author Matthieu Lalonde
	 * @access private
	 */
	final	public	function __destruct()
	{
		$dbAbstract = Singleton::getInstance('dbAbstract');
		$dbAbstract->disconnectDB();
	} // End __destruct()
	
	/**
	 * allows for easy access to the mdb2 methods
	 *
	 * @param string $name: method name 
	 * @param string $params: method params
	 * @return void
	 * @author Matthieu Lalonde
	 * @access public
	 */
	final	public	function __call($name, $params)
	{
		$dbAbstract = Singleton::getInstance('dbAbstract');
		if (method_exists($dbAbstract->mdb2, $name))
		{
			return call_user_func(array($dbAbstract->mdb2, $name), $params);
		}
		
		return false;
	}
	
	/**
	 * disconnectDB closes the database connection and reset the state
	 *
	 * @return void
	 * @author Matthieu Lalonde
	 * @access public
	 */
	final	public	function disconnectDB()
	{
		$dbAbstract = Singleton::getInstance('dbAbstract');
		if (is_object($dbAbstract->mdb2) && !(PEAR::isError($dbAbstract->mdb2))) {
			$dbAbstract->mdb2->disconnect();
		}
		$dbAbstract->mdb2		= null;
		$dbAbstract->dbState	= false;
	} // END disconnectDB
	
	/**
	 * resetConnection attempts to reset the database's connection
	 *
	 * @return bool: true on success
	 * @author Matthieu Lalonde
	 * @access public
	 */
	final	public	function resetConnection()
	{
		$dbAbstract = Singleton::getInstance('dbAbstract');
		$dbAbstract->disconnectDB();
		return $dbAbstract->_init();
	} // END resetConnection
	
	/**
	 * _init starts up a connection to the database
	 *
	 * @return bool: true on success
	 * @author Matthieu Lalonde
	 * @access public
	 */
	final	public	function _init()
	{	
		global $dsn;
		$dbAbstract			= Singleton::getInstance('dbAbstract');
		$dbAbstract->dsn	= $dsn;
		
		$dbAbstract->mdb2	=& MDB2::connect($dbAbstract->dsn, $dbAbstract->dsnOptions);
		
		if (PEAR::isError($dbAbstract->mdb2)) {
			throw new appException(	'Error connecting to the database with error: '.
										$dbAbstract->mdb2->getMessage() . ' on ' . $dbAbstract->mdb2->getUserinfo()
									);
			return false;
		} else {
			$dbAbstract->mdb2->setOption('portability', MDB2_PORTABILITY_ALL ^ MDB2_PORTABILITY_FIX_CASE);
			$dbAbstract->dbState	= true;
			return true;
		}
	} // End Init
	
	/**
	** Acessors
	**/
	
	/**
	 * isReady checks if the database is read or can be initialized.
	 * in the later case, an attempt will be made to init the database
	 *
	 * @return bool: state of the database
	 * @author Matthieu Lalonde
	 * @access public
	 */
	final	public	function isReady($noInit = false)
	{
		$dbAbstract		= Singleton::getInstance('dbAbstract');
		$msgController	= msgController();
		if (!$noInit && !$dbAbstract->dbState && $msgController->msgCount(false, false, ERROR_CODE_DB) == 0) {
			return $dbAbstract->_init();
		}
		
		return $dbAbstract->dbState;
	}
	
	/**
	| Utilities |
	**/
	
	/**
	 * fetchTableFields fetch a litle of the table's fields
	 *
	 * @param string $tableName: valid table name
	 * @return array, false on failure
	 * @author Matthieu Lalonde
	 * @access public
	 */
	final	public	function fetchTableFields($tableName)
	{
		$dbAbstract = Singleton::getInstance('dbAbstract');
		
		$sql	= 'SHOW COLUMNS FROM `'. $tableName .'`;';
		$fields = Array();
		
		if (!$dbAbstract->isReady())
		{
			return false;
		}
		
		$res =& $dbAbstract->mdb2->query($sql);
		
		if (PEAR::isError($res)) {
			return false;
		}
		
		$return = $res->fetchAll(MDB2_FETCHMODE_ASSOC);
		
		// Free the result!
		$res->free();
		
		if (count($return) == 1) {
			return $return[0];
		} else if (count($return) > 1) {
			return $return;
		}
		
		return false;
	}
	
	
	/**
	 * isLike returns true is a type uses a 'LIKE' syntax rather than '='
	 *
	 * @param string $type 
	 * @return bool
	 * @author Matthieu Lalonde
	 */
	final	static	function isLike($type)
	{
		if (preg_match('/(text)|(varchar)|(blob)/', $type))
		{
			return true;
		}
		
		return false;
	}
	
	/**
	 * getNOW returns a mySQL NOW() DATETIME stamp
	 *
	 * @return void
	 * @author Matthieu Lalonde
	 */
	final	public	static	function getNOW() {
		return date("Y-m-d H:i:s");
	}
	
	/**
	 * getNever returns a mySQL formatted _never_ DATETIME stamp
	 *
	 * @return void
	 * @author Matthieu Lalonde
	 */
	final	static	function getNever() {
		return '0000-00-00 00:00:00';
	}
	
	/**
	 * escapeString escapes an array or a string of data.
	 *
	 * @param mixed $data 
	 * @param mixed $type 
	 * @param bool $trim 
	 * @return $data
	 * @author Matthieu Lalonde
	 */
	final	static	function escapeString(&$data, $trim = false)
	{
		$dbAbstract = Singleton::getInstance('dbAbstract');
		
		if (!is_array($data)) {
			if ($data == 'NOW()') return self::getNOW();
			
			$data = mysql_real_escape_string($data);
			
			if ($trim) {
				$data = trim($data);
			}
		} else {
			foreach($data as $key => $val) {
				if ($val == 'NOW()') {
					$data[$key] = self::getNOW();
				} else {
					if ($trim) {
						$data[$key] = trim($val);
					}
					
					$data[$key] = mysql_real_escape_string($val);
				}
			}
		}
		
		return $data;
	}
}

?><pre>
<?php
function timer($start = 0)
{
	if ($start == 0) return microtime(true) - $start;
	else return '1/'. round(1 / (microtime(true) - $start));
}
$begin = timer();

$myTest = new activeRecordTest(new xmlRenderer);
$myTest->fetchRows(H('fieldName', '*'));

$myTest->fetchRow(HA(H('fieldName', 'email'), H('login', 'xsmurf')));

// Use of a custom model method
echo 'User xsmurf <b>' . (($iExists = $myTest->loginExists('xsmurf')) ? 'exists' : 'doesn\'t exist') . "</b>\n";

if ($myTest->fetchAll() == 0 || !$iExists)
{
	$myTest->email		= 'xsmurf@smurfturf.net';
	$myTest->password	= sha1('xsmurf');
	$myTest->login		= 'xsmurf';
	
	if ($myTest->saveData())
	{
		echo '<b>Saved data 1</b>' . "\n";
	} else {
		echo '<b style="color red">Failed to save 1</b>' . "\n";
	}
}

if ($myTest->fetchRows(H('fieldName', 'id'), H('limit', 6)) <= 5) {
	$myTest->resetQuery(); // Force reset the query we want to create a new entry but had a valid query!
	$myTest->login		= 'fubar'.date('u');
	$myTest->email		= 'fubar@'.microtime().'.net';
	$myTest->password	= sha1('fubar');
	
	if ($myTest->saveData())
	{
		echo '<b>Saved data 2</b>' . "\n";
	} else {
		echo '<b style="color red">Failed to save 2</b>' . "\n";
	}
	
	/* Update the newly inserted row */
	
	$myTest->login		= 'fubar'.microtime();
	$myTest->email		= 'fubar@'.microtime().'.net';
	$myTest->password	= sha1('fubar');
	
	if ($myTest->saveData())
	{
		echo '<b>Updated data 2</b>' . "\n";
	} else {
		echo '<b style="color red">Updated to save 2</b>' . "\n";
	}
}

if ($myTest->fetchRows(HP('fieldName', 'id', 'QReversed', 'true', 'login', 'xsmurf')) >= 5)
{
	if ($myTest->deleteData())
	{
		echo '<b>Deleted data 1</b>' . "\n";
	} else {
		echo '<b style="color red">Failed to delete 1</b>' . "\n";
	}
}

if ($myTest->fetchAll() > 0)
{
	for ($i = 0;$i < $myTest->getNumRow();$i++)
	{
		$myTest->setRowID($i);
		echo $i . ': ' . $myTest->login . ' <b>&gt;</b> ' . $myTest->email . "\n";
	}
	
	if ($myTest->getNumRow() > 1 && $myTest->setRowID($myTest->getNumRow() - 1)) {
		$myTest->email = 'last@cool.net';
		$myTest->saveData();
	}
	
	if ($myTest->fetchRows(HP('fieldName', 'id', 'QReversed', 'true', 'login', 'xsmurf')) >= 3)
	{
		for ($i = 0;$i < $myTest->getNumRow();$i++)
		{
			$myTest->setRowID($i);
			$myTest->email = 'last@ofit.' . microtime();
		}
		
		$myTest->setRowID(false); // We want to update all of the entries so we have to unset our row pointer!
		$myTest->saveData();
	}
}

$myTest->fetchRows(HP('fieldName', '*'));

?></pre><?php

echo '<h2>tableRenderer generated XML</h2><hr />';

?><pre><?php
echo htmlentities($myTest->render(true));

?></pre><?php

echo '<h2>jsonRenderer output</h2><hr />';

?><pre><?php

$myTest->setRenderer(new jsonRenderer);
echo str_replace('},{', "},\n{", $myTest->render());

$time = timer($begin);

?></pre><?php
echo '<h2>Queries executed in ' . $time . ' sec.</h2>';
echo '<h2>Query log</h2><hr />';
?><pre><?php

foreach ($myTest->getQueryLog() as $query)
{
	echo '<b style="color: '. (($query[1]) ? 'red' : ' green') .'">';
	echo ($query[1]) ? 'Failed' : ' Passed';
	echo ':</b> ';
	echo $query[0] . "\n";
}

?></pre><?php //END

echo '<h2>Query usage sources</h2><hr />';
$file = file_get_contents(__FILE__);
$res = substr($file, strpos($file, '<pre>'));
$res = substr($res, 0, strrpos($res, '</pre>'));
highlight_string($res);
echo '...';

$exp	= explode("\n", $file);
$lines	= count($exp);

echo <<<XHTML
<div>
	<h1>In $lines lines of code</h1>
</div>
<hr />
	<h1>Code coverage</h1>
XHTML;

// Hash Pair
function HP()
{
	$args	= func_get_args();
	if (!is_array($args)) return $args;
	
	$myArgs = array();
	for ($i=0;$i<count($args);$i++)
	{
		if ($i%2 == 0) $myKey	= $args[$i];
		else
		{
			$myArgs[$myKey]		= $args[$i];
		}
	}
	
	return $myArgs;
} // END HP()

// Hash from Array
function HA() {
	$args	= func_get_args();
	if (!is_array($args)) return $args;
	
	$myArgs = array();
	foreach ($args as $node)
	{
		foreach($node as $key => $val)
		{
			$myArgs[$key]	= $val;
		}
	}
	
	return $myArgs;
} // END HA()

// Hash map entry
function H($node, $val) {return array($node => $val);}
?>