Subversion-Projekte lars-tiefland.prado

<?php

/**

 * TSqlMapManager class file.

 *

 * @author Wei Zhuo <weizhuo[at]gmail[dot]com>

 * @link http://www.pradosoft.com/

 * @copyright Copyright © 2005-2008 PradoSoft

 * @license http://www.pradosoft.com/license/

 * @version $Id: TSqlMapManager.php 2541 2008-10-21 15:05:13Z qiang.xue $

 * @package System.Data.SqlMap

 */

Prado::using('System.Data.SqlMap.TSqlMapGateway');

Prado::using('System.Data.SqlMap.DataMapper.TSqlMapException');

Prado::using('System.Data.SqlMap.DataMapper.TSqlMapTypeHandlerRegistry');

Prado::using('System.Data.SqlMap.DataMapper.TSqlMapCache');

Prado::using('System.Data.SqlMap.Configuration.TSqlMapStatement');

Prado::using('System.Data.SqlMap.Configuration.*');

Prado::using('System.Data.SqlMap.DataMapper.*');

Prado::using('System.Data.SqlMap.Statements.*');

/**

 * TSqlMapManager class holds the sqlmap configuation result maps, statements

 * parameter maps and a type handler factory.

 *

 * Use {@link SqlMapGateway getSqlMapGateway()} property to obtain the gateway

 * instance used for querying statements defined in the SqlMap configuration files.

 *

 * <code>

 * $conn = new TDbConnection($dsn,$dbuser,$dbpass);

 * $manager = new TSqlMapManager($conn);

 * $manager->configureXml('mydb-sqlmap.xml');

 * $sqlmap = $manager->getSqlMapGateway();

 * $result = $sqlmap->queryForObject('Products');

 * </code>

 *

 * @author Wei Zhuo <weizhuo[at]gmail[dot]com>

 * @version $Id: TSqlMapManager.php 2541 2008-10-21 15:05:13Z qiang.xue $

 * @package System.Data.SqlMap

 * @since 3.1

 */

class TSqlMapManager extends TComponent

{

	private $_mappedStatements;

	private $_resultMaps;

	private $_parameterMaps;

	private $_typeHandlers;

	private $_cacheModels;

	private $_connection;

	private $_gateway;

	/**

	 * Constructor, create a new SqlMap manager.

	 * @param TDbConnection database connection

	 * @param string configuration file.

	 */

	public function __construct($connection=null)

	{

		$this->_connection=$connection;

		$this->_mappedStatements=new TMap;

		$this->_resultMaps=new TMap;

		$this->_parameterMaps=new TMap;

		$this->_cacheModels=new TMap;

	}

	/**

	 * @param TDbConnection default database connection

	 */

	public function setDbConnection($conn)

	{

		$this->_connection=$conn;

	}

	/**

	 * @return TDbConnection default database connection

	 */

	public function getDbConnection()

	{

		return $this->_connection;

	}

	/**

	 * @return TTypeHandlerFactory The TypeHandlerFactory

	 */

	public function getTypeHandlers()

	{

		if($this->_typeHandlers===null)

			$this->_typeHandlers= new TSqlMapTypeHandlerRegistry();

		return $this->_typeHandlers;

	}

	/**

	 * @return TSqlMapGateway SqlMap gateway.

	 */

	public function getSqlmapGateway()

	{

		if($this->_gateway===null)

			$this->_gateway=$this->createSqlMapGateway();

		return $this->_gateway;

	}

	/**

	 * Loads and parses the SqlMap configuration file.

	 * @param string xml configuration file.

	 */

	public function configureXml($file)

	{

		$config = new TSqlMapXmlConfiguration($this);

		$config->configure($file);

	}

	/**

	 * Configures the current TSqlMapManager using the given xml configuration file

	 * defined in {@link ConfigFile setConfigFile()}.

	 * @return TSqlMapGateway create and configure a new TSqlMapGateway.

	 */

	protected function createSqlMapGateway()

	{

		return new TSqlMapGateway($this);

	}

	/**

	 * @return TMap mapped statements collection.

	 */

