Importing SQLMap + sample + docs.

15 files changed, 1488 insertions, 0 deletions

diff --git a/framework/DataAccess/SQLMap/Configuration/TConfigDeserialize.php b/framework/DataAccess/SQLMap/Configuration/TConfigDeserialize.php
new file mode 100644
index 00000000..250133b9
--- /dev/null
+++ b/framework/DataAccess/SQLMap/Configuration/TConfigDeserialize.php
@@ -0,0 +1,171 @@
+<?php

+

+class TConfigDeserialize

+{

+	private $_properties;

+

+	public function __construct($properties)

+	{

+		$this->_properties = $properties;

+	}

+

+	public function loadConfiguration($object, $node, $file)

+	{

+		foreach($node->attributes() as $k=>$v)

+		{

+			if($object->canSetProperty($k))

+				$object->{'set'.$k}($this->replaceProperties((string)($v)));

+			else 

+				throw new TUndefinedAttributeException($k,$node,$object,$file);

+		}	

+	}

+

+	public function replaceProperties($string)

+	{

+		foreach($this->_properties as $find => $replace)

+			$string = str_replace('${'.$find.'}', $replace, $string);

+		return $string;

+	}

+

+	public function parameterMap($node, $sqlMap, $file)

+	{

+		$parameterMap = new TParameterMap;

+		$this->loadConfiguration($parameterMap, $node, $file);

+		foreach($node->parameter as $parameter)

+		{

+			$property = $this->parameterProperty($parameter, $sqlMap, $file);

+			$property->initialize($sqlMap);

+			$parameterMap->addParameterProperty($property);

+		}

+		return $parameterMap;

+	}

+

+	public function parameterProperty($node, $sqlMap, $file)

+	{

+		$property = new TParameterProperty;

+		$this->loadConfiguration($property, $node, $file);

+		return $property;

+	}

+

+	public function select($node, $sqlMap, $file)

+	{

+		$select = new TSqlMapSelect;

+		$this->loadConfiguration($select, $node, $file);

+		$select->initialize($sqlMap);

+		return $select;

+	}

+

+	public function update($node, $sqlMap, $file)

+	{

+		$update = new TSqlMapUpdate;

+		$this->loadConfiguration($update, $node, $file);

+		$update->initialize($sqlMap);

+		return $update;

+	}

+

+	public function delete($node, $sqlMap, $file)

+	{

+		$delete = new TSqlMapDelete;

+		$this->loadConfiguration($delete, $node, $file);

+		$delete->initialize($sqlMap);

+		return $delete;

+	}

+

+

+	public function insert($node, $sqlMap, $file)

+	{

+		$insert = new TSqlMapInsert;

+		$this->loadConfiguration($insert, $node, $file);

+		if(isset($node->selectKey))

+		{

+			$selectKey = new TSqlMapSelectKey;

+			$this->loadConfiguration($selectKey, $node->selectKey, $file);

+			$type = $selectKey->getType();

+			$selectKey->setType(strtolower($type) == 'post' ? 'post' : 'pre');

+			$insert->setSelectKey($selectKey);

+		}

+		if(isset($node->generate))

+		{

+			var_dump("add generate");

+		}

+

+		$insert->initialize($sqlMap);

+		return $insert;

+	}

+	

+	public function statement($node, $sqlMap, $file)

+	{

+		$statement = new TSqlMapStatement;

+		$this->loadConfiguration($statement, $node, $file);

+		$statement->initialize($sqlMap);

+		return $statement;

+	}

+	

+	public function resultMap($node, $sqlMap, $file)

+	{

+		$resultMap = new TResultMap;

+		$this->loadConfiguration($resultMap, $node, $file);

+		foreach($node->result as $result)

+		{

+			$property = $this->resultProperty($result, $sqlMap, $file);

+			$property->initialize($sqlMap, $resultMap);

+			$resultMap->addResultProperty($property);

+		}

+		$discriminator = null;

+		if(isset($node->discriminator))

+		{

+			$discriminator = new TDiscriminator;

+			$this->loadConfiguration($discriminator, $node->discriminator, $file);

+			$discriminator->initMapping($sqlMap, $resultMap);

+		}

+		foreach($node->subMap as $subMapNode)

+		{

+			if(is_null($discriminator))

+				throw new TSqlMapConfigurationException(

+					'sqlmap_undefined_discriminator', $resultMap->getID(), $file);

+			$subMap = new TSubMap;

+			$this->loadConfiguration($subMap, $subMapNode, $file);

+			$discriminator->add($subMap);

+		}

+		if(!is_null($discriminator))

+			$resultMap->setDiscriminator($discriminator);

+

+		return $resultMap;

+	}

+

+	public function resultProperty($node, $sqlMap, $file)

+	{

+		$resultProperty = new TResultProperty;

+		$this->loadConfiguration($resultProperty, $node, $file);

+		return $resultProperty;

+	}

+

+	public function cacheModel($node, $sqlMap, $file)

+	{

+		$cacheModel = new TSqlMapCacheModel;

+		$this->loadConfiguration($cacheModel, $node, $file);

+		if(isset($node->flushInterval))

+		{

+			$interval = $node->flushInterval;

+			$span = 0; //span in seconds

+			if(isset($interval['hours']))

+				$span += intval($interval['hours'])*60*60;

+			if(isset($interval['minutes']))

+				$span += intval($interval['minutes'])*60;

+			if(isset($interval['seconds']))

+				$span += intval($interval['seconds']);

+			if($span > 0)

+				$cacheModel->setFlushInterval($span);

+		}

+		if(isset($node->property))

+		{

+			foreach($node->property as $property)

+				$cacheModel->addProperty((string)$property['name'],

+						(string)$property['value']);

+		}

+		return $cacheModel;

+	}

+}

+

+

+?>
\ No newline at end of file
diff --git a/framework/DataAccess/SQLMap/Configuration/TDiscriminator.php b/framework/DataAccess/SQLMap/Configuration/TDiscriminator.php
new file mode 100644
index 00000000..0ee34e3e
--- /dev/null
+++ b/framework/DataAccess/SQLMap/Configuration/TDiscriminator.php
@@ -0,0 +1,86 @@
+<?php

+

+class TDiscriminator extends TComponent

