Keskustelu: Nettisivujen teko: PHP: tietokantakysely ja oliot

class TFactory
{

	/**
	 * Get a configuration object
	 *
	 * Returns a reference to the global {@link JRegistry} object, only creating it
	 * if it doesn't already exist.
	 */
	function &getConfig($file = null, $type = 'PHP')
	{
		static $instance;

		if (!is_object($instance))
		{
			if ($file === null) {
				$file = TPATH_CONFIGURATION.DS.'config.php';
			}

			$instance = TFactory::_createConfig($file, $type);
		}

		return $instance;
	}

	/**
	 * Get a database object
	 *
	 * Returns a reference to the global {@link JDatabase} object, only creating it
	 * if it doesn't already exist.
	 *
	 * @return object JDatabase
	 */
	function &getDBO()
	{
		static $instance;

		if (!is_object($instance))
		{
			//get the debug configuration setting
			$conf =& TFactory::getConfig();

			$instance = TFactory::_createDBO();
		}

		return $instance;
	}

	/**
	 * Create a configuration object
	 */
	function &_createConfig($file, $type = 'PHP')
	{
		// Hakee registry.php tiedoston
		timport('registry.registry');

		require_once $file;

		// Create the registry with a default namespace of config
		$registry = new TRegistry('config');

		// Create the TConfig object
		$config = new TConfig();

		// Load the configuration values into the registry
		$registry->loadObject($config);

		return $registry;
	}

	/**
	 * Create an database object
	 */
	function &_createDBO()
	{
		// Hakee database.php tiedoston
		timport('database.database');

		$conf =& TFactory::getConfig();

		$host 		= $conf->getValue('config.db_server');
		$user 		= $conf->getValue('config.db_user');
		$password 	= $conf->getValue('config.db_passwd');
		$database	= $conf->getValue('config.db_db');

		$options	= array ( 'host' => $host, 'user' => $user, 'password' => $password, 'database' => $database );

		$db =& TDatabase::getInstance( $options );

		return $db;
	}
}

class TObject
{

	/**
	 * A hack to support __construct() on PHP 4
	 *
	 * Hint: descendant classes have no PHP4 class_name() constructors,
	 * so this constructor gets called first and calls the top-layer __construct()
	 * which (if present) should call parent::__construct()
	 */
	function TObject()
	{
		$args = func_get_args();
		call_user_func_array(array(&$this, '__construct'), $args);
	}

	/**
	 * Class constructor, overridden in descendant classes.
	 */
	function __construct() {}

	/**
	 * Returns a property of the object or the default value if the property is not set.
 	 */
	function get($property, $default=null)
	{
		if(isset($this->$property)) {
			return $this->$property;
		}
		return $default;
	}


	/**
	 * Modifies a property of the object, creating it if it does not already exist.
	 */
	function set( $property, $value = null )
	{
		$previous = isset($this->$property) ? $this->$property : null;
		$this->$property = $value;
		return $previous;
	}
}

class TRegistry extends TObject
{
	/**
	 * Default NameSpace
	 * @var string
	 */
	var $_defaultNameSpace = null;

	/**
	 * Registry Object
	 *  - actually an array of namespace objects
	 * @var array
	 */
	var $_registry = array ();

	/**
	 * Constructor
	 */
	function __construct($namespace = 'default')
	{
		$this->_defaultNameSpace = $namespace;
		$this->makeNameSpace($namespace);
	}

	/**
	 * Create a namespace
	 */
	function makeNameSpace($namespace)
	{
		$this->_registry[$namespace] = array('data' => new stdClass());
		return true;
	}

	/**
	 * Get the list of namespaces
	 */
	function getNameSpaces()
	{
		return array_keys($this->_registry);
	}

	/**
	 * Get a registry value
	 */
	function getValue($regpath, $default=null)
	{
		$result = $default;

		// Explode the registry path into an array
		if ($nodes = explode('.', $regpath))
		{
			// Get the namespace
			//$namespace = array_shift($nodes);
			$count = count($nodes);
			if ($count < 2) {
				$namespace	= $this->_defaultNameSpace;
				$nodes[1]	= $nodes[0];
			} else {
				$namespace = $nodes[0];
			}

			if (isset($this->_registry[$namespace])) {
				$ns = & $this->_registry[$namespace]['data'];
				$pathNodes = $count - 1;

				//for ($i = 0; $i < $pathNodes; $i ++) {
				for ($i = 1; $i < $pathNodes; $i ++) {
					if((isset($ns->$nodes[$i]))) $ns =& $ns->$nodes[$i];
				}

				if(isset($ns->$nodes[$i])) {
					$result = $ns->$nodes[$i];
				}
			}
		}
		return $result;
	}