	public function getMappedStatements()

	{

		return $this->_mappedStatements;

	}

	/**

	 * Gets a MappedStatement by name.

	 * @param string The name of the statement.

	 * @return IMappedStatement The MappedStatement

	 * @throws TSqlMapUndefinedException

	 */

	public function getMappedStatement($name)

	{

		if($this->_mappedStatements->contains($name) == false)

			throw new TSqlMapUndefinedException('sqlmap_contains_no_statement', $name);

		return $this->_mappedStatements[$name];

	}

	/**

	 * Adds a (named) MappedStatement.

	 * @param string The key name

	 * @param IMappedStatement The statement to add

	 * @throws TSqlMapDuplicateException

	 */

	public function addMappedStatement(IMappedStatement $statement)

	{

		$key = $statement->getID();

		if($this->_mappedStatements->contains($key) == true)

			throw new TSqlMapDuplicateException('sqlmap_already_contains_statement', $key);

		$this->_mappedStatements->add($key, $statement);

	}

	/**

	 * @return TMap result maps collection.

	 */

	public function getResultMaps()

	{

		return $this->_resultMaps;

	}

	/**

	 * Gets a named result map

	 * @param string result name.

	 * @return TResultMap the result map.

	 * @throws TSqlMapUndefinedException

	 */

	public function getResultMap($name)

	{

		if($this->_resultMaps->contains($name) == false)

			throw new TSqlMapUndefinedException('sqlmap_contains_no_result_map', $name);

		return $this->_resultMaps[$name];

	}

	/**

	 * @param TResultMap add a new result map to this SQLMap

	 * @throws TSqlMapDuplicateException

	 */

	public function addResultMap(TResultMap $result)

	{

		$key = $result->getID();

		if($this->_resultMaps->contains($key) == true)

			throw new TSqlMapDuplicateException('sqlmap_already_contains_result_map', $key);

		$this->_resultMaps->add($key, $result);

	}

	/**

	 * @return TMap parameter maps collection.

	 */

	public function getParameterMaps()

	{

		return $this->_parameterMaps;

	}

	/**

	 * @param string parameter map ID name.

	 * @return TParameterMap the parameter with given ID.

	 * @throws TSqlMapUndefinedException

	 */

	public function getParameterMap($name)

	{

		if($this->_parameterMaps->contains($name) == false)

			throw new TSqlMapUndefinedException('sqlmap_contains_no_parameter_map', $name);

		return $this->_parameterMaps[$name];

	}

	/**

	 * @param TParameterMap add a new parameter map to this SQLMap.

	 * @throws TSqlMapDuplicateException

	 */

	public function addParameterMap(TParameterMap $parameter)

	{

		$key = $parameter->getID();

		if($this->_parameterMaps->contains($key) == true)

			throw new TSqlMapDuplicateException('sqlmap_already_contains_parameter_map', $key);

		$this->_parameterMaps->add($key, $parameter);

	}

	/**

	 * Adds a named cache.

	 * @param TSqlMapCacheModel the cache to add.

	 * @throws TSqlMapConfigurationException

	 */

	public function addCacheModel(TSqlMapCacheModel $cacheModel)

	{

		if($this->_cacheModels->contains($cacheModel->getID()))

			throw new TSqlMapConfigurationException('sqlmap_cache_model_already_exists', $cacheModel->getID());

		else

			$this->_cacheModels->add($cacheModel->getID(), $cacheModel);

	}

	/**

	 * Gets a cache by name

	 * @param string the name of the cache to get.

	 * @return TSqlMapCacheModel the cache object.

	 * @throws TSqlMapConfigurationException

	 */

	public function getCacheModel($name)

	{

		if(!$this->_cacheModels->contains($name))

			throw new TSqlMapConfigurationException('sqlmap_unable_to_find_cache_model', $name);

		return $this->_cacheModels[$name];

	}

	/**

	 * Flushes all cached objects that belong to this SqlMap

	 */

	public function flushCacheModels()

	{

		foreach($this->_cacheModels as $cache)

			$cache->flush();

	}

}