+{

+	private $_column='';

+	private $_type='';

+	private $_typeHandler=null;

+	private $_dbType='';

+	private $_columnIndex='';

+	private $_nullValue='';

+	private $_mapping='';

+	private $_resultMaps=array();

+	private $_subMaps=array();

+

+	public function getColumn(){ return $this->_column; }

+	public function setColumn($value){ $this->_column = $value; }

+

+	public function getType(){ return $this->_type; }

+	public function setType($value){ $this->_type = $value; }

+

+	public function getTypeHandler(){ return $this->_typeHandler; }

+	public function setTypeHandler($value){ $this->_typeHandler = $value; }

+

+	public function getDbType(){ return $this->_dbType; }

+	public function setDbType($value){ $this->_dbType = $value; }

+

+	public function getColumnIndex(){ return $this->_columnIndex; }

+	public function setColumnIndex($value){ $this->_columnIndex = $value; }

+

+	public function getNullValue(){ return $this->_nullValue; }

+	public function setNullValue($value){ $this->_nullValue = $value; }

+

+	public function getMapping(){ return $this->_mapping; }

+

+	public function getResultMaps(){ return $this->_resultMaps; }

+	public function setResultMaps($value){ $this->_resultMaps = $value; }

+

+	public function add($subMap)

+	{ 

+		$this->_subMaps[] = $subMap;

+	}

+

+	public function getSubMap($value)

+	{ 

+		if(isset($this->_resultMaps[$value]))

+			return $this->_resultMaps[$value];

+		else

+			return null;

+	}

+

+	public function initMapping($sqlMap, $resultMap)

+	{

+		$this->_mapping = new TResultProperty;

+		$this->_mapping->setColumn($this->getColumn());

+		$this->_mapping->setColumnIndex($this->getColumnIndex());

+		$this->_mapping->setType($this->getType());

+		$this->_mapping->setTypeHandler($this->getTypeHandler());

+		$this->_mapping->setDbType($this->getDbType());

+		$this->_mapping->setNullValue($this->getNullValue());

+		$this->_mapping->initialize($sqlMap, $resultMap);

+	}

+

+	public function initialize($sqlMap)

+	{

+		foreach($this->_subMaps as $subMap)

+		{

+			$this->_resultMaps[$subMap->getValue()] =

+				$sqlMap->getResultMap($subMap->getResultMapping());

+		}

+	}

+}

+

+

+class TSubMap extends TComponent

+{

+	private $_value='';

+	private $_resultMapping='';

+

+	public function getValue(){ return $this->_value; }

+	public function setValue($value){ $this->_value = $value; }

+

+	public function getResultMapping(){ return $this->_resultMapping; }

+	public function setResultMapping($value){ $this->_resultMapping = $value; }

+}

+

+?>
\ No newline at end of file
diff --git a/framework/DataAccess/SQLMap/Configuration/TDomSqlMapBuilder.php b/framework/DataAccess/SQLMap/Configuration/TDomSqlMapBuilder.php
new file mode 100644
index 00000000..d3059dd7
--- /dev/null
+++ b/framework/DataAccess/SQLMap/Configuration/TDomSqlMapBuilder.php
@@ -0,0 +1,481 @@
+<?php

+

+class TDomSqlMapBuilder

