RetailCRM-Mirror/doctrine2
1
0
Fork 0
mirror of synced 2025-01-20 15:31:40 +03:00
Code Issues Projects Releases Wiki Activity

new DQL Hydration algorithm !

Browse Source
This commit is contained in:
zYne 2007-05-31 17:45:07 +00:00
parent 881788f372
commit d4c12c357d
8 changed files with 176 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

336
lib/Doctrine/Hydrate.php
View File

@ -581,7 +581,11 @@ class Doctrine_Hydrate implements Serializable
if (isset($this->_aliasMap[$alias]['agg'][$index])) { if (isset($this->_aliasMap[$alias]['agg'][$index])) {
$agg = $this->_aliasMap[$alias]['agg'][$index]; $agg = $this->_aliasMap[$alias]['agg'][$index];
} }
if (is_array($record)) {
$record[$agg] = $value;
} else {
$record->mapValue($agg, $value); $record->mapValue($agg, $value);
}
$found = true; $found = true;
} }
} }
@ -647,7 +651,7 @@ class Doctrine_Hydrate implements Serializable
if ($cached === null) { if ($cached === null) {
// cache miss // cache miss
$stmt = $this->_execute($params, $return); $stmt = $this->_execute($params, $return);
$array = $this->parseData($stmt); $array = $this->parseData2($stmt);
$cached = $this->getCachedForm($array); $cached = $this->getCachedForm($array);
@ -675,150 +679,12 @@ class Doctrine_Hydrate implements Serializable
} }
} else { } else {
$stmt = $this->_execute($params, $return); $stmt = $this->_execute($params, $return);
if ($return === Doctrine::FETCH_ARRAY) {
return $this->parseData2($stmt); $array = $this->parseData2($stmt, $return);
} else {
$array = $this->parseData($stmt);
} }
return $array;
} }
if (empty($this->_aliasMap)) {
throw new Doctrine_Hydrate_Exception("Couldn't execute query. Component alias map was empty.");
}
// initialize some variables used within the main loop
reset($this->_aliasMap);
$rootMap = current($this->_aliasMap);
$rootAlias = key($this->_aliasMap);
$coll = new Doctrine_Collection($rootMap['table']);
$prev[$rootAlias] = $coll;
// we keep track of all the collections
$colls = array();
$colls[] = $coll;
$prevRow = array();
/**
* iterate over the fetched data
* here $data is a two dimensional array
*/
foreach ($array as $data) {
/**
* remove duplicated data rows and map data into objects
*/
foreach ($data as $tableAlias => $row) {
// skip empty rows (not mappable)
if (empty($row)) {
continue;
}
$alias = $this->getComponentAlias($tableAlias);
$map = $this->_aliasMap[$alias];
// initialize previous row array if not set
if ( ! isset($prevRow[$tableAlias])) {
$prevRow[$tableAlias] = array();
}
// don't map duplicate rows
if ($prevRow[$tableAlias] !== $row) {
$identifiable = $this->isIdentifiable($row, $map['table']->getIdentifier());
if ($identifiable) {
// set internal data
$map['table']->setData($row);
}
// initialize a new record
$record = $map['table']->getRecord();
// map aggregate values (if any)
if($this->mapAggregateValues($record, $row, $alias)) {
$identifiable = true;
}
if ($alias == $rootAlias) {
// add record into root collection
if ($identifiable) {
$coll->add($record);
unset($prevRow);
}
} else {
$relation = $map['relation'];
$parentAlias = $map['parent'];
$parentMap = $this->_aliasMap[$parentAlias];
$parent = $prev[$parentAlias]->getLast();
// check the type of the relation
if ($relation->isOneToOne()) {
if ( ! $identifiable) {
continue;
}
$prev[$alias] = $record;
} else {
// one-to-many relation or many-to-many relation
if ( ! $prev[$parentAlias]->getLast()->hasReference($relation->getAlias())) {
// initialize a new collection
$prev[$alias] = new Doctrine_Collection($map['table']);
$prev[$alias]->setReference($parent, $relation);
} else {
// previous entry found from memory
$prev[$alias] = $prev[$parentAlias]->getLast()->get($relation->getAlias());
}
$colls[] = $prev[$alias];
// add record to the current collection
if ($identifiable) {
$prev[$alias]->add($record);
}
}
// initialize the relation from parent to the current collection/record
$parent->set($relation->getAlias(), $prev[$alias]);
}
// following statement is needed to ensure that mappings
// are being done properly when the result set doesn't
// contain the rows in 'right order'
if ($prev[$alias] !== $record) {
$prev[$alias] = $record;
}
}
$prevRow[$tableAlias] = $row;
}
}
// take snapshots from all initialized collections
foreach(array_unique($colls) as $c) {
$c->takeSnapshot();
}
return $coll;
}
/**
* isIdentifiable
* returns whether or not a given data row is identifiable (it contains
* all primary key fields specified in the second argument)
*
* @param array $row
* @param mixed $primaryKeys
* @return boolean
*/
public function isIdentifiable(array $row, $primaryKeys)
{
if (is_array($primaryKeys)) {
foreach ($primaryKeys as $id) {
if ($row[$id] == null) {
return false;
}
}
} else {
if ( ! isset($row[$primaryKeys])) {
return false;
}
}
return true;
}
/** /**
* getType * getType
* *
@ -901,19 +767,28 @@ class Doctrine_Hydrate implements Serializable
* @param mixed $stmt * @param mixed $stmt
* @return array * @return array
*/ */
public function parseData2($stmt) public function parseData2($stmt, $return)
{ {
$array = array();
$cache = array(); $cache = array();
$rootMap = reset($this->_aliasMap); $rootMap = reset($this->_aliasMap);
$rootAlias = key($this->_aliasMap); $rootAlias = key($this->_aliasMap);
$componentName = $rootMap['table']->getComponentName();
$index = 0; $index = 0;
$incr = true; $incr = true;
$lastAlias = ''; $lastAlias = '';
$currData = array(); $currData = array();
if ($return === Doctrine::FETCH_ARRAY) {
$driver = new Doctrine_Hydrate_Array();
} else {
$driver = new Doctrine_Hydrate_Record();
}
$array = $driver->getElementCollection($componentName);
while ($data = $stmt->fetch(PDO::FETCH_ASSOC)) { while ($data = $stmt->fetch(PDO::FETCH_ASSOC)) {
$parse = true;
foreach ($data as $key => $value) { foreach ($data as $key => $value) {
if ( ! isset($cache[$key])) { if ( ! isset($cache[$key])) {
$e = explode('__', $key); $e = explode('__', $key);
@ -934,38 +809,120 @@ class Doctrine_Hydrate implements Serializable
$tmp = array(); $tmp = array();
$alias = $cache[$key]['alias']; $alias = $cache[$key]['alias'];
$component = $cache[$key]['component']; $component = $cache[$key]['component'];
$componentName = $this->_aliasMap[$cache[$key]['alias']]['table']->getComponentName();
$table = $this->_aliasMap[$cache[$key]['alias']]['table'];
if ( ! isset($currData[$alias])) { if ( ! isset($currData[$alias])) {
$currData[$alias] = array(); $currData[$alias] = array();
} }
if ( ! isset($prevData[$alias])) {
$prevData[$alias] = array();
}
if ( ! isset($prevElement[$alias])) {
$prevElement[$alias] = array();
}
if ( ! isset($prev[$alias])) { if ( ! isset($prev[$alias])) {
$prev[$alias] = array(); $prev[$alias] = array();
} }
if ($lastAlias !== $alias) { if ($alias !== $lastAlias || $parse) {
// component changed
// component changed
$identifiable = $driver->isIdentifiable($currData[$alias], $table);
$element = $driver->getElement($currData[$alias], $componentName);
// map aggregate values (if any)
if ($this->mapAggregateValues($element, $currData[$alias], $alias)) {
$identifiable = true;
}
if ($currData[$alias] !== $prevData[$alias] || $element !== $prevElement[$alias]) {
if ($identifiable) {
if ($alias === $rootAlias) { if ($alias === $rootAlias) {
// dealing with root component // dealing with root component
if ( ! isset($prevData[$alias]) || $currData[$alias] !== $prevData[$alias]) { $array[$index] = $element;
if ( ! empty($currData[$alias])) {
$array[$index] = $currData[$alias];
$prev[$alias] =& $array[$index]; $prev[$alias] =& $array[$index];
$index++; $index++;
}
}
} else { } else {
$parent = $cache[$key]['parent']; $parent = $cache[$key]['parent'];
$relation = $this->_aliasMap[$cache[$key]['alias']]['relation']; $relation = $this->_aliasMap[$cache[$key]['alias']]['relation'];
// check the type of the relation
if ( ! $relation->isOneToOne()) {
if ($prev[$parent][$component] instanceof Doctrine_Record) {
throw new Exception();
}
$prev[$parent][$component][] = $element;
if ( ! isset($prevData[$alias]) || $currData[$alias] !== $prevData[$alias]) { $driver->registerCollection($prev[$parent][$component]);
if ($relation->getType() >= Doctrine_Relation::MANY) {
$prev[$parent][$component][] = $currData[$alias];
} else { } else {
$prev[$parent][$component] = $currData[$alias]; $prev[$parent][$component] = $element;
}
if (is_array($prev[$parent][$component])) {
$prev[$alias] = end($prev[$parent][$component]);
} else {
$prev[$alias] = $prev[$parent][$component]->getLast();
}
}
if (isset($currData[$alias])) {
$prevData[$alias] = $currData[$alias];
} else {
$prevData[$alias] = array();
}
$currData[$alias] = array();
$prevElement[$alias] = $element;
}
}
}
$field = $cache[$key]['field'];
$currData[$alias][$field] = $value;
//print_r($currData[$alias]);
$lastAlias = $alias;
$parse = false;
}
}
foreach ($currData as $alias => $data) {
$componentName = $this->_aliasMap[$alias]['table']->getComponentName();
// component changed
$identifiable = $driver->isIdentifiable($currData[$alias], $table);
$element = $driver->getElement($currData[$alias], $componentName, $identifiable);
// map aggregate values (if any)
if($this->mapAggregateValues($element, $currData[$alias], $alias)) {
$identifiable = true;
}
if ( ! isset($prevData[$alias]) || (isset($currData[$alias]) && $currData[$alias] !== $prevData[$alias]) || $element !== $prevElement[$alias]) {
if ($identifiable) {
if ($alias === $rootAlias) {
// dealing with root component
$array[$index] = $element;
$prev[$alias] =& $array[$index];
$index++;
} else {
$parent = $this->_aliasMap[$alias]['parent'];
$relation = $this->_aliasMap[$alias]['relation'];
$componentAlias = $relation->getAlias();
// check the type of the relation
if ( ! $relation->isOneToOne()) {
$prev[$parent][$componentAlias][] = $element;
$driver->registerCollection($prev[$parent][$componentAlias]);
} else {
$prev[$parent][$componentAlias] = $element;
}
} }
} }
} }
@ -974,75 +931,14 @@ class Doctrine_Hydrate implements Serializable
} else { } else {
$prevData[$alias] = array(); $prevData[$alias] = array();
} }
$currData[$alias] = array();
} else { $prevElement[$alias] = $element;
$field = $cache[$key]['field'];
$currData[$alias][$field] = $value;
}
$lastAlias = $alias;
}
}
foreach ($currData as $alias => $data) {
if ($alias === $rootAlias) {
// dealing with root component
if ( ! isset($prevData[$alias]) || $currData[$alias] !== $prevData[$alias]) {
if ( ! empty($currData[$alias])) {
$array[$index] = $currData[$alias];
$prev[$alias] =& $array[$index];
$index++;
}
}
} else {
$parent = $cache[$key]['parent'];
$relation = $this->_aliasMap[$cache[$key]['alias']]['relation'];
if ( ! isset($prevData[$alias]) || $currData[$alias] !== $prevData[$alias]) {
if ($relation->getType() >= Doctrine_Relation::MANY) {
$prev[$parent][$component][] = $currData[$alias];
} else {
$prev[$parent][$component] = $currData[$alias];
}
}
}
} }
$driver->flush();
$stmt->closeCursor(); $stmt->closeCursor();
unset($cache);
return $array;
}
/**
* parseData
* parses the data returned by statement object
*
* @param mixed $stmt
* @return array
*/
public function parseData($stmt)
{
$array = array();
$cache = array();
while ($data = $stmt->fetch(PDO::FETCH_ASSOC)) {
foreach ($data as $key => $value) {
if ( ! isset($cache[$key])) {
$e = explode('__', $key);
$cache[$key]['field'] = strtolower(array_pop($e));
$cache[$key]['component'] = strtolower(implode('__', $e));
}
$data[$cache[$key]['component']][$cache[$key]['field']] = $value;
unset($data[$key]);
}
$array[] = $data;
}
$stmt->closeCursor();
return $array; return $array;
} }
/** /**

2
lib/Doctrine/Hydrate/Array.php
View File

@ -43,7 +43,7 @@ class Doctrine_Hydrate_Array
} }
public function isIdentifiable(array $data, Doctrine_Table $table) public function isIdentifiable(array $data, Doctrine_Table $table)
{ {
return true; return (! empty($data));
} }
public function registerCollection($coll) public function registerCollection($coll)
{ {

8
lib/Doctrine/Hydrate/Record.php
View File

@ -46,7 +46,7 @@ class Doctrine_Hydrate_Record
return $coll; return $coll;
} }
public function registerCollection($coll) public function registerCollection(Doctrine_Collection $coll)
{ {
$this->_collections[] = $coll; $this->_collections[] = $coll;
} }
@ -76,19 +76,17 @@ class Doctrine_Hydrate_Record
} }
return true; return true;
} }
public function getElement(array $data, $component) public function getElement(array $data, $component)
{ {
if ( ! isset($this->_tables[$component])) { if ( ! isset($this->_tables[$component])) {
$this->_tables[$component] = Doctrine_Manager::getInstance()->getTable($component); $this->_tables[$component] = Doctrine_Manager::getInstance()->getTable($component);
$this->_tables[$component]->setAttribute(Doctrine::ATTR_LOAD_REFERENCES, false);
} }
$this->_tables[$component]->setData($data); $this->_tables[$component]->setData($data);
$record = $this->_tables[$component]->getRecord(); $record = $this->_tables[$component]->getRecord();
$this->_records[] = $record; $this->_records[] = $record;
$this->_tables[$component]->setAttribute(Doctrine::ATTR_LOAD_REFERENCES, false);
return $record; return $record;
} }
public function flush() public function flush()

1
lib/Doctrine/Query.php
View File

@ -234,6 +234,7 @@ class Doctrine_Query extends Doctrine_Query_Abstract implements Countable
*/ */
public function parseQueryPart($queryPartName, $queryPart, $append = false) public function parseQueryPart($queryPartName, $queryPart, $append = false)
{ {
// sanity check // sanity check
if ($queryPart === '' || $queryPart === null) { if ($queryPart === '' || $queryPart === null) {
throw new Doctrine_Query_Exception('Empty ' . $queryPartName . ' part given.'); throw new Doctrine_Query_Exception('Empty ' . $queryPartName . ' part given.');

13
lib/Doctrine/Query/Abstract.php
View File

@ -288,4 +288,17 @@ abstract class Doctrine_Query_Abstract extends Doctrine_Hydrate
{ {
return $this->parseQueryPart('offset', $offset); return $this->parseQueryPart('offset', $offset);
} }
/**
* parseQueryPart
* parses given DQL query part
*
* @param string $queryPartName the name of the query part
* @param string $queryPart query part to be parsed
* @param boolean $append whether or not to append the query part to its stack
* if false is given, this method will overwrite
* the given query part stack with $queryPart
* @return Doctrine_Query this object
*/
abstract public function parseQueryPart($queryPartName, $queryPart, $append = false);
} }

9
lib/Doctrine/Record.php
View File

@ -229,6 +229,15 @@ abstract class Doctrine_Record extends Doctrine_Access implements Countable, Ite
{ {
return self::$_null; return self::$_null;
} }
/**
* _index
*
* @return integer
*/
public static function _index()
{
return self::$_index;
}
/** /**
* setUp * setUp
* this method is used for setting up relations and attributes * this method is used for setting up relations and attributes

15
lib/Doctrine/Table.php
View File

@ -857,13 +857,26 @@ class Doctrine_Table extends Doctrine_Configurable implements Countable
$key = array($key); $key = array($key);
} }
$found = false;
foreach ($key as $k) { foreach ($key as $k) {
if ( ! isset($this->data[$k])) { if ( ! isset($this->data[$k])) {
throw new Doctrine_Table_Exception("Primary key value for $k wasn't found"); // primary key column not found return new record
$found = true;
break;
} }
$id[] = $this->data[$k]; $id[] = $this->data[$k];
} }
if ($found) {
$this->data = array();
$recordName = $this->getClassnameToReturn();
$record = new $recordName($this, true);
return $record;
}
$id = implode(' ', $id); $id = implode(' ', $id);
if (isset($this->identityMap[$id])) { if (isset($this->identityMap[$id])) {