1
0
mirror of synced 2024-12-14 15:16:04 +03:00
doctrine2/lib/Doctrine/Hydrate.php

621 lines
18 KiB
PHP
Raw Normal View History

2006-07-22 03:22:15 +04:00
<?php
2006-08-07 00:46:12 +04:00
/*
* $Id$
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see
* <http://www.phpdoctrine.com>.
*/
Doctrine::autoload('Doctrine_Access');
2006-08-07 00:46:12 +04:00
/**
* Doctrine_Hydrate is a base class for Doctrine_RawSql and Doctrine_Query.
* Its purpose is to populate object graphs.
*
*
* @package Doctrine ORM
* @url www.phpdoctrine.com
* @license LGPL
*/
2006-08-08 01:07:29 +04:00
abstract class Doctrine_Hydrate extends Doctrine_Access {
2006-07-22 03:22:15 +04:00
/**
* @var array $fetchmodes an array containing all fetchmodes
2006-07-22 03:22:15 +04:00
*/
protected $fetchModes = array();
/**
* @var array $tables an array containing all the tables used in the query
2006-07-22 03:22:15 +04:00
*/
protected $tables = array();
/**
* @var array $collections an array containing all collections
* this hydrater has created/will create
2006-07-22 03:22:15 +04:00
*/
protected $collections = array();
/**
* @var array $joins an array containing all table joins
2006-07-22 03:22:15 +04:00
*/
protected $joins = array();
/**
* @var array $data fetched data
2006-07-22 03:22:15 +04:00
*/
protected $data = array();
/**
* @var array $params query input parameters
*/
2006-10-01 20:14:26 +04:00
protected $params = array();
2006-07-22 03:22:15 +04:00
/**
* @var Doctrine_Connection $connection Doctrine_Connection object
2006-07-22 03:22:15 +04:00
*/
2006-08-22 03:19:15 +04:00
protected $connection;
2006-07-22 03:22:15 +04:00
/**
* @var Doctrine_View $view Doctrine_View object
2006-07-22 03:22:15 +04:00
*/
protected $view;
/**
* @var boolean $inheritanceApplied
*/
2006-07-22 03:22:15 +04:00
protected $inheritanceApplied = false;
/**
* @var boolean $aggregate
*/
2006-07-22 03:22:15 +04:00
protected $aggregate = false;
/**
* @var array $compAliases
*/
protected $compAliases = array();
2006-07-22 03:22:15 +04:00
/**
* @var array $tableAliases
*/
protected $tableAliases = array();
/**
* @var array $tableIndexes
*/
protected $tableIndexes = array();
2006-10-17 21:21:21 +04:00
protected $components = array();
protected $pendingAggregates = array();
protected $aggregateMap = array();
2006-07-22 03:22:15 +04:00
/**
* @var array $parts SQL query string parts
*/
protected $parts = array(
"select" => array(),
"from" => array(),
"join" => array(),
"where" => array(),
"groupby" => array(),
"having" => array(),
"orderby" => array(),
"limit" => false,
"offset" => false,
);
/**
* constructor
*
* @param Doctrine_Connection|null $connection
2006-07-22 03:22:15 +04:00
*/
public function __construct($connection = null) {
2006-08-22 03:19:15 +04:00
if( ! ($connection instanceof Doctrine_Connection))
$connection = Doctrine_Manager::getInstance()->getCurrentConnection();
2006-08-22 03:19:15 +04:00
$this->connection = $connection;
2006-07-22 03:22:15 +04:00
}
/**
* getComponentAliases
*
* @return array
*/
public function getComponentAliases() {
return $this->compAliases;
}
/**
* getTableAliases
*
* @return array
*/
public function getTableAliases() {
return $this->tableAliases;
}
/**
* getTableIndexes
*
* @return array
*/
public function getTableIndexes() {
return $this->tableIndexes;
}
/**
* copyAliases
*
* @return void
*/
public function copyAliases(Doctrine_Hydrate $query) {
$this->compAliases = $query->getComponentAliases();
$this->tableAliases = $query->getTableAliases();
$this->tableIndexes = $query->getTableIndexes();
return $this;
}
2006-10-17 21:21:21 +04:00
public function getPathAlias($path) {
$s = array_search($path, $this->compAliases);
if($s === false)
return $path;
return $s;
}
/**
* createSubquery
*
* @return Doctrine_Hydrate
*/
public function createSubquery() {
$class = get_class($this);
$obj = new $class();
// copy the aliases to the subquery
$obj->copyAliases($this);
return $obj;
}
/**
2006-08-08 01:07:29 +04:00
* getQuery
*
* @return string
*/
abstract public function getQuery();
/**
* limitSubqueryUsed
2006-09-08 01:25:08 +04:00
*
* @return boolean
*/
public function isLimitSubqueryUsed() {
return false;
}
/**
* remove
*
* @param $name
*/
public function remove($name) {
if(isset($this->parts[$name])) {
if($name == "limit" || $name == "offset")
$this->parts[$name] = false;
else
$this->parts[$name] = array();
}
return $this;
}
2006-07-22 03:22:15 +04:00
/**
* clear
* resets all the variables
*
* @return void
*/
protected function clear() {
$this->fetchModes = array();
$this->tables = array();
$this->parts = array(
"select" => array(),
"from" => array(),
"join" => array(),
"where" => array(),
"groupby" => array(),
"having" => array(),
"orderby" => array(),
"limit" => false,
"offset" => false,
);
$this->inheritanceApplied = false;
$this->aggregate = false;
$this->data = array();
$this->collections = array();
$this->joins = array();
$this->tableIndexes = array();
$this->tableAliases = array();
}
/**
2006-09-08 01:25:08 +04:00
* getConnection
*
2006-08-22 03:19:15 +04:00
* @return Doctrine_Connection
2006-07-22 03:22:15 +04:00
*/
2006-08-22 03:19:15 +04:00
public function getConnection() {
return $this->connection;
2006-07-22 03:22:15 +04:00
}
/**
* setView
* sets a database view this query object uses
* this method should only be called internally by doctrine
*
* @param Doctrine_View $view database view
* @return void
*/
public function setView(Doctrine_View $view) {
$this->view = $view;
}
/**
* getView
*
* @return Doctrine_View
*/
public function getView() {
return $this->view;
}
/**
* getTableAlias
*
* @param string $path
* @return string
*/
final public function getTableAlias($path) {
2006-10-10 22:09:20 +04:00
if(isset($this->compAliases[$path]))
$path = $this->compAliases[$path];
2006-07-22 03:22:15 +04:00
if( ! isset($this->tableAliases[$path]))
return false;
return $this->tableAliases[$path];
}
/**
* getCollection
*
* @parma string $name component name
* @param integer $index
*/
private function getCollection($name) {
$table = $this->tables[$name];
2006-10-17 21:21:21 +04:00
if( ! isset($this->fetchModes[$name]))
return new Doctrine_Collection($table);
2006-07-22 03:22:15 +04:00
switch($this->fetchModes[$name]):
case Doctrine::FETCH_BATCH:
$coll = new Doctrine_Collection_Batch($table);
break;
case Doctrine::FETCH_LAZY:
$coll = new Doctrine_Collection_Lazy($table);
break;
case Doctrine::FETCH_OFFSET:
$coll = new Doctrine_Collection_Offset($table);
break;
case Doctrine::FETCH_IMMEDIATE:
$coll = new Doctrine_Collection_Immediate($table);
break;
case Doctrine::FETCH_LAZY_OFFSET:
$coll = new Doctrine_Collection_LazyOffset($table);
break;
default:
throw new Doctrine_Exception("Unknown fetchmode");
endswitch;
return $coll;
}
/**
* convertBoolean
* converts boolean to integers
*
* @param mixed $item
* @return void
*/
public static function convertBoolean(&$item) {
if(is_bool($item))
$item = (int) $item;
}
2006-07-22 03:22:15 +04:00
/**
* execute
* executes the dql query and populates all collections
*
* @param string $params
* @return Doctrine_Collection the root collection
*/
public function execute($params = array(), $return = Doctrine::FETCH_RECORD) {
2006-07-22 03:22:15 +04:00
$this->collections = array();
2006-10-01 20:14:26 +04:00
$params = array_merge($this->params, $params);
array_walk($params, array(__CLASS__, 'convertBoolean'));
2006-07-22 03:22:15 +04:00
if( ! $this->view)
$query = $this->getQuery(true);
2006-07-22 03:22:15 +04:00
else
$query = $this->view->getSelectSql();
if($this->isLimitSubqueryUsed() &&
$this->connection->getDBH()->getAttribute(PDO::ATTR_DRIVER_NAME) !== 'mysql')
$params = array_merge($params, $params);
$stmt = $this->connection->execute($query, $params);
2006-09-08 01:25:08 +04:00
2006-10-14 20:58:59 +04:00
if($this->aggregate)
return $stmt->fetchAll(PDO::FETCH_ASSOC);
2006-10-01 19:18:04 +04:00
if(count($this->tables) == 0)
2006-10-14 20:58:59 +04:00
throw new Doctrine_Query_Exception("No components selected");
2006-08-22 23:34:40 +04:00
2006-10-01 19:18:04 +04:00
$keys = array_keys($this->tables);
$root = $keys[0];
2006-10-01 18:57:27 +04:00
2006-10-01 19:18:04 +04:00
$previd = array();
2006-07-22 03:22:15 +04:00
2006-10-01 19:18:04 +04:00
$coll = $this->getCollection($root);
$prev[$root] = $coll;
2006-07-22 03:22:15 +04:00
2006-10-01 19:18:04 +04:00
if($this->aggregate)
$return = Doctrine::FETCH_ARRAY;
2006-09-08 01:25:08 +04:00
2006-10-01 19:18:04 +04:00
$array = $this->parseData($stmt);
2006-07-22 03:22:15 +04:00
2006-10-01 19:18:04 +04:00
if($return == Doctrine::FETCH_ARRAY)
return $array;
2006-08-22 23:34:40 +04:00
2006-08-08 01:07:29 +04:00
2006-10-01 19:18:04 +04:00
foreach($array as $data) {
/**
* remove duplicated data rows and map data into objects
*/
foreach($data as $key => $row) {
if(empty($row))
continue;
2006-07-22 03:22:15 +04:00
2006-10-24 21:24:58 +04:00
foreach($this->tables as $k => $t) {
if ( ! strcasecmp($key, $k))
$key = $k;
}
if ( !isset($this->tables[$key]) )
throw new Doctrine_Exception("No table named $key found.");
2006-10-17 21:21:21 +04:00
2006-10-01 19:18:04 +04:00
$ids = $this->tables[$key]->getIdentifier();
$name = $key;
2006-07-22 03:22:15 +04:00
2006-10-01 19:18:04 +04:00
if($this->isIdentifiable($row, $ids)) {
2006-07-22 03:22:15 +04:00
2006-10-01 19:18:04 +04:00
$prev = $this->initRelated($prev, $name);
2006-10-17 21:21:21 +04:00
// aggregate values have numeric keys
2006-10-18 01:18:57 +04:00
2006-10-17 21:21:21 +04:00
if(isset($row[0])) {
$path = array_search($name, $this->tableAliases);
$alias = $this->getPathAlias($path);
2006-10-18 01:18:57 +04:00
//print_r($this->pendingAggregates);
2006-10-27 01:32:52 +04:00
// map each aggregate value
2006-10-17 21:21:21 +04:00
foreach($row as $index => $value) {
$agg = false;
if(isset($this->pendingAggregates[$alias][$index]))
$agg = $this->pendingAggregates[$alias][$index][0];
$prev[$name]->setAggregateValue($agg, $value);
}
}
2006-10-01 19:18:04 +04:00
continue;
}
2006-07-22 03:22:15 +04:00
2006-10-01 19:18:04 +04:00
if( ! isset($previd[$name]))
2006-07-22 03:22:15 +04:00
$previd[$name] = array();
2006-10-01 19:18:04 +04:00
if($previd[$name] !== $row) {
// set internal data
2006-10-01 19:18:04 +04:00
$this->tables[$name]->setData($row);
2006-09-23 21:02:30 +04:00
2006-10-01 19:18:04 +04:00
// initialize a new record
$record = $this->tables[$name]->getRecord();
2006-07-22 03:22:15 +04:00
2006-10-01 18:57:27 +04:00
2006-10-01 19:18:04 +04:00
if($name == $root) {
2006-10-01 19:18:04 +04:00
// add record into root collection
$coll->add($record);
unset($previd);
2006-07-22 03:22:15 +04:00
2006-10-01 19:18:04 +04:00
} else {
2006-10-17 21:21:21 +04:00
$prev = $this->addRelated($prev, $name, $record);
2006-07-22 03:22:15 +04:00
}
2006-10-01 19:18:04 +04:00
// 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[$name] !== $record)
$prev[$name] = $record;
2006-07-22 03:22:15 +04:00
}
2006-10-01 19:18:04 +04:00
$previd[$name] = $row;
}
}
return $coll;
2006-07-22 03:22:15 +04:00
}
2006-10-01 18:57:27 +04:00
/**
* initRelation
*
* @param array $prev
* @param string $name
* @return array
*/
public function initRelated(array $prev, $name) {
$pointer = $this->joins[$name];
$path = array_search($name, $this->tableAliases);
$tmp = explode(".", $path);
$alias = end($tmp);
if( ! isset($prev[$pointer]) )
return $prev;
2006-10-13 01:07:15 +04:00
$fk = $this->tables[$pointer]->getRelation($alias);
2006-10-01 18:57:27 +04:00
if( ! $fk->isOneToOne()) {
if($prev[$pointer]->getLast() instanceof Doctrine_Record) {
if( ! $prev[$pointer]->getLast()->hasReference($alias)) {
$prev[$name] = $this->getCollection($name);
$prev[$pointer]->getLast()->initReference($prev[$name],$fk);
2006-10-18 01:18:57 +04:00
} else
$prev[$name] = $prev[$pointer]->getLast()->get($alias);
2006-10-01 18:57:27 +04:00
}
}
return $prev;
}
/**
* addRelated
*
* @param array $prev
* @param string $name
* @return array
*/
public function addRelated(array $prev, $name, Doctrine_Record $record) {
$pointer = $this->joins[$name];
2006-10-01 18:57:27 +04:00
$path = array_search($name, $this->tableAliases);
$tmp = explode(".", $path);
$alias = end($tmp);
$fk = $this->tables[$pointer]->getRelation($alias);
if($fk->isOneToOne()) {
$prev[$pointer]->getLast()->set($fk->getAlias(), $record);
$prev[$name] = $record;
} else {
// one-to-many relation or many-to-many relation
if( ! $prev[$pointer]->getLast()->hasReference($alias)) {
$prev[$name] = $this->getCollection($name);
$prev[$pointer]->getLast()->initReference($prev[$name], $fk);
} else {
// previous entry found from memory
$prev[$name] = $prev[$pointer]->getLast()->get($alias);
}
$prev[$pointer]->getLast()->addReference($record, $fk);
}
return $prev;
}
/**
* isIdentifiable
* returns whether or not a given data row is identifiable (it contains
* all id fields specified in the second argument)
*
* @param array $row
* @param mixed $ids
* @return boolean
*/
public function isIdentifiable(array $row, $ids) {
if(is_array($ids)) {
foreach($ids as $id) {
if($row[$id] == null)
return true;
}
} else {
if( ! isset($row[$ids]))
return true;
}
return false;
}
2006-07-22 03:22:15 +04:00
/**
* applyInheritance
* applies column aggregation inheritance to DQL / SQL query
2006-07-22 03:22:15 +04:00
*
* @return string
*/
public function applyInheritance() {
2006-07-22 03:22:15 +04:00
// get the inheritance maps
$array = array();
foreach($this->tables as $alias => $table):
$array[$alias][] = $table->getInheritanceMap();
endforeach;
// apply inheritance maps
$str = "";
$c = array();
$index = 0;
foreach($array as $tname => $maps) {
$a = array();
foreach($maps as $map) {
$b = array();
foreach($map as $field => $value) {
if($index > 0)
$b[] = "(".$tname.".$field = $value OR $tname.$field IS NULL)";
else
$b[] = $tname.".$field = $value";
}
if( ! empty($b)) $a[] = implode(" AND ",$b);
}
if( ! empty($a)) $c[] = implode(" AND ",$a);
$index++;
}
$str .= implode(" AND ",$c);
return $str;
}
/**
* parseData
* parses the data returned by PDOStatement
*
* @return array
*/
public function parseData(PDOStatement $stmt) {
$array = array();
while($data = $stmt->fetch(PDO::FETCH_ASSOC)):
/**
* parse the data into two-dimensional array
*/
foreach($data as $key => $value):
$e = explode("__",$key);
2006-09-03 23:20:02 +04:00
$field = strtolower( array_pop($e) );
$component = strtolower( implode("__",$e) );
2006-08-22 23:34:40 +04:00
$data[$component][$field] = $value;
2006-07-22 03:22:15 +04:00
unset($data[$key]);
endforeach;
$array[] = $data;
endwhile;
2006-08-22 23:34:40 +04:00
2006-07-22 03:22:15 +04:00
$stmt->closeCursor();
return $array;
}
/**
* returns a Doctrine_Table for given name
*
* @param string $name component name
* @return Doctrine_Table
*/
public function getTable($name) {
return $this->tables[$name];
}
/**
* @return string returns a string representation of this object
*/
public function __toString() {
return Doctrine_Lib::formatSql($this->getQuery());
}
2006-07-22 03:22:15 +04:00
}