+{

+	const DEFAULT_CONFIG_FILE = 'sqlmap.xml';

+

+	private $_document;

+

+	private $_sqlMapper;

+

+	private $_configFile;

+

+	private $_properties;

+

+	private $_deserialize;

+

+	private $_useNamespaces = false;

+

+	private $_FlushOnExecuteStatements=array();

+

+	public function __construct($cachedir='./cache')

+	{

+		$this->_properties = new TMap;

+		$this->_deserialize = new TConfigDeserialize($this->_properties);

+	}

+

+	public function configure($resource=null)

+	{

+		if($resource instanceof SimpleXMLElement)

+			return $this->build($resource);

+		

+		if(!is_string($resource))

+			$resource = self::DEFAULT_CONFIG_FILE;

+		

+		$this->_configFile = $resource;

+		if(!is_file($resource))

+			throw new TSqlMapConfigurationException(

+				'sqlmap_unable_to_find_config', $resource);

+

+		return $this->build($this->getConfigAsXmlDocument($resource));

+	}

+

+	protected function getConfigAsXmlDocument($file)

+	{

+		return simplexml_load_file($file);

+	}

+

+	public function build(SimpleXMLElement $document)

+	{

+		$this->_document = $document;

+		$this->initialize($document);

+		return $this->_sqlMapper;

+	}

+

+	protected function initialize($document)

+	{

+		$this->_sqlMapper = new TSqlMapper(new TTypeHandlerFactory);

+

+		if(isset($document->properties))

+		{

+			$this->loadGlobalProperties($document->properties);

+		}

+		

+		if(isset($document->settings) && isset($document->settings->setting))

+			$this->configureSettings($document->settings);

+

+		//load database provider

+		if(isset($document->provider) && isset($document->provider->datasource))

+		{

+			$this->loadProvider($document->provider, 

+				$document->provider->datasource, $document, $this->_configFile);

+		}

+		else

+		{

+			throw new TSqlMapConfigurationException(

+					'sqlmap_unable_to_find_db_config', $this->_configFile);

+		}

+

+		if(isset($document->sqlMaps) && isset($document->sqlMaps->sqlMap))

+			$this->loadSqlMappingFiles($document->sqlMaps);

+

+		if($this->_sqlMapper->getIsCacheModelsEnabled())

+			$this->attachCacheModel();

+	}

+

+	protected function configureSettings($node)

+	{

+		foreach($node->setting as $setting)

+		{

+			if(isset($setting['useStatementNamespaces']))

+			{

+				$this->_useNamespaces = 

+					TPropertyValue::ensureBoolean(

+						(string)$setting['useStatementNamespaces']);

+			}

+

+			if(isset($setting['cacheModelsEnabled']))

+			{

+				$this->_sqlMapper->setCacheModelsEnabled(

+					TPropertyValue::ensureBoolean(

+						(string)$setting['cacheModelsEnabled']));

+			}

+		}

+	}

+

+	/**

+	 * Attach CacheModel to statement and register trigger statements for 

+	 * cache models

+	 */

+	protected function attachCacheModel()

+	{

+		foreach($this->_sqlMapper->getStatements() as $mappedStatement)

+		{

+			if(strlen($model = $mappedStatement->getStatement()->getCacheModel()) > 0)

+			{

+				$cache = $this->_sqlMapper->getCache($model); 

+				//var_dump($model);

+				$mappedStatement->getStatement()->setCache($cache);

+			}

+		}	

+

+		foreach($this->_FlushOnExecuteStatements as $cacheID => $statementIDs)

+		{

+			if(count($statementIDs) > 0)

+			{

+				foreach($statementIDs as $statementID)

+				{

+					$cacheModel = $this->_sqlMapper->getCache($cacheID);

+					$statement = $this->_sqlMapper->getMappedStatement($statementID);

+					$cacheModel->registerTriggerStatement($statement);

+				}

+			}

+		}

+	}

+

+	protected function loadGlobalProperties($node)

+	{

+		if(isset($node['resource']))

+			$this->loadPropertyResource($node);

+

+		foreach($node->children() as $child)

+		{

+			if(isset($child['resource']))

+				$this->loadPropertyResource($child);

+			$this->_properties[(string)$child['key']] = (string)$child['value'];

+		}

+	}

+

+	protected function loadPropertyResource($node)

+	{

+		$resource = $this->getResourceFromPath((string)$node['resource']);

+		$properties = $this->getConfigAsXmlDocument($resource);

+		$this->loadGlobalProperties($properties);

+	}

+

+	protected function loadProvider($providerNode, $node, $document, $file)

+	{

+		//$id = (string)$node['id'];

+		$class = (string)$providerNode['class'];

+		if(strlen($class) > 0 && class_exists($class,false))

+		{

+			$provider = new $class;

+			$this->_deserialize->loadConfiguration($provider, $node,$file);

+			$this->_sqlMapper->setDataProvider($provider);

+		}

+		else

+		{

+			throw new TSqlMapConfigurationException(

+						'sqlmap_unable_find_provider_class', $file);

+		}

+		//var_dump($node);

+	}

+/*

+	protected function loadTypeHandlers()

+	{

+	}

+*/

+	protected function loadSqlMappingFiles($sqlmappings)

+	{

+		foreach($sqlmappings->sqlMap as $node)

+		{

+			$resource = $this->getResourceFromPath((string)$node['resource']);

+			$sqlmap = $this->getConfigAsXmlDocument($resource);

+			$this->configureSqlMap($sqlmap,$resource);

+		}

+

+		$this->resolveResultMapping();

+	}

+

+	protected function getResourceFromPath($resource)

+	{

+		$basedir = dirname($this->_configFile);

+		$file = realpath($basedir.'/'.$resource);

+		if(!is_string($file) || !is_file($file))

+			$file = realpath($resource);

+		if(is_string($file) && is_file($file))

+			return $file;

+		else

+			throw new TSqlMapConfigurationException(

+				'sqlmap_unable_to_find_resource', $resource);

+	}

+

+	protected function configureSqlMap($document,$file)

+	{

+	//	if(isset($document->typeAlias))

+	//		foreach($document->typeAlias as $node)

+	//			TTypeAliasDeSerializer::Deserialize($node, $this->_sqlMapper);

+		if(isset($document->resultMap))

+			foreach($document->resultMap as $node)

+				$this->loadResultMap($node,$document,$file);

+		if(isset($document->parameterMap))

+			foreach($document->parameterMap as $node)

+				$this->loadParameterMap($node, $document, $file);

+		if(isset($document->statement))

+			foreach($document->statement as $node)

+				$this->loadStatementTag($node, $document,$file);

+		if(isset($document->select))

+			foreach($document->select as $node)

+				$this->loadSelectTag($node, $document, $file);

+		if(isset($document->insert))

+			foreach($document->insert as $node)

+				$this->loadInsertTag($node, $document, $file);

+		if(isset($document->update))

+			foreach($document->update as $node)

+				$this->loadUpdateTag($node, $document, $file);

+		if(isset($document->delete))

+			foreach($document->delete as $node)

+				$this->loadDeleteTag($node, $document, $file);

+/*		if(isset($document->procedure))

+			foreach($document->procedure as $node)

+				$this->loadProcedureTag($node);

+*/

+		if($this->_sqlMapper->getIsCacheModelsEnabled())

+		{

+			if(isset($document->cacheModel))

+				foreach($document->cacheModel as $node)

+					$this->loadCacheModel($node, $document, $file);

+		}

+	}

+

+	protected function loadCacheModel($node, $document, $file)

+	{

+		$cacheModel = $this->_deserialize->cacheModel($node, $this->_sqlMapper, $file);

+		if(isset($node->flushOnExecute))

+		{

+			foreach($node->flushOnExecute as $flush)

+			{

+				$id = $cacheModel->getID();

+				if(!isset($this->_FlushOnExecuteStatements[$id]))

+					$this->_FlushOnExecuteStatements[$id] = array();

+

+				$this->_FlushOnExecuteStatements[$id][] = (string)$flush['statement'];

+			}

+		}

+		//var_dump($cacheModel);

+		$cacheModel->initialize($this->_sqlMapper);

+		$this->_sqlMapper->addCache($cacheModel);

+	}

+

+	protected function loadUpdateTag($node, $document, $file)

+	{

+		$update = $this->_deserialize->insert($node, $this->_sqlMapper, $file);

+		if(!is_null($update->getGenerate()))

+		{

+			var_dump('generate update');

+		}

+		else

+		{

+			$this->processSqlStatement($update, $document, $node, $file);

+		}

+		$mappedStatement = new TUpdateMappedStatement($this->_sqlMapper, $update);

+		$this->_sqlMapper->addMappedStatement($mappedStatement);

+	}

+

+	protected function loadDeleteTag($node, $document, $file)

+	{

+		$delete = $this->_deserialize->delete($node, $this->_sqlMapper, $file);

+		if(!is_null($delete->getGenerate()))

+		{

+			var_dump('generate delete');

+		}

+		else

+		{

+			$this->processSqlStatement($delete, $document, $node, $file);

+		}

+		$mappedStatement = new TDeleteMappedStatement($this->_sqlMapper, $delete);

+		$this->_sqlMapper->addMappedStatement($mappedStatement);

+	}

+

+

+	protected function loadParameterMap($node, $document, $file)

+	{

+		$id = (string)$node['id'];

+		if($this->_sqlMapper->getParameterMaps()->contains($id))

+			return;

+		$parameterMap = $this->_deserialize->parameterMap($node, $this->_sqlMapper, $file);

+		$extendMap = $parameterMap->getExtends();

+		if(strlen($extendMap) > 0)

+		{

+			if($this->_sqlMapper->getParameterMaps()->contains($extendMap) == false)

+			{

+				$nodes = $document->xpath("//parameterMap[@id='{$extendMap}']");

+				if(isset($nodes[0]))

+					$this->loadParameterMap($nodes[0],$document,$file);

+				else

+					throw new TSqlMapConfigurationException(

+						'sqlmap_unable_to_find_parent_parameter_map', $extendMap, $file);

+			}

+			$superMap = $this->_sqlMapper->getParameterMap($extendMap);

+			$index = 0;

+			foreach($superMap->getPropertyNames() as $propertyName)

+			{

+				$parameterMap->insertParameterProperty($index++, 

+						$superMap->getProperty($propertyName));

+			}

+		}

+		$this->_sqlMapper->addParameterMap($parameterMap);

+	}

+

+	protected function loadInsertTag($node, $document, $file)

+	{

+		$insert = $this->_deserialize->insert($node, $this->_sqlMapper, $file);

+		if(!is_null($insert->getGenerate()))

+		{

+			var_dump("generate insert");

+		}

+		else

+		{

+			$this->processSqlStatement($insert, $document, $node, $file);

+		}

+

+		$mappedStatement = new TInsertMappedStatement($this->_sqlMapper, $insert);

+		$this->_sqlMapper->addMappedStatement($mappedStatement);

+		if(!is_null($insert->getSelectKey()))

+		{

+			$selectKey = $insert->getSelectKey();

+			$selectKey->setID($insert->getID());

+			$selectKey->initialize($this->_sqlMapper);

+			$selectKey->setID($insert->getID().'.SelectKey');

+			$this->processSqlStatement($selectKey, 

+					$document, $node->selectKey, $file);

+			$mappedStatement = new TMappedStatement($this->_sqlMapper, $selectKey);

+			$this->_sqlMapper->addMappedStatement($mappedStatement);

+		}

+	}

+

+	protected function processSqlStatement($statement, $document, $node, $file)

+	{

+		$commandText = (string)$node;

+		if(strlen($extend = $statement->getExtends()) > 0)

+		{

+			$superNodes = $document->xpath("//*[@id='{$extend}']");

+			if(isset($superNodes[0]))

+				$commandText = (string)$superNodes[0] . $commandText;

+			else

+				throw TSqlMapConfigurationException(

+						'sqlmap_unable_to_find_parent_sql', $extend, $file);

+		}

+

+		//$sql = new TStaticSql();

+		//$sql->buildPreparedStatement($statement, (string)$node);

+		$commandText = $this->_deserialize->replaceProperties($commandText);

+		$this->applyInlineParameterMap($statement, $commandText, $node, $file);

+		//$statement->setSql($sql);

+	}

+

+	protected function applyInlineParameterMap($statement, $sqlStatement, $node, $file)

+	{

+		if($statement->parameterMap() == null)

+		{

+			$scope['statement']  = $statement->getID();

+			$scope['file'] = $file;

+

+			// Build a Parametermap with the inline parameters.

+			// if they exist. Then delete inline infos from sqltext.

+			$parameterParser = new TInlineParameterMapParser;

+			$sqlText = $parameterParser->parseInlineParameterMap(

+							$this->_sqlMapper, $statement, $sqlStatement, $scope);

+			if(count($sqlText['parameters']) > 0)

+			{

+				$map = new TParameterMap();

+				$map->setID($statement->getID().'-InLineParameterMap');

+				$statement->setInlineParameterMap($map);

+				foreach($sqlText['parameters'] as $property)

+					$map->addParameterProperty($property);

+			}

+			$sqlStatement = $sqlText['sql'];

+		}

+		$sql = new TStaticSql();

+		$sql->buildPreparedStatement($statement, $sqlStatement);

+		$statement->setSql($sql);

+	}

+

+	protected function resolveResultMapping()

+	{

+		$maps = $this->_sqlMapper->getResultMaps();

+		foreach($maps as $entry)

+		{

+			foreach($entry->getColumns() as $item)

+			{

+				$resultMap = $item->getResultMapping();

+				if(strlen($resultMap) > 0)

+				{

+					if($maps->contains($resultMap))

+						$item->setNestedResultMap($maps[$resultMap]);

+					else

+						throw new TSqlMapConfigurationException(

+							'sqlmap_unable_to_find_result_mapping', 

+								$resultMap, $this->_configFile, $entry->getID());

+				}

+			}

+			if(!is_null($entry->getDiscriminator()))

+			{

+				$entry->getDiscriminator()->initialize($this->_sqlMapper);

+			}

+		}

+	}

+

+	protected function loadSelectTag($node, $document, $file)

+	{

+		$select = $this->_deserialize->select($node, $this->_sqlMapper, $file);

+		if(!is_null($select->getGenerate()))

+		{

+			var_dump("generate select");

+		}

+		else

+		{

+			$this->processSqlStatement($select, $document, $node, $file);

+			/*$sql = new TStaticSql();

+			$sql->buildPreparedStatement($select, (string)$node);

+			$select->setSql($sql);*/

+		}

+		

+		$mappedStatement = new TMappedStatement($this->_sqlMapper, $select);

+		if($this->_sqlMapper->getIsCacheModelsEnabled() && 

+				strlen($select->getCacheModel()) > 0)

+		{

+			$mappedStatement = new TCachingStatement($mappedStatement);

+		}

+

+		$this->_sqlMapper->addMappedStatement($mappedStatement);

+	}

+

+	protected function loadResultMap($node,$document,$file)

+	{

+		$resultMap = $this->_deserialize->resultMap($node, $this->_sqlMapper,$file);

+		$extendMap = $resultMap->getExtends();

+		if(strlen($extendMap) > 0)

+		{

+			if(!$this->_sqlMapper->getResultMaps()->contains($extendMap))

+			{

+				$nodes = $document->xpath("//resultMap[@id='{$extendMap}']");

+				if(isset($nodes[0]))

+					$this->loadResultMap($nodes[0],$document,$file);

+				else

+					throw new TSqlMapConfigurationException(

+						'sqlmap_unable_to_find_parent_result_map', $extendMap, $file);

+			}

+			$superMap = $this->_sqlMapper->getResultMap($extendMap);

+			$resultMap->getColumns()->mergeWith($superMap->getColumns());

+		}

+		if(!$this->_sqlMapper->getResultMaps()->contains($resultMap->getID()))

+			$this->_sqlMapper->addResultMap($resultMap);

+	}

+

+

+	protected function loadStatementTag($node, $document, $file)

+	{

+		$statement = $this->_deserialize->statement($node, $this->_sqlMapper, $file);

+		

+		/*$sql = new TStaticSql();

+		$sql->buildPreparedStatement($statement, (string)$node);

+		$statement->setSql($sql);*/

+		$this->processSqlStatement($statement, $document, $node, $file);

+

+		$mappedStatement = new TMappedStatement($this->_sqlMapper, $statement);

+		$this->_sqlMapper->addMappedStatement($mappedStatement);

+	}

+}