	/**
	 * Load the public variables of the object into the default namespace.
	 */
	function loadObject(&$object, $namespace = null)
	{
		// If namespace is not set, get the default namespace
		if ($namespace == null) {
			$namespace = $this->_defaultNameSpace;
		}

		if (!isset($this->_registry[$namespace])) {
			// If namespace does not exist, make it and load the data
			$this->makeNameSpace($namespace);
		}

		/*
		 * We want to leave groups that are already in the namespace and add the
		 * groups loaded into the namespace.  This overwrites any existing group
		 * with the same name
		 */
		if (is_object( $object ))
		{
			foreach (get_object_vars($object) as $k => $v) {
				$this->_registry[$namespace]['data']->$k = $v;
			}
		}

		return true;
	}
}

<?php

class TDatabase extends TObject {

	var $_values		= array();

	var $_query			= '';

	/**
	 * Returns a reference to the global Database object, only creating it
	 * if it doesn't already exist.
	 *
	 * The 'driver' entry in the parameters array specifies the database driver
	 * to be used (defaults to 'mysql' if omitted). All other parameters are
	 * database driver dependent.
	*/
	function &getInstance( $options	= array() )
	{
		static $dbo;

		if (!is_object($dbo))
		{

			$path	= dirname(__FILE__).DS.'mysql.php';

			if (file_exists($path)) {
				require_once($path);
			}

			$dbo	= new TDatabaseMySQL($options);
		}

		return $dbo;
	}

	function executedb()
	{
		$query = $this->prepare($this->_query);
		$query->execute($this->_values);
		$value = $query->fetchAll(PDO::FETCH_ASSOC);
		return $value;
	}

	function setQuery($options) {

		/**
		* Käsitellään $options -taulukko ja laitetaan valmis kysely _query -attribuuttiin
		* ja execute() -function sisään tuleva taulukko _values -attribuutin sisään.
		*/

		return $this->executedb();
	}
}

class TDatabaseMySQL extends TDatabase
{

	/**
	* Database object constructor
	*/
	function __construct( $options )
	{
		$host		= array_key_exists('host', $options)	? $options['host']		: 'localhost';
		$user		= array_key_exists('user', $options)	? $options['user']		: '';
		$password	= array_key_exists('password',$options)	? $options['password']	: '';
		$database	= array_key_exists('database',$options)	? $options['database']	: '';

		try {
			$lnk = new PDO("mysql:host=".$host.";dbname=".$database, $user, $password);
			$lnk->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
			$lnk->exec('SET CHARACTER SET utf8');
		} catch (PDOException $e) {
			TErrors::setError('Could not connect to MySQL');
		}
		return $lnk;
	}

	/**
	 * Database object destructor
	 */
	function __destruct()
	{
		$return = false;
		unset($lnk);
		return $return;
	}

	function prepare()
	{
		return;
	}

	function execute()
	{
		return;
	}
}

class TDatabaseMySQL extends TDatabase
{
	var $_db		= '';
	var $_host		= '';
	var $_user		= '';
	var $_password	= '';
	var $_database	= 'localhost';

	/**
	* Database object constructor
	*/
	function __construct( $options )
	{
		$this->_host		= array_key_exists('host', $options)	? $options['host']		: 'localhost';
		$this->_user		= array_key_exists('user', $options)	? $options['user']		: '';
		$this->_password	= array_key_exists('password',$options)	? $options['password']	: '';
		$this->_database	= array_key_exists('database',$options)	? $options['database']	: '';
		$this->_db			= $this->getdb();
		$this->getdb();

	}

	/**
	 * Database object destructor
	 */
	function __destruct()
	{
		$return = false;
		unset($this->_db);
		return $return;
	}

	/**
	* Open the database connection and returns the database object
	*/
	function getdb() {
		try {
			$db = new PDO("mysql:host=".$this->_host.";dbname=".$this->_database, $this->_user, $this->_password);
			$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
			$db->exec('SET CHARACTER SET utf8');
		} catch (PDOException $e) {
			TErrors::setError('Could not connect to MySQL');
		}
		return $db;
	}

	/**
	 * Sets given value to given property
	 */
	function setValue($key, $value)
	{
		$this->$key = property_exists('TDatabase', $key) ? $value : $this->$key;
	}

	/**
	 * Returns value of given property
	 */
	function getValue($key)
	{
		return $this->$key;
	}
}