1
0
mirror of synced 2024-12-13 22:56:04 +03:00
doctrine2/lib/Doctrine/Hydrate.php

637 lines
20 KiB
PHP
Raw Normal View History

2006-07-22 03:22:15 +04:00
<?php
2006-12-29 17:01:31 +03:00
/*
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>.
*/
2007-05-16 23:20:55 +04:00
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
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @category Object Relational Mapping
* @link www.phpdoctrine.com
* @since 1.0
* @version $Revision$
* @author Konsta Vesterinen <kvesteri@cc.hut.fi>
*/
2007-05-16 23:20:55 +04:00
class Doctrine_Hydrate
2006-12-29 17:40:47 +03:00
{
/**
* QUERY TYPE CONSTANTS
*/
/**
* constant for SELECT queries
*/
const SELECT = 0;
/**
* constant for DELETE queries
*/
const DELETE = 1;
/**
* constant for UPDATE queries
*/
const UPDATE = 2;
/**
* constant for INSERT queries
*/
const INSERT = 3;
/**
* constant for CREATE queries
*/
const CREATE = 4;
2007-05-16 23:20:55 +04:00
/**
* @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 $conn Doctrine_Connection object
2006-07-22 03:22:15 +04:00
*/
protected $conn;
2006-07-22 03:22:15 +04:00
/**
2007-05-21 01:30:08 +04:00
* @var Doctrine_View $_view Doctrine_View object, when set this object will use the
* the query given by the view object for object population
2006-07-22 03:22:15 +04:00
*/
2007-05-21 01:30:08 +04:00
protected $_view;
/**
2007-05-16 23:20:55 +04:00
* @var array $_aliasMap two dimensional array containing the map for query aliases
* Main keys are component aliases
*
* table table object associated with given alias
*
* relation the relation object owned by the parent
*
* parent the alias of the parent
*/
2007-05-16 23:20:55 +04:00
protected $_aliasMap = array();
2006-07-22 03:22:15 +04:00
/**
2007-05-16 23:20:55 +04:00
*
2006-07-22 03:22:15 +04:00
*/
2006-10-17 21:21:21 +04:00
protected $pendingAggregates = array();
2007-05-16 23:20:55 +04:00
/**
*
*/
2007-04-14 20:28:09 +04:00
protected $subqueryAggregates = array();
/**
* @var array $aggregateMap an array containing all aggregate aliases, keys as dql aliases
* and values as sql aliases
*/
2006-10-17 21:21:21 +04:00
protected $aggregateMap = array();
/**
2007-05-21 01:30:08 +04:00
* @var Doctrine_Hydrate_Alias $aliasHandler handles the creation and storage of table aliases and
* binds the aliases to component aliases / paths
*/
protected $aliasHandler;
2006-07-22 03:22:15 +04:00
/**
* @var array $parts SQL query string parts
*/
protected $parts = array(
2006-12-14 16:26:16 +03:00
'select' => array(),
2007-05-18 03:13:58 +04:00
'distinct' => false,
'forUpdate' => false,
2006-12-14 16:26:16 +03:00
'from' => array(),
'set' => array(),
'join' => array(),
'where' => array(),
'groupby' => array(),
'having' => array(),
'orderby' => array(),
'limit' => false,
'offset' => false,
2006-07-22 03:22:15 +04:00
);
/**
* @var integer $type the query type
*
* @see Doctrine_Query::* constants
*/
protected $type = self::SELECT;
2006-07-22 03:22:15 +04:00
/**
* constructor
*
* @param Doctrine_Connection|null $connection
2006-07-22 03:22:15 +04:00
*/
2006-12-29 17:40:47 +03:00
public function __construct($connection = null)
{
2006-12-29 17:01:31 +03:00
if ( ! ($connection instanceof Doctrine_Connection)) {
$connection = Doctrine_Manager::getInstance()->getCurrentConnection();
2006-12-29 17:01:31 +03:00
}
$this->conn = $connection;
$this->aliasHandler = new Doctrine_Hydrate_Alias();
2006-07-22 03:22:15 +04:00
}
2007-05-21 01:30:08 +04:00
2007-05-16 23:20:55 +04:00
public function getTableAlias($componentAlias)
{
return $this->aliasHandler->getShortAlias($componentAlias);
}
public function addQueryPart($name, $part)
{
if ( ! isset($this->parts[$name])) {
throw new Doctrine_Hydrate_Exception('Unknown query part ' . $name);
}
$this->parts[$name][] = $part;
}
public function getDeclaration($name)
2006-12-29 17:40:47 +03:00
{
2007-05-16 23:20:55 +04:00
if ( ! isset($this->_aliasMap[$name])) {
throw new Doctrine_Hydrate_Exception('Unknown component alias ' . $name);
}
return $this->_aliasMap[$name];
}
public function setQueryPart($name, $part)
{
if ( ! isset($this->parts[$name])) {
throw new Doctrine_Hydrate_Exception('Unknown query part ' . $name);
}
if ($name !== 'limit' && $name !== 'offset') {
$this->parts[$name] = array($part);
} else {
$this->parts[$name] = $part;
}
2006-12-24 01:45:36 +03:00
}
/**
* copyAliases
*
* @return void
*/
2007-05-16 23:20:55 +04:00
public function copyAliases($query)
2006-12-29 17:40:47 +03:00
{
2007-04-16 18:43:12 +04:00
$this->aliasHandler = $query->aliasHandler;
2006-12-29 17:01:31 +03:00
return $this;
}
/**
* createSubquery
2006-12-29 17:01:31 +03:00
*
* @return Doctrine_Hydrate
*/
2006-12-29 17:40:47 +03:00
public function createSubquery()
{
$class = get_class($this);
$obj = new $class();
2006-12-29 17:01:31 +03:00
// copy the aliases to the subquery
$obj->copyAliases($this);
2007-04-16 17:49:14 +04:00
// this prevents the 'id' being selected, re ticket #307
$obj->isSubquery(true);
return $obj;
}
/**
* limitSubqueryUsed
2006-09-08 01:25:08 +04:00
*
* @return boolean
*/
2006-12-29 17:40:47 +03:00
public function isLimitSubqueryUsed()
{
return false;
}
2007-05-16 23:20:55 +04:00
public function getQueryPart($part)
{
if ( ! isset($this->parts[$part])) {
throw new Doctrine_Hydrate_Exception('Unknown query part ' . $part);
}
2007-05-16 23:20:55 +04:00
return $this->parts[$part];
}
/**
* remove
*
* @param $name
*/
2006-12-29 17:40:47 +03:00
public function remove($name)
{
2006-12-29 17:01:31 +03:00
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
2006-12-29 17:01:31 +03:00
*
2006-07-22 03:22:15 +04:00
* @return void
*/
2006-12-29 17:40:47 +03:00
protected function clear()
{
2006-07-22 03:22:15 +04:00
$this->parts = array(
2007-05-16 23:20:55 +04:00
'select' => array(),
2007-05-18 03:13:58 +04:00
'distinct' => false,
'forUpdate' => false,
2007-05-16 23:20:55 +04:00
'from' => array(),
'set' => array(),
'join' => array(),
'where' => array(),
'groupby' => array(),
'having' => array(),
'orderby' => array(),
'limit' => false,
'offset' => false,
);
2006-07-22 03:22:15 +04:00
$this->inheritanceApplied = false;
$this->aliasHandler->clear();
2006-07-22 03:22:15 +04:00
}
/**
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-12-29 17:40:47 +03:00
public function getConnection()
{
return $this->conn;
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
*/
2006-12-29 17:40:47 +03:00
public function setView(Doctrine_View $view)
{
2007-05-21 01:30:08 +04:00
$this->_view = $view;
2006-07-22 03:22:15 +04:00
}
/**
* getView
2006-12-24 01:45:36 +03:00
* returns the view associated with this query object (if any)
2006-07-22 03:22:15 +04:00
*
2006-12-24 01:45:36 +03:00
* @return Doctrine_View the view associated with this query object
2006-07-22 03:22:15 +04:00
*/
2006-12-29 17:40:47 +03:00
public function getView()
{
2007-05-21 01:30:08 +04:00
return $this->_view;
2006-07-22 03:22:15 +04:00
}
2006-12-29 14:30:36 +03:00
/**
* getParams
2006-12-29 17:40:47 +03:00
*
2006-12-29 14:30:36 +03:00
* @return array
*/
2006-12-29 17:40:47 +03:00
public function getParams()
{
2006-12-29 14:30:36 +03:00
return $this->params;
}
2006-12-23 00:10:14 +03:00
/**
* setParams
*
* @param array $params
*/
public function setParams(array $params = array()) {
$this->params = $params;
}
2006-07-22 03:22:15 +04:00
/**
2007-05-16 23:20:55 +04:00
* _fetch
2006-07-22 03:22:15 +04:00
*
2007-05-16 23:20:55 +04:00
* @param array $params prepared statement parameters
* @param integer $fetchMode the fetchmode
* @see Doctrine::FETCH_* constants
2006-07-22 03:22:15 +04:00
*/
2007-05-16 23:20:55 +04:00
public function _fetch($params = array(), $fetchMode = Doctrine::FETCH_RECORD)
{
2007-02-15 14:41:00 +03:00
$params = $this->conn->convertBooleans(array_merge($this->params, $params));
2007-05-18 03:13:58 +04:00
$params = $this->convertEnums($params);
2006-12-29 17:01:31 +03:00
2007-05-21 01:30:08 +04:00
if ( ! $this->_view) {
$query = $this->getQuery($params);
2006-12-29 17:01:31 +03:00
} else {
2007-05-21 01:30:08 +04:00
$query = $this->_view->getSelectSql();
2006-12-29 17:01:31 +03:00
}
2006-07-22 03:22:15 +04:00
2007-05-16 23:20:55 +04:00
if ($this->isLimitSubqueryUsed() &&
2007-04-14 20:28:09 +04:00
$this->conn->getDBH()->getAttribute(Doctrine::ATTR_DRIVER_NAME) !== 'mysql') {
2007-05-18 03:13:58 +04:00
$params = array_merge($params, $params);
2006-12-29 17:01:31 +03:00
}
2007-05-18 03:13:58 +04:00
$stmt = $this->conn->execute($query, $params);
2006-09-08 01:25:08 +04:00
2007-05-16 23:20:55 +04:00
return $this->parseData($stmt);
}
2007-05-18 03:13:58 +04:00
public function convertEnums($params)
{
return $params;
}
2007-05-16 23:20:55 +04:00
public function setAliasMap($map)
{
$this->_aliasMap = $map;
}
2007-05-18 03:13:58 +04:00
public function getAliasMap()
2007-05-16 23:20:55 +04:00
{
return $this->_aliasMap;
}
/**
* mapAggregateValues
* map the aggregate values of given dataset row to a given record
*
* @param Doctrine_Record $record
* @param array $row
* @return Doctrine_Record
*/
public function mapAggregateValues($record, array $row, $alias)
{
$found = false;
// aggregate values have numeric keys
if (isset($row[0])) {
// map each aggregate value
foreach ($row as $index => $value) {
$agg = false;
if (isset($this->pendingAggregates[$alias][$index])) {
$agg = $this->pendingAggregates[$alias][$index][3];
} elseif (isset($this->subqueryAggregates[$alias][$index])) {
$agg = $this->subqueryAggregates[$alias][$index];
}
$record->mapValue($agg, $value);
$found = true;
}
2007-04-14 20:28:09 +04:00
}
2007-05-16 23:20:55 +04:00
return $found;
}
/**
* 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)
{
$array = (array) $this->_fetch($params, $return = Doctrine::FETCH_RECORD);
2006-09-08 01:25:08 +04:00
2007-05-16 23:20:55 +04:00
if (empty($this->_aliasMap)) {
throw new Doctrine_Hydrate_Exception("Couldn't execute query. Component alias map was empty.");
2007-04-14 20:28:09 +04:00
}
2007-05-16 23:20:55 +04:00
// initialize some variables used within the main loop
reset($this->_aliasMap);
$rootMap = current($this->_aliasMap);
$rootAlias = key($this->_aliasMap);
2007-05-16 23:52:06 +04:00
$coll = new Doctrine_Collection($rootMap['table']);
2007-05-16 23:20:55 +04:00
$prev[$rootAlias] = $coll;
2007-05-17 01:47:23 +04:00
2007-05-16 23:52:06 +04:00
// we keep track of all the collections
$colls = array();
2007-05-18 03:13:58 +04:00
$colls[] = $coll;
2007-05-16 23:20:55 +04:00
$prevRow = array();
/**
* iterate over the fetched data
* here $data is a two dimensional array
*/
2006-12-29 17:01:31 +03:00
foreach ($array as $data) {
2006-10-01 19:18:04 +04:00
/**
* remove duplicated data rows and map data into objects
*/
2007-05-16 23:20:55 +04:00
foreach ($data as $tableAlias => $row) {
// skip empty rows (not mappable)
2006-12-29 17:01:31 +03:00
if (empty($row)) {
2006-10-01 19:18:04 +04:00
continue;
2006-12-29 17:01:31 +03:00
}
2007-05-16 23:20:55 +04:00
$alias = $this->aliasHandler->getComponentAlias($tableAlias);
$map = $this->_aliasMap[$alias];
2006-07-22 03:22:15 +04:00
2007-05-16 23:20:55 +04:00
// initialize previous row array if not set
if ( ! isset($prevRow[$tableAlias])) {
$prevRow[$tableAlias] = array();
2006-10-24 21:24:58 +04:00
}
2006-10-17 21:21:21 +04:00
2007-05-16 23:20:55 +04:00
// don't map duplicate rows
if ($prevRow[$tableAlias] !== $row) {
$identifiable = $this->isIdentifiable($row, $map['table']->getIdentifier());
2006-07-22 03:22:15 +04:00
2007-05-16 23:20:55 +04:00
if ($identifiable) {
// set internal data
$map['table']->setData($row);
2006-12-22 01:06:08 +03:00
}
2006-10-17 21:21:21 +04:00
2007-05-16 23:20:55 +04:00
// initialize a new record
$record = $map['table']->getRecord();
2006-10-17 21:21:21 +04:00
2007-05-16 23:20:55 +04:00
// map aggregate values (if any)
if($this->mapAggregateValues($record, $row, $alias)) {
$identifiable = true;
2006-12-22 01:06:08 +03:00
}
2007-05-16 23:20:55 +04:00
if ($alias == $rootAlias) {
// add record into root collection
2007-05-17 00:27:03 +04:00
2007-05-16 23:20:55 +04:00
if ($identifiable) {
$coll->add($record);
unset($prevRow);
}
} else {
2006-09-23 21:02:30 +04:00
2007-05-16 23:20:55 +04:00
$relation = $map['relation'];
$parentAlias = $map['parent'];
$parentMap = $this->_aliasMap[$parentAlias];
$parent = $prev[$parentAlias]->getLast();
2006-07-22 03:22:15 +04:00
2007-05-16 23:20:55 +04:00
// 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());
}
2007-05-16 23:52:06 +04:00
$colls[] = $prev[$alias];
2007-05-16 23:20:55 +04:00
// add record to the current collection
if ($identifiable) {
$prev[$alias]->add($record);
2006-12-29 17:01:31 +03:00
}
2006-12-22 01:06:08 +03:00
}
2007-05-16 23:20:55 +04:00
// initialize the relation from parent to the current collection/record
$parent->set($relation->getAlias(), $prev[$alias]);
2006-12-22 01:06:08 +03:00
}
2007-05-16 23:20:55 +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'
2007-05-16 23:20:55 +04:00
if ($prev[$alias] !== $record) {
$prev[$alias] = $record;
2007-04-14 20:28:09 +04:00
}
2006-07-22 03:22:15 +04:00
}
2007-05-16 23:20:55 +04:00
$prevRow[$tableAlias] = $row;
2006-10-01 19:18:04 +04:00
}
}
2007-05-16 23:52:06 +04:00
// take snapshots from all initialized collections
2007-05-17 00:27:03 +04:00
foreach(array_unique($colls) as $c) {
$c->takeSnapshot();
2007-05-16 23:52:06 +04:00
}
2006-10-01 19:18:04 +04:00
return $coll;
2006-07-22 03:22:15 +04:00
}
/**
* isIdentifiable
2006-12-29 17:01:31 +03:00
* returns whether or not a given data row is identifiable (it contains
2007-05-16 23:20:55 +04:00
* all primary key fields specified in the second argument)
*
* @param array $row
2007-05-16 23:20:55 +04:00
* @param mixed $primaryKeys
* @return boolean
*/
2007-05-16 23:20:55 +04:00
public function isIdentifiable(array $row, $primaryKeys)
2006-12-29 17:40:47 +03:00
{
2007-05-16 23:20:55 +04:00
if (is_array($primaryKeys)) {
foreach ($primaryKeys as $id) {
if ($row[$id] == null) {
return false;
}
}
} else {
2007-05-16 23:20:55 +04:00
if ( ! isset($row[$primaryKeys])) {
return false;
2006-12-29 17:01:31 +03:00
}
}
2007-05-16 23:20:55 +04:00
return true;
}
/**
* getType
*
* returns the type of this query object
* by default the type is Doctrine_Hydrate::SELECT but if update() or delete()
* are being called the type is Doctrine_Hydrate::UPDATE and Doctrine_Hydrate::DELETE,
* respectively
*
* @see Doctrine_Hydrate::SELECT
* @see Doctrine_Hydrate::UPDATE
* @see Doctrine_Hydrate::DELETE
*
* @return integer return the query type
*/
public function getType()
{
return $this->type;
}
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
*/
2006-12-29 17:40:47 +03:00
public function applyInheritance()
{
2006-07-22 03:22:15 +04:00
// get the inheritance maps
$array = array();
2007-05-16 23:20:55 +04:00
foreach ($this->_aliasMap as $componentAlias => $data) {
$tableAlias = $this->getTableAlias($componentAlias);
$array[$tableAlias][] = $data['table']->inheritanceMap;
2007-02-08 16:56:23 +03:00
}
2006-07-22 03:22:15 +04:00
// apply inheritance maps
2007-05-16 23:20:55 +04:00
$str = '';
2006-07-22 03:22:15 +04:00
$c = array();
$index = 0;
2006-12-29 17:01:31 +03:00
foreach ($array as $tableAlias => $maps) {
2006-07-22 03:22:15 +04:00
$a = array();
// don't use table aliases if the query isn't a select query
if ($this->type !== Doctrine_Query::SELECT) {
$tableAlias = '';
} else {
$tableAlias .= '.';
}
2007-04-14 20:28:09 +04:00
2006-12-29 17:01:31 +03:00
foreach ($maps as $map) {
2006-07-22 03:22:15 +04:00
$b = array();
2006-12-29 17:01:31 +03:00
foreach ($map as $field => $value) {
if ($index > 0) {
$b[] = '(' . $tableAlias . $field . ' = ' . $value
. ' OR ' . $tableAlias . $field . ' IS NULL)';
2006-12-29 17:01:31 +03:00
} else {
$b[] = $tableAlias . $field . ' = ' . $value;
2006-12-29 17:01:31 +03:00
}
2006-07-22 03:22:15 +04:00
}
2006-12-29 17:01:31 +03:00
if ( ! empty($b)) {
$a[] = implode(' AND ', $b);
2006-12-29 17:01:31 +03:00
}
2006-07-22 03:22:15 +04:00
}
2006-12-29 17:01:31 +03:00
if ( ! empty($a)) {
$c[] = implode(' AND ', $a);
2006-12-29 17:01:31 +03:00
}
2006-07-22 03:22:15 +04:00
$index++;
}
$str .= implode(' AND ', $c);
2006-07-22 03:22:15 +04:00
return $str;
}
/**
* parseData
* parses the data returned by statement object
2006-07-22 03:22:15 +04:00
*
* @param mixed $stmt
2006-07-22 03:22:15 +04:00
* @return array
*/
public function parseData($stmt)
2006-12-29 17:40:47 +03:00
{
2006-07-22 03:22:15 +04:00
$array = array();
2006-12-29 17:01:31 +03:00
while ($data = $stmt->fetch(PDO::FETCH_ASSOC)) {
2006-07-22 03:22:15 +04:00
/**
* parse the data into two-dimensional array
*/
2006-12-29 17:01:31 +03:00
foreach ($data as $key => $value) {
2006-12-24 01:45:36 +03:00
$e = explode('__', $key);
2006-07-22 03:22:15 +04:00
2007-05-16 23:20:55 +04:00
$field = strtolower(array_pop($e));
$tableAlias = strtolower(implode('__', $e));
2006-09-03 23:20:02 +04:00
2007-05-16 23:20:55 +04:00
$data[$tableAlias][$field] = $value;
2006-08-22 23:34:40 +04:00
2006-07-22 03:22:15 +04:00
unset($data[$key]);
2007-05-16 23:20:55 +04:00
}
2006-07-22 03:22:15 +04:00
$array[] = $data;
2007-05-16 23:20:55 +04:00
}
2006-08-22 23:34:40 +04:00
2006-07-22 03:22:15 +04:00
$stmt->closeCursor();
return $array;
}
/**
* @return string returns a string representation of this object
*/
2006-12-29 17:40:47 +03:00
public function __toString()
{
return Doctrine_Lib::formatSql($this->getQuery());
}
2006-07-22 03:22:15 +04:00
}