+

+?>
\ No newline at end of file
diff --git a/framework/DataAccess/SQLMap/Configuration/TInlineParameterMapParser.php b/framework/DataAccess/SQLMap/Configuration/TInlineParameterMapParser.php
new file mode 100644
index 00000000..8b1ecf04
--- /dev/null
+++ b/framework/DataAccess/SQLMap/Configuration/TInlineParameterMapParser.php
@@ -0,0 +1,50 @@
+<?php

+

+class TInlineParameterMapParser

+{

+	private $PARAMETER_TOKEN_REGEXP = '/#(#?[^#]+#?)#/';

+

+	public function parseInlineParameterMap($sqlMap, $statement, $sqlText, $scope)

+	{

+		$parameterClass = !is_null($statement) 

+							? $statement->getParameterClass() : null;

+		$matches = array();

+		$mappings = array();

+		preg_match_all($this->PARAMETER_TOKEN_REGEXP, $sqlText, $matches);

+		

+		for($i = 0, $k=count($matches[1]); $i<$k; $i++)

+		{

+			$mappings[] = $this->parseMapping($matches[1][$i], 

+									$parameterClass, $sqlMap, $scope);

+			$sqlText = str_replace($matches[0][$i], '?', $sqlText);

+		}

+		return array('sql'=>$sqlText, 'parameters'=>$mappings);

+	}

+

+	/**

+	 * Parse inline parameter with syntax as

+	 * #propertyName,type=string,dbype=Varchar,nullValue=N/A,handler=string#

+	 */

+	protected function parseMapping($token, $parameterClass, $sqlMap, $scope)

+	{

+		$mapping = new TParameterProperty;

+		$properties = explode(',', $token);

+		$mapping->setProperty(trim(array_shift($properties)));

+		//var_dump($properties);

+		foreach($properties as $property)

+		{

+			$prop = explode('=',$property);

+			$name = trim($prop[0]); $value=trim($prop[1]);

+			if($mapping->canSetProperty($name))

+				$mapping->{'set'.$name}($value);

+			else

+				throw new TSqlMapUndefinedException(

+						'sqlmap_undefined_property_inline_map',

+						$name, $scope['statement'], $scope['file']);

+		}

+		$mapping->initialize($sqlMap);

+		return $mapping;

+	}

+}

+

+?>
\ No newline at end of file
diff --git a/framework/DataAccess/SQLMap/Configuration/TParameterMap.php b/framework/DataAccess/SQLMap/Configuration/TParameterMap.php
new file mode 100644
index 00000000..8e1c757d
--- /dev/null
+++ b/framework/DataAccess/SQLMap/Configuration/TParameterMap.php
@@ -0,0 +1,95 @@
+<?php

+

+class TParameterMap extends TComponent

+{

+	private $_ID='';

+	private $_extend='';

+	private $_properties;

+	private $_propertyMap;

+	private $_extendMap;

+

+	public function __construct()

+	{

+		$this->_properties = new TList;

+		$this->_propertyMap = new TMap;

+	}

+

+	public function getProperties(){ return $this->_properties; }

+

+	public function getID(){ return $this->_ID; }

+	public function setID($value){ $this->_ID = $value; }

+

+	public function getExtends(){ return $this->_extend; }

+	public function setExtends($value){ $this->_extend = $value; }

+

+	public function getProperty($index)

+	{

+		if(is_string($index))

+			return $this->_propertyMap->itemAt($index);

+		else if(is_int($index))

+			return $this->_properties->itemAt($index);

+		else

+			throw new TDataMapperException(

+						'sqlmap_index_must_be_string_or_int', $index);

+	}

+

+	public function addParameterProperty(TParameterProperty $property)

+	{

+		$this->_propertyMap->add($property->getProperty(), $property);

+		$this->_properties->add($property);

+	}

+

+	public function insertParameterProperty($index, TParameterProperty $property)

+	{

+		$this->_propertyMap->add($property->getProperty(), $property);

+		$this->_properties->insertAt($index, $property);

+	}

+	

+	public function getPropertyNames()

+	{

+		return $this->_propertyMap->getKeys();

+	}

+

+	public function getParameter($mapping, $parameterValue, $statement)

+	{

+		$value = $parameterValue;

+		$typeHandler = $mapping->getTypeHandler();

+		try

+		{

+			$value = TPropertyAccess::get($parameterValue, $mapping->getProperty());		

+		}

+		catch (TInvalidPropertyException $e)

+		{

+			throw new TSqlMapExecutionException(

+					'sqlmap_unable_to_get_property_for_parameter',$this->getID(), 

+					$mapping->getProperty(), get_class($parameterValue), 

+					$e->getMessage(), $statement->getID());

+		}

+

+		if(!is_null($typeHandler))

+		{

+			try

+			{

+				$value = $typeHandler->getParameter($value);			

+			}

+			catch (Exception $e)

+			{

+				throw new TSqlMapExecutionException(

+				'sqlmap_error_in_parameter_from_handler',$this->getID(),

+				$value, get_class($typeHandler), $e->getMessage());

+			}

+		}

+

+		if(!is_null($nullValue = $mapping->getNullValue()))

+		{

+			if($nullValue === $value)

+				$value = null;

+		}

+

+		if(!is_null($type = $mapping->getType()))

+			$value = TTypeHandlerFactory::convertToType($type, $value);

+

+		return $value;

+	}

+}

+?>
\ No newline at end of file
diff --git a/framework/DataAccess/SQLMap/Configuration/TParameterProperty.php b/framework/DataAccess/SQLMap/Configuration/TParameterProperty.php
new file mode 100644
index 00000000..2ff55f73
--- /dev/null
+++ b/framework/DataAccess/SQLMap/Configuration/TParameterProperty.php
@@ -0,0 +1,68 @@
+<?php

+

+class TParameterProperty extends TComponent

+{

+	private $_typeHandler=null;

+	private $_type=null;

+	private $_column='';

+	private $_dbType='';

+	private $_property='';

+	private $_nullValue=null;

+	private $_typeHandlerFactory;

+

+	private $_size;

+	private $_precision;

+	private $_scale;

+	private $_direction;

+

+	public function getTypeHandler()

+	{

+		if(is_null($this->_typeHandlerFactory)) return null;

+		if(!is_null($this->_typeHandler))

+			return $this->_typeHandlerFactory->getTypeHandler($this->_typeHandler);

+		else if(!is_null($this->getType()))

+			return $this->_typeHandlerFactory->getTypeHandler($this->getType());

+		else

+			return null;

+	}

+	public function setTypeHandler($value){ $this->_typeHandler = $value; }

+

+	public function getType(){ return $this->_type; }

+	public function setType($value){ $this->_type = $value; }

+

+	public function getColumn(){ return $this->_column; }

+	public function setColumn($value){ $this->_column = $value; }

+

+	public function getDbType(){ return $this->_dbType; }

+	public function setDbType($value){ $this->_dbType = $value; }

+

+	public function getProperty(){ return $this->_property; }

+	public function setProperty($value){ $this->_property = $value; }

+

+	public function getNullValue(){ return $this->_nullValue; }

+	public function setNullValue($value){ $this->_nullValue = $value; }

+

+	public function getSize(){ return $this->_size; }

+	public function setSize($value){ $this->_size = $value; }

+

+	public function getPrecision(){ return $this->_precision; }

+	public function setPrecision($value){ $this->_precision = $value; }

+	

+	public function getScale(){ return $this->_scale; }

+	public function setScale($value){ $this->_scale = $value; }

+

+	

+	public function getDirection(){ return $this->_direction; }

+	public function setDirection($value){ $this->_direction = $value; }

+

+	public function initialize($sqlMap)

+	{

+		$this->_typeHandlerFactory = $sqlMap->getTypeHandlerFactory();

+	//	$type = !is_null($this->_typeHandler) ? $this->_typeHandler: $this->_type;

+	//	$this->setTypeHandler($sqlMap->getTypeHandlerFactory()->getTypeHandler($type));

+	//	if(!is_null($type))

+	//		var_dump($sqlMap->getTypeHandlerFactory());

+	}

+}

+

+?>
\ No newline at end of file
diff --git a/framework/DataAccess/SQLMap/Configuration/TResultMap.php b/framework/DataAccess/SQLMap/Configuration/TResultMap.php
new file mode 100644
index 00000000..0f09a1ba
--- /dev/null
+++ b/framework/DataAccess/SQLMap/Configuration/TResultMap.php
@@ -0,0 +1,63 @@
+<?php

+

+class TResultMap extends TComponent

+{

+	private $_ID='';

+	private $_className='';

+	private $_columns='';

+	private $_extendMap='';

+	private $_groupBy='';

+	private $_discriminator=null;

+

+	public function __construct()

+	{

+		$this->_columns = new TMap;

+	}

+

+	public function getID(){ return $this->_ID; }

+	public function setID($value){ $this->_ID = $value; }

+

+	public function getClass(){ return $this->_className; }

+	public function setClass($value){ $this->_className = $value; }

+

+	public function getColumns(){ return $this->_columns; }

+	public function setColumns($value){ $this->_columns = $value; }

+

+	public function getExtends(){ return $this->_extendMap; }

+	public function setExtends($value){ $this->_extendMap = $value; }

+

+	public function getGroupBy(){ return $this->_groupBy; }

+	public function setGroupBy($value){ $this->_groupBy = $value; }

+

+	public function getDiscriminator(){ return $this->_discriminator; }

+	public function setDiscriminator($value){ $this->_discriminator = $value; }

+

+	public function addResultProperty(TResultProperty $property)

+	{

+		$this->_columns->add($property->getProperty(), $property);

+	}

+	

+	public function createInstanceOfResult()

+	{

+		return TTypeHandlerFactory::createInstanceOf($this->getClass());

+	}

+

+	public function resolveSubMap($row)

+	{

+		$subMap = $this;

+		if(!is_null($disc = $this->getDiscriminator()))

+		{

+			$mapping = $disc->getMapping();

+			$dataValue = $mapping->getDatabaseValue($row);

+			$subMap = $disc->getSubMap((string)$dataValue);

+		

+			if(is_null($subMap))

+				$subMap = $this;

+			else if($subMap !== $this)

+				$subMap = $subMap->resolveSubMap($row);

+		}

+		return $subMap;

+	}

+}

+

+?>
\ No newline at end of file
diff --git a/framework/DataAccess/SQLMap/Configuration/TResultProperty.php b/framework/DataAccess/SQLMap/Configuration/TResultProperty.php
new file mode 100644
index 00000000..9cc0df3a
--- /dev/null
+++ b/framework/DataAccess/SQLMap/Configuration/TResultProperty.php
@@ -0,0 +1,164 @@
+<?php

+

+class TResultProperty extends TComponent

+{

+	private $_nullValue=null;

+	private $_propertyName='';

+	private $_columnName='';

+	private $_columnIndex=-1;

+	private $_nestedResultMapName='';

+	private $_nestedResultMap=null;

+	private $_valueType=null;

+	private $_typeHandler=null;

+	private $_isLazyLoad=false;

+	private $_select='';

+	private $_dbType='';

+	private $_typeHandlerFactory;

+	private $_hostResultMapID='inplicit internal mapping';

+

+	const LIST_TYPE = 0;

+	const ARRAY_TYPE = 1;

+	const OBJECT_TYPE = 2;

+

+	public function getNullValue(){ return $this->_nullValue; }

+	public function setNullValue($value){ $this->_nullValue = $value; }

+

+	public function getProperty(){ return $this->_propertyName; }

+	public function setProperty($value){ $this->_propertyName = $value; }

+

+	public function getColumn(){ return $this->_columnName; }

+	public function setColumn($value){ $this->_columnName = $value; }

+

+	public function getColumnIndex(){ return $this->_columnIndex; }

+	public function setColumnIndex($value){ $this->_columnIndex = TPropertyValue::ensureInteger($value,-1); }

+

+	public function getResultMapping(){ return $this->_nestedResultMapName; }

+	public function setResultMapping($value){ $this->_nestedResultMapName = $value; }

+

+	public function getNestedResultMap(){ return $this->_nestedResultMap; }

+	public function setNestedResultMap($value){ $this->_nestedResultMap = $value; }

+

+	public function getType(){ return $this->_valueType; }

+	public function setType($value) { $this->_valueType = $value; }

+

+	public function getTypeHandler()

+	{ 

+		if(is_null($this->_typeHandlerFactory)) return null;

+		if(!is_null($this->_typeHandler))

+			return $this->_typeHandlerFactory->getTypeHandler($this->_typeHandler);

+		else if(!is_null($this->getType()))

+			return $this->_typeHandlerFactory->getTypeHandler($this->getType());

+		else

+			return null;

+	}

+	public function setTypeHandler($value) { $this->_typeHandler = $value; }

+

+	public function getSelect(){ return $this->_select; }

+	public function setSelect($value){ $this->_select = $value; }

+

+	public function getLazyLoad(){ return $this->_isLazyLoad; }

+	public function setLazyLoad($value){ $this->_isLazyLoad = TPropertyValue::ensureBoolean($value,false); }

+

+	public function getDbType(){ return $this->_dbType; }

+	public function setDbType($value){ $this->_dbType = $value; }

+

+	public function initialize($sqlMap, $resultMap=null)

+	{

+		$this->_typeHandlerFactory = $sqlMap->getTypeHandlerFactory();

+		if(!is_null($resultMap))

+			$this->_hostResultMapID = $resultMap->getID();

+//		$type = !is_null($this->_typeHandler) ? $this->_typeHandler: $this->_valueType;

+//		$this->setTypeHandler($sqlMap->getTypeHandlerFactory()->getTypeHandler($type));

+	}

+

+	public function getDatabaseValue($row,$forceType=true)

+	{

+		$value = null;

+		if($this->_columnIndex > 0 && isset($row[$this->_columnIndex]))

+			$value = $this->getTypedValue($row[$this->_columnIndex], $forceType);

+		else if(isset($row[$this->_columnName]))

+			$value = $this->getTypedValue($row[$this->_columnName],$forceType);

+		if(is_null($value) && !is_null($this->_nullValue))

+			$value = $this->getTypedValue($this->_nullValue,$forceType);

+		return $value;

+	}

+	

+	public function getOrdinalValue($row)

+	{

+		return $this->getDatabaseValue($row,false);

+	}

+

+	private function getTypedValue($value, $forceType=true)

+	{

+		if(!$forceType) return $value;

+		if(is_null($this->getTypeHandler()))

+		{

+			return TTypeHandlerFactory::convertToType($this->_valueType, $value);

+		}

+		else

+		{

+			try

+			{

+				return $this->getTypeHandler()->getResult($value);	

+			}

+			catch (Exception $e)

+			{

+				throw new TSqlMapExecutionException(

+					'sqlmap_error_in_result_property_from_handler',$this->_hostResultMapID,

+					$value, get_class($this->getTypeHandler()), $e->getMessage());

+			}

+		}

+	}

+

+

+	public function getPropertyType($type=null)

+	{

+		if(is_null($type))

+			$type = $this->getType();

+		if(class_exists($type, false)) //NO force autoloading

+		{

+			$class = new ReflectionClass($type);

+			if($class->isSubclassOf('TList'))

+				return self::LIST_TYPE;

+			if($class->inmplementsInterface('ArrayAccess'))

+				return self::ARRAY_TYPE;

+		}

+		if(strtolower($type) == 'array')

+			return self::ARRAY_TYPE;

+		return self::OBJECT_TYPE;

+	}

+

+	public function isListType($target)

+	{

+		if(is_null($this->getType()))

+		{

+			$prop = TPropertyAccess::get($target,$this->getProperty()); 

+			return  $prop instanceof TList;

+		}

+		return $this->getPropertyType() == self::LIST_TYPE;

+	}

+

+	public function isArrayType($target)

+	{

+		if(is_null($this->getType()))

+		{

+			$prop = TPropertyAccess::get($target,$this->getProperty());

+			if(is_object($prop))

+				return $prop instanceof ArrayAccess;

+			return is_array($prop);

+		}

+		return $this->getPropertyType() == self::ARRAY_TYPE;

+	}

+

+	public function isObjectType($target)

+	{

+		if(is_null($this->getType()))

+		{

+			$prop = TPropertyAccess::get($target,$this->getProperty());

+			return is_object($prop);

+		}

+		return $this->getPropertyType() == self::OBJECT_TYPE;

+	}

+}

+

+?>
\ No newline at end of file
diff --git a/framework/DataAccess/SQLMap/Configuration/TSqlMapCacheModel.php b/framework/DataAccess/SQLMap/Configuration/TSqlMapCacheModel.php
new file mode 100644
index 00000000..6c945155
--- /dev/null
+++ b/framework/DataAccess/SQLMap/Configuration/TSqlMapCacheModel.php
@@ -0,0 +1,131 @@
+<?php

+

+class TSqlMapCacheModel extends TComponent

+{

+	private $_cache;

+	private $_flushInterval = -1;

+	private $_hits = 0;

+	private $_requests = 0;

+	private $_id;

+	private $_lastFlush;

+	private $_implementation;

+	private $_properties = array();

+

+

+	public function getID(){ return $this->_id; }

+	public function setID($value){ $this->_id = $value; }

+

+	public function getImplementation(){ return $this->_implementation; }

+	public function setImplementation($value){ $this->_implementation = $value; }

+

+	public function getFlushInterval(){ return $this->_flushInterval; }

+	public function setFlushInterval($value){ $this->_flushInterval = $value; }

+

+	public function initialize($sqlMap)

+	{

+		$implementation = $this->getImplementationClass(

+				$sqlMap->getTypeHandlerFactory());

+		$this->_cache = new $implementation;

+		$this->_cache->configure($this->_properties);

+	}

+

+	protected function getImplementationClass($typeFactory)

+	{

+		switch(strtolower($this->_implementation))

+		{

+			case 'fifo': return 'TSqlMapFifoCache';

+			case 'lru' : return 'TSqlMapLruCache';

+		}

+

+		if(class_exists($this->_implementation, false))

+			$class = $this->_implementation;

+		else

+			$class  = $typeFactory->getTypeHandler($this->_implementation);

+		if(!is_null($class)) 

+			return $class;

+		else

+			throw new TSqlMapConfigurationException(

+				'sqlmap_unable_to_find_implemenation', $this->_implementation);

+	}

+

+	public function addProperty($name, $value)

+	{

+		$this->_properties[strtolower($name)] = $value;

+	}

+

+	public function registerTriggerStatement($mappedStatement)

+	{

+		$mappedStatement->attachEventHandler('OnExecuteQuery', 

+				array($this, 'flushHandler'));

+	}

+

+	protected function flushHandler($sender, $param)

+	{

+		$this->flush();

+	}

+

+	public function flush()

+	{

+		var_dump("flush!");

+		$this->_cache->flush();

+	}

+

+	public function get($key)

+	{

+		if($key instanceof TSqlMapCacheKey)

+			$key = $key->getHash();

+

+		//if flush ?

+		$value = $this->_cache->get($key);

+		$this->_requests++;

+		if(!is_null($value))

+			$this->_hits++;

+		return $value;

+	}

+

+	public function set($key, $value)

+	{

+		if($key instanceof TSqlMapCacheKey)

+			$key = $key->getHash();

+

+		if(!is_null($value))

+			$this->_cache->set($key, $value);

+	}

+

+	public function getHitRatio()

+	{

+		if($this->_requests != 0)

+			return $this->_hits / $this->_requests;

+		else

+			return 0;

+	}

+}

+

+

+class TSqlMapCacheKey

+{

+	private $_key;

+

+	public function __construct($object)

+	{

+		$this->_key = $this->generateKey(serialize($object));

+	}

+

+	protected function generateKey($string)

+	{

+		return sprintf('%x',crc32($string));

+	}

+

+	public function getHash()

+	{

+		return $this->_key;

+	}

+

+	public function __toString()

+	{

+		return $this->getHash();

+	}

+}

+

+

+?>
\ No newline at end of file
diff --git a/framework/DataAccess/SQLMap/Configuration/TSqlMapDelete.php b/framework/DataAccess/SQLMap/Configuration/TSqlMapDelete.php
new file mode 100644
index 00000000..9ca3843a
--- /dev/null
+++ b/framework/DataAccess/SQLMap/Configuration/TSqlMapDelete.php
@@ -0,0 +1,7 @@
+<?php

+

+class TSqlMapDelete extends TSqlMapUpdate

+{

+}

+

+?>
\ No newline at end of file
diff --git a/framework/DataAccess/SQLMap/Configuration/TSqlMapInsert.php b/framework/DataAccess/SQLMap/Configuration/TSqlMapInsert.php
new file mode 100644
index 00000000..c8d798c5
--- /dev/null
+++ b/framework/DataAccess/SQLMap/Configuration/TSqlMapInsert.php
@@ -0,0 +1,15 @@
+<?php

+

+class TSqlMapInsert extends TSqlMapStatement

+{

+	private $_selectKey=null;

+	private $_generate=null;

+

+	public function getSelectKey(){ return $this->_selectKey; }

+	public function setSelectKey($value){ $this->_selectKey = $value; }

+

+	public function getGenerate(){ return $this->_generate; }

+	public function setGenerate($value){ $this->_generate = $value; }

+}

+

+?>
\ No newline at end of file
diff --git a/framework/DataAccess/SQLMap/Configuration/TSqlMapSelect.php b/framework/DataAccess/SQLMap/Configuration/TSqlMapSelect.php
new file mode 100644
index 00000000..b33bc27e
--- /dev/null
+++ b/framework/DataAccess/SQLMap/Configuration/TSqlMapSelect.php
@@ -0,0 +1,11 @@
+<?php

+

+class TSqlMapSelect extends TSqlMapStatement

+{

+	private $_generate;

+

+	public function getGenerate(){ return $this->_generate; }

+	public function setGenerate($value){ $this->_generate = $value; }

+}

+

+?>
\ No newline at end of file
diff --git a/framework/DataAccess/SQLMap/Configuration/TSqlMapSelectKey.php b/framework/DataAccess/SQLMap/Configuration/TSqlMapSelectKey.php
new file mode 100644
index 00000000..b73d4ef0
--- /dev/null
+++ b/framework/DataAccess/SQLMap/Configuration/TSqlMapSelectKey.php
@@ -0,0 +1,26 @@
+<?php

+

+class TSqlMapSelectKey extends TSqlMapStatement

+{

+	private $_type = 'post';

+	private $_property = '';

+

+	public function getType(){ return $this->_type; }

+	public function setType($value){ $this->_type = $value; }

+

+	public function getProperty(){ return $this->_property; }

+	public function setProperty($value){ $this->_property = $value; }

+

+	public function setExtends($value)

+	{

+		throw new TSqlMapConfigurationException(

+				'sqlmap_can_not_extend_select_key');

+	}

+

+	public function getIsAfter()

+	{

+		return $this->_type == 'post';

+	}

+}

+

+?>
\ No newline at end of file
diff --git a/framework/DataAccess/SQLMap/Configuration/TSqlMapStatement.php b/framework/DataAccess/SQLMap/Configuration/TSqlMapStatement.php
new file mode 100644
index 00000000..228b37d6
--- /dev/null
+++ b/framework/DataAccess/SQLMap/Configuration/TSqlMapStatement.php
@@ -0,0 +1,109 @@
+<?php

+

+class TSqlMapStatement extends TComponent

+{

+	private $_ID='';

+	private $_parameterMapName='';

+	private $_parameterMap;

+	private $_parameterClassName='';

+//	private $_parameterClass;

+	private $_resultMapName='';

+	private $_resultMap;

+	private $_resultClassName='';

+//	private $_resultClass;

+	private $_cacheModelName='';

+	private $_remapResults=false;

+	private $_SQL='';

+	private $_listClass='';

+	private $_typeHandler;

+	private $_extendStatement='';

+	private $_cache;

+

+	public function getID(){ return $this->_ID; }

+	public function setID($value){ $this->_ID = $value; }

+

+	public function getParameterMap(){ return $this->_parameterMapName; }

+	public function setParameterMap($value){ $this->_parameterMapName = $value; }

+

+	public function getParameterClass(){ return $this->_parameterClassName; }

+	public function setParameterClass($value){ $this->_parameterClassName = $value; }

+

+	public function getResultMap(){ return $this->_resultMapName; }

+	public function setResultMap($value){ $this->_resultMapName = $value; }

+

+	public function getResultClass(){ return $this->_resultClassName; }

+	public function setResultClass($value){ $this->_resultClassName = $value; }

+

+	public function getCacheModel(){ return $this->_cacheModelName; }

+	public function setCacheModel($value){ $this->_cacheModelName = $value; }

+

+	public function getCache(){ return $this->_cache; }

+	public function setCache($value){ $this->_cache = $value; }

+

+	public function getRemapResults(){ return $this->_remapResults; }

+	public function setRemapResults($value){ $this->_remapResults = TPropertyValue::ensureBoolean($value,false); }

+

+	public function getSQL(){ return $this->_SQL; }

+	public function setSQL($value){ $this->_SQL = $value; }

+

+	public function getListClass(){ return $this->_listClass; }

+	public function setListClass($value){ $this->_listClass = $value; }

+

+	public function getExtends(){ return $this->_extendStatement; }

+	public function setExtends($value){ $this->_extendStatement = $value; }

+	

+	public function resultMap(){ return $this->_resultMap; }

+	public function parameterMap(){ return $this->_parameterMap; }

+

+	public function setInlineParameterMap($map)

+	{

+		$this->_parameterMap = $map;

+	}

+//	public function parameterClass(){ return $this->_parameterClass; }

+//	public function resultClass(){ return $this->_resultClass; }

+

+	public function initialize($sqlMap)

+	{

+		$this->_typeHandler = $sqlMap->getTypeHandlerFactory();

+		if(strlen($this->_resultMapName) > 0)

+			$this->_resultMap = $sqlMap->getResultMap($this->_resultMapName);

+		if(strlen($this->_parameterMapName) > 0)

+			$this->_parameterMap = $sqlMap->getParameterMap($this->_parameterMapName);

+	}

+

+

+	public function createInstanceOfListClass()

+	{

+		if(strlen($type = $this->getListClass()) > 0)

+			return $this->createInstanceOf($type);

+		return array(); //new TList;

+	}

+

+	protected function createInstanceOf($type)

+	{

+		$handler = $this->_typeHandler->getTypeHandler($type);

+		

+		try

+		{

+			if(!is_null($handler))

+					return $handler->createNewInstance();		

+			else

+				return TTypeHandlerFactory::createInstanceOf($type);

+		}

+		catch (TDataMapperException $e)

+		{

+			throw new TSqlMapExecutionException(

+				'sqlmap_unable_to_create_new_instance', 

+					$type, get_class($handler), $this->getID());

+		}

+					

+	}

+

+	public function createInstanceOfResultClass()

+	{

+		if(strlen($type= $this->getResultClass()) > 0)

+			return $this->createInstanceOf($type);

+	}

+}

+

+?>
\ No newline at end of file
diff --git a/framework/DataAccess/SQLMap/Configuration/TSqlMapUpdate.php b/framework/DataAccess/SQLMap/Configuration/TSqlMapUpdate.php
new file mode 100644
index 00000000..26d00e39
--- /dev/null
+++ b/framework/DataAccess/SQLMap/Configuration/TSqlMapUpdate.php
@@ -0,0 +1,11 @@
+<?php

+

+class TSqlMapUpdate extends TSqlMapStatement

+{

+	private $_generate;

+

+	public function getGenerate(){ return $this->_generate; }

+	public function setGenerate($value){ $this->_generate = $value; }

+}

+

+?>
\ No newline at end of file