Viewing file:  Abstract.php (66.98 KB) -rwxr-xr-x
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
<?php
/*
* $Id: Query.php 1393 2007-05-19 17:49:16Z zYne $
*
* 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.org>.
*/
/**
* Doctrine_Query_Abstract
*
* @package Doctrine
* @subpackage Query
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.phpdoctrine.org
* @since 1.0
* @version $Revision: 1393 $
* @author Konsta Vesterinen <kvesteri@cc.hut.fi>
* @todo See {@link Doctrine_Query}
*/
abstract class Doctrine_Query_Abstract
{
/**
* 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;
/** @todo document the query states (and the transitions between them). */
/**
* A query object is in CLEAN state when it has NO unparsed/unprocessed DQL parts.
*/
const STATE_CLEAN = 1;
/**
* A query object is in state DIRTY when it has DQL parts that have not yet been
* parsed/processed.
*/
const STATE_DIRTY = 2;
/**
* A query is in DIRECT state when ... ?
*/
const STATE_DIRECT = 3;
/**
* A query object is on LOCKED state when ... ?
*/
const STATE_LOCKED = 4;
/**
* @var array Table alias map. Keys are SQL aliases and values DQL aliases.
*/
protected $_tableAliasMap = array();
/**
* @var Doctrine_View The view object used by this query, if any.
*/
protected $_view;
/**
* @var integer $_state The current state of this query.
*/
protected $_state = Doctrine_Query::STATE_CLEAN;
/**
* @var array $_params The parameters of this query.
*/
protected $_params = array('exec' => array(),
'join' => array(),
'where' => array(),
'set' => array(),
'having' => array());
/**
* @var array $_execParams The parameters passed to connection statement
*/
protected $_execParams = array();
/* Caching properties */
/**
* @var Doctrine_Cache_Interface The cache driver used for caching result sets.
*/
protected $_resultCache;
/**
* @var string Key to use for result cache entry in the cache driver
*/
protected $_resultCacheHash;
/**
* @var boolean $_expireResultCache A boolean value that indicates whether or not
* expire the result cache.
*/
protected $_expireResultCache = false;
protected $_resultCacheTTL;
/**
* @var Doctrine_Cache_Interface The cache driver used for caching queries.
*/
protected $_queryCache;
protected $_expireQueryCache = false;
protected $_queryCacheTTL;
/**
* @var Doctrine_Connection The connection used by this query object.
*/
protected $_conn;
/**
* @var bool Whether or not a connection was passed to this query object to use
*/
protected $_passedConn = false;
/**
* @var array $_sqlParts The SQL query string parts. Filled during the DQL parsing process.
*/
protected $_sqlParts = array(
'select' => array(),
'distinct' => false,
'forUpdate' => false,
'from' => array(),
'set' => array(),
'join' => array(),
'where' => array(),
'groupby' => array(),
'having' => array(),
'orderby' => array(),
'limit' => false,
'offset' => false,
);
/**
* @var array $_dqlParts an array containing all DQL query parts; @see Doctrine_Query::getDqlPart()
*/
protected $_dqlParts = array(
'from' => array(),
'select' => array(),
'forUpdate' => false,
'set' => array(),
'join' => array(),
'where' => array(),
'groupby' => array(),
'having' => array(),
'orderby' => array(),
'limit' => array(),
'offset' => array(),
);
/**
* @var array $_queryComponents Two dimensional array containing the components of this query,
* informations about their relations and other related information.
* The components are constructed during query parsing.
*
* Keys are component aliases and values the following:
*
* table table object associated with given alias
*
* relation the relation object owned by the parent
*
* parent the alias of the parent
*
* agg the aggregates of this component
*
* map the name of the column / aggregate value this
* component is mapped to a collection
*/
protected $_queryComponents = array();
/**
* Stores the root DQL alias
*
* @var string
*/
protected $_rootAlias = '';
/**
* @var integer $type the query type
*
* @see Doctrine_Query::* constants
*/
protected $_type = self::SELECT;
/**
* @var Doctrine_Hydrator The hydrator object used to hydrate query results.
*/
protected $_hydrator;
/**
* @var Doctrine_Query_Tokenizer The tokenizer that is used during the query parsing process.
*/
protected $_tokenizer;
/**
* @var Doctrine_Query_Parser The parser that is used for query parsing.
*/
protected $_parser;
/**
* @var array $_tableAliasSeeds A simple array keys representing table aliases and values
* table alias seeds. The seeds are used for generating short table
* aliases.
*/
protected $_tableAliasSeeds = array();
/**
* @var array $_options an array of options
*/
protected $_options = array(
'hydrationMode' => Doctrine_Core::HYDRATE_RECORD
);
/**
* @var boolean
*/
protected $_isLimitSubqueryUsed = false;
/**
* @var array components used in the DQL statement
*/
protected $_components;
/**
* @var bool Boolean variable for whether or not the preQuery process has been executed
*/
protected $_preQueried = false;
/**
* Constructor.
*
* @param Doctrine_Connection The connection object the query will use.
* @param Doctrine_Hydrator_Abstract The hydrator that will be used for generating result sets.
*/
public function __construct(Doctrine_Connection $connection = null,
Doctrine_Hydrator_Abstract $hydrator = null)
{
if ($connection === null) {
$connection = Doctrine_Manager::getInstance()->getCurrentConnection();
} else {
$this->_passedConn = true;
}
if ($hydrator === null) {
$hydrator = new Doctrine_Hydrator();
}
$this->_conn = $connection;
$this->_hydrator = $hydrator;
$this->_tokenizer = new Doctrine_Query_Tokenizer();
$this->_resultCacheTTL = $this->_conn->getAttribute(Doctrine_Core::ATTR_RESULT_CACHE_LIFESPAN);
$this->_queryCacheTTL = $this->_conn->getAttribute(Doctrine_Core::ATTR_QUERY_CACHE_LIFESPAN);
}
/**
* Set the connection this query object should use
*
* @param Doctrine_Connection $connection
* @return void
*/
public function setConnection(Doctrine_Connection $connection)
{
$this->_passedConn = true;
$this->_conn = $connection;
}
/**
* setOption
*
* @param string $name option name
* @param string $value option value
* @return Doctrine_Query this object
*/
public function setOption($name, $value)
{
if ( ! isset($this->_options[$name])) {
throw new Doctrine_Query_Exception('Unknown option ' . $name);
}
$this->_options[$name] = $value;
}
/**
* hasSqlTableAlias
* whether or not this object has given tableAlias
*
* @param string $tableAlias the table alias to be checked
* @return boolean true if this object has given alias, otherwise false
*/
public function hasSqlTableAlias($sqlTableAlias)
{
return (isset($this->_tableAliasMap[$sqlTableAlias]));
}
/**
* getTableAliasMap
* returns all table aliases
*
* @return array table aliases as an array
*/
public function getTableAliasMap()
{
return $this->_tableAliasMap;
}
/**
* getDql
* returns the DQL query that is represented by this query object.
*
* the query is built from $_dqlParts
*
* @return string the DQL query
*/
public function getDql()
{
$q = '';
if ($this->_type == self::SELECT) {
$q .= ( ! empty($this->_dqlParts['select'])) ? 'SELECT ' . implode(', ', $this->_dqlParts['select']) : '';
$q .= ( ! empty($this->_dqlParts['from'])) ? ' FROM ' . implode(' ', $this->_dqlParts['from']) : '';
} else if ($this->_type == self::DELETE) {
$q .= 'DELETE';
$q .= ( ! empty($this->_dqlParts['from'])) ? ' FROM ' . implode(' ', $this->_dqlParts['from']) : '';
} else if ($this->_type == self::UPDATE) {
$q .= 'UPDATE ';
$q .= ( ! empty($this->_dqlParts['from'])) ? implode(' ', $this->_dqlParts['from']) : '';
$q .= ( ! empty($this->_dqlParts['set'])) ? ' SET ' . implode(' ', $this->_dqlParts['set']) : '';
}
$q .= ( ! empty($this->_dqlParts['where'])) ? ' WHERE ' . implode(' ', $this->_dqlParts['where']) : '';
$q .= ( ! empty($this->_dqlParts['groupby'])) ? ' GROUP BY ' . implode(', ', $this->_dqlParts['groupby']) : '';
$q .= ( ! empty($this->_dqlParts['having'])) ? ' HAVING ' . implode(' AND ', $this->_dqlParts['having']) : '';
$q .= ( ! empty($this->_dqlParts['orderby'])) ? ' ORDER BY ' . implode(', ', $this->_dqlParts['orderby']) : '';
$q .= ( ! empty($this->_dqlParts['limit'])) ? ' LIMIT ' . implode(' ', $this->_dqlParts['limit']) : '';
$q .= ( ! empty($this->_dqlParts['offset'])) ? ' OFFSET ' . implode(' ', $this->_dqlParts['offset']) : '';
return $q;
}
/**
* getSqlQueryPart
* gets an SQL query part from the SQL query part array
*
* @param string $name the name of the query part to be set
* @param string $part query part string
* @throws Doctrine_Query_Exception if trying to set unknown query part
* @return Doctrine_Hydrate this object
*/
public function getSqlQueryPart($part)
{
if ( ! isset($this->_sqlParts[$part])) {
throw new Doctrine_Query_Exception('Unknown SQL query part ' . $part);
}
return $this->_sqlParts[$part];
}
/**
* setSqlQueryPart
* sets an SQL query part in the SQL query part array
*
* @param string $name the name of the query part to be set
* @param string $part query part string
* @throws Doctrine_Query_Exception if trying to set unknown query part
* @return Doctrine_Hydrate this object
*/
public function setSqlQueryPart($name, $part)
{
if ( ! isset($this->_sqlParts[$name])) {
throw new Doctrine_Query_Exception('Unknown query part ' . $name);
}
if ($name !== 'limit' && $name !== 'offset') {
if (is_array($part)) {
$this->_sqlParts[$name] = $part;
} else {
$this->_sqlParts[$name] = array($part);
}
} else {
$this->_sqlParts[$name] = $part;
}
return $this;
}
/**
* addSqlQueryPart
* adds an SQL query part to the SQL query part array
*
* @param string $name the name of the query part to be added
* @param string $part query part string
* @throws Doctrine_Query_Exception if trying to add unknown query part
* @return Doctrine_Hydrate this object
*/
public function addSqlQueryPart($name, $part)
{
if ( ! isset($this->_sqlParts[$name])) {
throw new Doctrine_Query_Exception('Unknown query part ' . $name);
}
if (is_array($part)) {
$this->_sqlParts[$name] = array_merge($this->_sqlParts[$name], $part);
} else {
$this->_sqlParts[$name][] = $part;
}
return $this;
}
/**
* removeSqlQueryPart
* removes a query part from the query part array
*
* @param string $name the name of the query part to be removed
* @throws Doctrine_Query_Exception if trying to remove unknown query part
* @return Doctrine_Hydrate this object
*/
public function removeSqlQueryPart($name)
{
if ( ! isset($this->_sqlParts[$name])) {
throw new Doctrine_Query_Exception('Unknown query part ' . $name);
}
if ($name == 'limit' || $name == 'offset' || $name == 'forUpdate') {
$this->_sqlParts[$name] = false;
} else {
$this->_sqlParts[$name] = array();
}
return $this;
}
/**
* removeDqlQueryPart
* removes a dql query part from the dql query part array
*
* @param string $name the name of the query part to be removed
* @throws Doctrine_Query_Exception if trying to remove unknown query part
* @return Doctrine_Hydrate this object
*/
public function removeDqlQueryPart($name)
{
if ( ! isset($this->_dqlParts[$name])) {
throw new Doctrine_Query_Exception('Unknown query part ' . $name);
}
if ($name == 'limit' || $name == 'offset') {
$this->_dqlParts[$name] = false;
} else {
$this->_dqlParts[$name] = array();
}
return $this;
}
/**
* Get raw array of parameters for query and all parts.
*
* @return array $params
*/
public function getParams()
{
return $this->_params;
}
/**
* Get flattened array of parameters for query.
* Used internally and used to pass flat array of params to the database.
*
* @param array $params
* @return void
*/
public function getFlattenedParams($params = array())
{
return array_merge(
(array) $params, (array) $this->_params['exec'],
$this->_params['join'], $this->_params['set'],
$this->_params['where'], $this->_params['having']
);
}
/**
* getInternalParams
*
* @return array
*/
public function getInternalParams($params = array())
{
return array_merge($params, $this->_execParams);
}
/**
* setParams
*
* @param array $params
*/
public function setParams(array $params = array())
{
$this->_params = $params;
}
/**
* getCountQueryParams
* Retrieves the parameters for count query
*
* @return array Parameters array
*/
public function getCountQueryParams($params = array())
{
if ( ! is_array($params)) {
$params = array($params);
}
$this->_params['exec'] = $params;
$params = array_merge($this->_params['join'], $this->_params['where'], $this->_params['having'], $this->_params['exec']);
$this->fixArrayParameterValues($params);
return $this->_execParams;
}
/**
* @nodoc
*/
public function fixArrayParameterValues($params = array())
{
$i = 0;
foreach ($params as $param) {
if (is_array($param)) {
$c = count($param);
array_splice($params, $i, 1, $param);
$i += $c;
} else {
$i++;
}
}
$this->_execParams = $params;
}
/**
* 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
* returns the view associated with this query object (if any)
*
* @return Doctrine_View the view associated with this query object
*/
public function getView()
{
return $this->_view;
}
/**
* limitSubqueryUsed
*
* @return boolean
*/
public function isLimitSubqueryUsed()
{
return $this->_isLimitSubqueryUsed;
}
/**
* Returns the inheritance condition for the passed componentAlias
* If no component alias is specified it defaults to the root component
*
* This function is used to append a SQL condition to models which have inheritance mapping
* The condition is applied to the FROM component in the WHERE, but the condition is applied to
* JOINS in the ON condition and not the WHERE
*
* @return string $str SQL condition string
*/
public function getInheritanceCondition($componentAlias)
{
$map = $this->_queryComponents[$componentAlias]['table']->inheritanceMap;
// No inheritance map so lets just return
if (empty($map)) {
return;
}
$tableAlias = $this->getSqlTableAlias($componentAlias);
if ($this->_type !== Doctrine_Query::SELECT) {
$tableAlias = '';
} else {
$tableAlias .= '.';
}
// Fix for 2015: loop through whole inheritanceMap to add all
// keyFields for inheritance (and not only the first)
$retVal = "";
$count = 0;
foreach ($map as $field => $value) {
if ($count++ > 0) {
$retVal .= ' AND ';
}
$identifier = $this->_conn->quoteIdentifier($tableAlias . $field);
$retVal .= $identifier . ' = ' . $this->_conn->quote($value);
}
return $retVal;
}
/**
* getSqlTableAlias
* some database such as Oracle need the identifier lengths to be < ~30 chars
* hence Doctrine creates as short identifier aliases as possible
*
* this method is used for the creation of short table aliases, its also
* smart enough to check if an alias already exists for given component (componentAlias)
*
* @param string $componentAlias the alias for the query component to search table alias for
* @param string $tableName the table name from which the table alias is being created
* @return string the generated / fetched short alias
*/
public function getSqlTableAlias($componentAlias, $tableName = null)
{
$alias = array_search($componentAlias, $this->_tableAliasMap);
if ($alias !== false) {
return $alias;
}
if ($tableName === null) {
throw new Doctrine_Query_Exception("Couldn't get short alias for " . $componentAlias);
}
return $this->generateSqlTableAlias($componentAlias, $tableName);
}
/**
* generateNewSqlTableAlias
* generates a new alias from given table alias
*
* @param string $tableAlias table alias from which to generate the new alias from
* @return string the created table alias
*/
public function generateNewSqlTableAlias($oldAlias)
{
if (isset($this->_tableAliasMap[$oldAlias])) {
// generate a new alias
$name = substr($oldAlias, 0, 1);
$i = ((int) substr($oldAlias, 1));
// Fix #1530: It was reaching unexistent seeds index
if ( ! isset($this->_tableAliasSeeds[$name])) {
$this->_tableAliasSeeds[$name] = 1;
}
$newIndex = ($this->_tableAliasSeeds[$name] + (($i == 0) ? 1 : $i));
return $name . $newIndex;
}
return $oldAlias;
}
/**
* getSqlTableAliasSeed
* returns the alias seed for given table alias
*
* @param string $tableAlias table alias that identifies the alias seed
* @return integer table alias seed
*/
public function getSqlTableAliasSeed($sqlTableAlias)
{
if ( ! isset($this->_tableAliasSeeds[$sqlTableAlias])) {
return 0;
}
return $this->_tableAliasSeeds[$sqlTableAlias];
}
/**
* hasAliasDeclaration
* whether or not this object has a declaration for given component alias
*
* @param string $componentAlias the component alias the retrieve the declaration from
* @return boolean
*/
public function hasAliasDeclaration($componentAlias)
{
return isset($this->_queryComponents[$componentAlias]);
}
/**
* getQueryComponent
* get the declaration for given component alias
*
* @param string $componentAlias the component alias the retrieve the declaration from
* @return array the alias declaration
*/
public function getQueryComponent($componentAlias)
{
if ( ! isset($this->_queryComponents[$componentAlias])) {
throw new Doctrine_Query_Exception('Unknown component alias ' . $componentAlias);
}
return $this->_queryComponents[$componentAlias];
}
/**
* copySubqueryInfo
* copy aliases from another Hydrate object
*
* this method is needed by DQL subqueries which need the aliases
* of the parent query
*
* @param Doctrine_Hydrate $query the query object from which the
* aliases are copied from
* @return Doctrine_Hydrate this object
*/
public function copySubqueryInfo(Doctrine_Query_Abstract $query)
{
$this->_params =& $query->_params;
$this->_tableAliasMap =& $query->_tableAliasMap;
$this->_queryComponents =& $query->_queryComponents;
$this->_tableAliasSeeds = $query->_tableAliasSeeds;
return $this;
}
/**
* getRootAlias
* returns the alias of the root component
*
* @return array
*/
public function getRootAlias()
{
if ( ! $this->_queryComponents) {
$this->getSqlQuery(array(), false);
}
return $this->_rootAlias;
}
/**
* getRootDeclaration
* returns the root declaration
*
* @return array
*/
public function getRootDeclaration()
{
$map = $this->_queryComponents[$this->_rootAlias];
return $map;
}
/**
* getRoot
* returns the root component for this object
*
* @return Doctrine_Table root components table
*/
public function getRoot()
{
$map = $this->_queryComponents[$this->_rootAlias];
if ( ! isset($map['table'])) {
throw new Doctrine_Query_Exception('Root component not initialized.');
}
return $map['table'];
}
/**
* generateSqlTableAlias
* generates a table alias from given table name and associates
* it with given component alias
*
* @param string $componentAlias the component alias to be associated with generated table alias
* @param string $tableName the table name from which to generate the table alias
* @return string the generated table alias
*/
public function generateSqlTableAlias($componentAlias, $tableName)
{
preg_match('/([^_|\d])/', $tableName, $matches);
$char = strtolower($matches[0]);
$alias = $char;
if ( ! isset($this->_tableAliasSeeds[$alias])) {
$this->_tableAliasSeeds[$alias] = 1;
}
while (isset($this->_tableAliasMap[$alias])) {
if ( ! isset($this->_tableAliasSeeds[$alias])) {
$this->_tableAliasSeeds[$alias] = 1;
}
$alias = $char . ++$this->_tableAliasSeeds[$alias];
}
$this->_tableAliasMap[$alias] = $componentAlias;
return $alias;
}
/**
* getComponentAlias
* get component alias associated with given table alias
*
* @param string $sqlTableAlias the SQL table alias that identifies the component alias
* @return string component alias
*/
public function getComponentAlias($sqlTableAlias)
{
$sqlTableAlias = trim($sqlTableAlias, '[]`"');
if ( ! isset($this->_tableAliasMap[$sqlTableAlias])) {
throw new Doctrine_Query_Exception('Unknown table alias ' . $sqlTableAlias);
}
return $this->_tableAliasMap[$sqlTableAlias];
}
/**
* calculateQueryCacheHash
* calculate hash key for query cache
*
* @return string the hash
*/
public function calculateQueryCacheHash()
{
$dql = $this->getDql();
$hash = md5($dql . var_export($this->_pendingJoinConditions, true) . 'DOCTRINE_QUERY_CACHE_SALT');
return $hash;
}
/**
* calculateResultCacheHash
* calculate hash key for result cache
*
* @param array $params
* @return string the hash
*/
public function calculateResultCacheHash($params = array())
{
$dql = $this->getDql();
$conn = $this->getConnection();
$params = $this->getFlattenedParams($params);
$hash = md5($this->_hydrator->getHydrationMode() . $conn->getName() . $conn->getOption('dsn') . $dql . var_export($this->_pendingJoinConditions, true) . var_export($params, true));
return $hash;
}
/**
* Get the result cache hash/key. Returns key set with useResultCache()
* or generates a unique key from the query automatically.
*
* @param array $params
* @return string $hash
*/
public function getResultCacheHash($params = array())
{
if ($this->_resultCacheHash) {
return $this->_resultCacheHash;
} else {
return $this->calculateResultCacheHash($params);
}
}
/**
* _execute
*
* @param array $params
* @return PDOStatement The executed PDOStatement.
*/
protected function _execute($params)
{
// Apply boolean conversion in DQL params
$params = $this->_conn->convertBooleans($params);
foreach ($this->_params as $k => $v) {
$this->_params[$k] = $this->_conn->convertBooleans($v);
}
$dqlParams = $this->getFlattenedParams($params);
// Check if we're not using a Doctrine_View
if ( ! $this->_view) {
if ($this->_queryCache !== false && ($this->_queryCache || $this->_conn->getAttribute(Doctrine_Core::ATTR_QUERY_CACHE))) {
$queryCacheDriver = $this->getQueryCacheDriver();
$hash = $this->calculateQueryCacheHash();
$cached = $queryCacheDriver->fetch($hash);
// If we have a cached query...
if ($cached) {
// Rebuild query from cache
$query = $this->_constructQueryFromCache($cached);
// Assign building/execution specific params
$this->_params['exec'] = $params;
// Initialize prepared parameters array
$this->_execParams = $this->getFlattenedParams();
// Fix possible array parameter values in SQL params
$this->fixArrayParameterValues($this->getInternalParams());
} else {
// Generate SQL or pick already processed one
$query = $this->getSqlQuery($params);
// Check again because getSqlQuery() above could have flipped the _queryCache flag
// if this query contains the limit sub query algorithm we don't need to cache it
if ($this->_queryCache !== false && ($this->_queryCache || $this->_conn->getAttribute(Doctrine_Core::ATTR_QUERY_CACHE))) {
// Convert query into a serialized form
$serializedQuery = $this->getCachedForm($query);
// Save cached query
$queryCacheDriver->save($hash, $serializedQuery, $this->getQueryCacheLifeSpan());
}
}
} else {
$query = $this->getSqlQuery($params);
}
} else {
$query = $this->_view->getSelectSql();
}
// Get prepared SQL params for execution
$params = $this->getInternalParams();
if ($this->isLimitSubqueryUsed() &&
$this->_conn->getAttribute(Doctrine_Core::ATTR_DRIVER_NAME) !== 'mysql') {
$params = array_merge((array) $params, (array) $params);
}
if ($this->_type !== self::SELECT) {
return $this->_conn->exec($query, $params);
}
$stmt = $this->_conn->execute($query, $params);
$this->_params['exec'] = array();
return $stmt;
}
/**
* execute
* executes the query and populates the data set
*
* @param array $params
* @return Doctrine_Collection the root collection
*/
public function execute($params = array(), $hydrationMode = null)
{
// Clean any possible processed params
$this->_execParams = array();
if (empty($this->_dqlParts['from']) && empty($this->_sqlParts['from'])) {
throw new Doctrine_Query_Exception('You must have at least one component specified in your from.');
}
$dqlParams = $this->getFlattenedParams($params);
$this->_preQuery($dqlParams);
if ($hydrationMode !== null) {
$this->_hydrator->setHydrationMode($hydrationMode);
}
$hydrationMode = $this->_hydrator->getHydrationMode();
if ($this->_resultCache && $this->_type == self::SELECT) {
$cacheDriver = $this->getResultCacheDriver();
$hash = $this->getResultCacheHash($params);
$cached = ($this->_expireResultCache) ? false : $cacheDriver->fetch($hash);
if ($cached === false) {
// cache miss
$stmt = $this->_execute($params);
$this->_hydrator->setQueryComponents($this->_queryComponents);
$result = $this->_hydrator->hydrateResultSet($stmt, $this->_tableAliasMap);
$cached = $this->getCachedForm($result);
$cacheDriver->save($hash, $cached, $this->getResultCacheLifeSpan());
} else {
$result = $this->_constructQueryFromCache($cached);
}
} else {
$stmt = $this->_execute($params);
if (is_integer($stmt)) {
$result = $stmt;
} else {
$this->_hydrator->setQueryComponents($this->_queryComponents);
if ($this->_type == self::SELECT && $hydrationMode == Doctrine_Core::HYDRATE_ON_DEMAND) {
$hydrationDriver = $this->_hydrator->getHydratorDriver($hydrationMode, $this->_tableAliasMap);
$result = new Doctrine_Collection_OnDemand($stmt, $hydrationDriver, $this->_tableAliasMap);
} else {
$result = $this->_hydrator->hydrateResultSet($stmt, $this->_tableAliasMap);
}
}
}
if ($this->getConnection()->getAttribute(Doctrine_Core::ATTR_AUTO_FREE_QUERY_OBJECTS)) {
$this->free();
}
return $result;
}
/**
* Blank template method free(). Override to be used to free query object memory
*/
public function free()
{
}
/**
* Get the dql call back for this query
*
* @return array $callback
*/
protected function _getDqlCallback()
{
$callback = false;
if ( ! empty($this->_dqlParts['from'])) {
switch ($this->_type) {
case self::DELETE:
$callback = array(
'callback' => 'preDqlDelete',
'const' => Doctrine_Event::RECORD_DQL_DELETE
);
break;
case self::UPDATE:
$callback = array(
'callback' => 'preDqlUpdate',
'const' => Doctrine_Event::RECORD_DQL_UPDATE
);
break;
case self::SELECT:
$callback = array(
'callback' => 'preDqlSelect',
'const' => Doctrine_Event::RECORD_DQL_SELECT
);
break;
}
}
return $callback;
}
/**
* Pre query method which invokes the pre*Query() methods on the model instance or any attached
* record listeners
*
* @return void
*/
protected function _preQuery($params = array())
{
if ( ! $this->_preQueried && $this->getConnection()->getAttribute(Doctrine_Core::ATTR_USE_DQL_CALLBACKS)) {
$this->_preQueried = true;
$callback = $this->_getDqlCallback();
// if there is no callback for the query type, then we can return early
if ( ! $callback) {
return;
}
foreach ($this->_getDqlCallbackComponents($params) as $alias => $component) {
$table = $component['table'];
$record = $table->getRecordInstance();
// Trigger preDql*() callback event
$params = array('component' => $component, 'alias' => $alias);
$event = new Doctrine_Event($record, $callback['const'], $this, $params);
$record->$callback['callback']($event);
$table->getRecordListener()->$callback['callback']($event);
}
}
// Invoke preQuery() hook on Doctrine_Query for child classes which implement this hook
$this->preQuery();
}
/**
* Returns an array of components to execute the query callbacks for
*
* @param array $params
* @return array $components
*/
protected function _getDqlCallbackComponents($params = array())
{
$componentsBefore = array();
if ($this->isSubquery()) {
$componentsBefore = $this->getQueryComponents();
}
$copy = $this->copy();
$copy->getSqlQuery($params, false);
$componentsAfter = $copy->getQueryComponents();
$this->_rootAlias = $copy->getRootAlias();
$copy->free();
if ($componentsBefore !== $componentsAfter) {
return array_diff($componentsAfter, $componentsBefore);
} else {
return $componentsAfter;
}
}
/**
* Blank hook methods which can be implemented in Doctrine_Query child classes
*
* @return void
*/
public function preQuery()
{
}
/**
* Constructs the query from the cached form.
*
* @param string The cached query, in a serialized form.
* @return array The custom component that was cached together with the essential
* query data. This can be either a result set (result caching)
* or an SQL query string (query caching).
*/
protected function _constructQueryFromCache($cached)
{
$cached = unserialize($cached);
$this->_tableAliasMap = $cached[2];
$customComponent = $cached[0];
$queryComponents = array();
$cachedComponents = $cached[1];
foreach ($cachedComponents as $alias => $components) {
$e = explode('.', $components['name']);
if (count($e) === 1) {
$manager = Doctrine_Manager::getInstance();
if ( ! $this->_passedConn && $manager->hasConnectionForComponent($e[0])) {
$this->_conn = $manager->getConnectionForComponent($e[0]);
}
$queryComponents[$alias]['table'] = $this->_conn->getTable($e[0]);
} else {
$queryComponents[$alias]['parent'] = $e[0];
$queryComponents[$alias]['relation'] = $queryComponents[$e[0]]['table']->getRelation($e[1]);
$queryComponents[$alias]['table'] = $queryComponents[$alias]['relation']->getTable();
}
if (isset($components['agg'])) {
$queryComponents[$alias]['agg'] = $components['agg'];
}
if (isset($components['map'])) {
$queryComponents[$alias]['map'] = $components['map'];
}
}
$this->_queryComponents = $queryComponents;
return $customComponent;
}
/**
* getCachedForm
* returns the cached form of this query for given resultSet
*
* @param array $resultSet
* @return string serialized string representation of this query
*/
public function getCachedForm($customComponent = null)
{
$componentInfo = array();
foreach ($this->getQueryComponents() as $alias => $components) {
if ( ! isset($components['parent'])) {
$componentInfo[$alias]['name'] = $components['table']->getComponentName();
} else {
$componentInfo[$alias]['name'] = $components['parent'] . '.' . $components['relation']->getAlias();
}
if (isset($components['agg'])) {
$componentInfo[$alias]['agg'] = $components['agg'];
}
if (isset($components['map'])) {
$componentInfo[$alias]['map'] = $components['map'];
}
}
if ($customComponent instanceof Doctrine_Collection) {
foreach ($customComponent as $record) {
$record->serializeReferences(true);
}
}
return serialize(array($customComponent, $componentInfo, $this->getTableAliasMap()));
}
/**
* Adds fields or aliased functions.
*
* This method adds fields or dbms functions to the SELECT query part.
* <code>
* $query->addSelect('COUNT(p.id) as num_phonenumbers');
* </code>
*
* @param string $select Query SELECT part
* @return Doctrine_Query
*/
public function addSelect($select)
{
return $this->_addDqlQueryPart('select', $select, true);
}
/**
* addSqlTableAlias
* adds an SQL table alias and associates it a component alias
*
* @param string $componentAlias the alias for the query component associated with given tableAlias
* @param string $tableAlias the table alias to be added
* @return Doctrine_Query_Abstract
*/
public function addSqlTableAlias($sqlTableAlias, $componentAlias)
{
$this->_tableAliasMap[$sqlTableAlias] = $componentAlias;
return $this;
}
/**
* addFrom
* adds fields to the FROM part of the query
*
* @param string $from Query FROM part
* @return Doctrine_Query
*/
public function addFrom($from)
{
return $this->_addDqlQueryPart('from', $from, true);
}
/**
* Alias for @see andWhere().
* @return Doctrine_Query this object
*/
public function addWhere($where, $params = array())
{
return $this->andWhere($where, $params);
}
/**
* Adds conditions to the WHERE part of the query.
* <code>
* $q->andWhere('u.birthDate > ?', '1975-01-01');
* </code>
*
* @param string $where Query WHERE part
* @param mixed $params An array of parameters or a simple scalar
* @return Doctrine_Query
*/
public function andWhere($where, $params = array())
{
if (is_array($params)) {
$this->_params['where'] = array_merge($this->_params['where'], $params);
} else {
$this->_params['where'][] = $params;
}
if ($this->_hasDqlQueryPart('where')) {
$this->_addDqlQueryPart('where', 'AND', true);
}
return $this->_addDqlQueryPart('where', $where, true);
}
/**
* Adds conditions to the WHERE part of the query
* <code>
* $q->orWhere('u.role = ?', 'admin');
* </code>
*
* @param string $where Query WHERE part
* @param mixed $params An array of parameters or a simple scalar
* @return Doctrine_Query
*/
public function orWhere($where, $params = array())
{
if (is_array($params)) {
$this->_params['where'] = array_merge($this->_params['where'], $params);
} else {
$this->_params['where'][] = $params;
}
if ($this->_hasDqlQueryPart('where')) {
$this->_addDqlQueryPart('where', 'OR', true);
}
return $this->_addDqlQueryPart('where', $where, true);
}
/**
* Adds IN condition to the query WHERE part. Alias to @see andWhereIn().
*
* @param string $expr the operand of the IN
* @param mixed $params an array of parameters or a simple scalar
* @param boolean $not whether or not to use NOT in front of IN
* @return Doctrine_Query
*/
public function whereIn($expr, $params = array(), $not = false)
{
return $this->andWhereIn($expr, $params, $not);
}
/**
* Adds IN condition to the query WHERE part
* <code>
* $q->whereIn('u.id', array(10, 23, 44));
* </code>
*
* @param string $expr The operand of the IN
* @param mixed $params An array of parameters or a simple scalar
* @param boolean $not Whether or not to use NOT in front of IN. Defaults to false (simple IN clause)
* @return Doctrine_Query this object.
*/
public function andWhereIn($expr, $params = array(), $not = false)
{
// if there's no params, return (else we'll get a WHERE IN (), invalid SQL)
if (isset($params) and (count($params) == 0)) {
return $this;
}
if ($this->_hasDqlQueryPart('where')) {
$this->_addDqlQueryPart('where', 'AND', true);
}
return $this->_addDqlQueryPart('where', $this->_processWhereIn($expr, $params, $not), true);
}
/**
* Adds IN condition to the query WHERE part, appending it with an OR operator.
* <code>
* $q->orWhereIn('u.id', array(10, 23))
* ->orWhereIn('u.id', 44);
* // will select all record with id equal to 10, 23 or 44
* </code>
*
* @param string $expr The operand of the IN
* @param mixed $params An array of parameters or a simple scalar
* @param boolean $not Whether or not to use NOT in front of IN
* @return Doctrine_Query
*/
public function orWhereIn($expr, $params = array(), $not = false)
{
// if there's no params, return (else we'll get a WHERE IN (), invalid SQL)
if (isset($params) and (count($params) == 0)) {
return $this;
}
if ($this->_hasDqlQueryPart('where')) {
$this->_addDqlQueryPart('where', 'OR', true);
}
return $this->_addDqlQueryPart('where', $this->_processWhereIn($expr, $params, $not), true);
}
/**
* @nodoc
*/
protected function _processWhereIn($expr, $params = array(), $not = false)
{
$params = (array) $params;
// if there's no params, return (else we'll get a WHERE IN (), invalid SQL)
if (count($params) == 0) {
throw new Doctrine_Query_Exception('You must pass at least one parameter when using an IN() condition.');
}
$a = array();
foreach ($params as $k => $value) {
if ($value instanceof Doctrine_Expression) {
$value = $value->getSql();
unset($params[$k]);
} else {
$value = '?';
}
$a[] = $value;
}
$this->_params['where'] = array_merge($this->_params['where'], $params);
return $expr . ($not === true ? ' NOT' : '') . ' IN (' . implode(', ', $a) . ')';
}
/**
* Adds NOT IN condition to the query WHERE part.
* <code>
* $q->whereNotIn('u.id', array(10, 20));
* // will exclude users with id 10 and 20 from the select
* </code>
*
* @param string $expr the operand of the NOT IN
* @param mixed $params an array of parameters or a simple scalar
* @return Doctrine_Query this object
*/
public function whereNotIn($expr, $params = array())
{
return $this->whereIn($expr, $params, true);
}
/**
* Adds NOT IN condition to the query WHERE part
* Alias for @see whereNotIn().
*
* @param string $expr The operand of the NOT IN
* @param mixed $params An array of parameters or a simple scalar
* @return Doctrine_Query
*/
public function andWhereNotIn($expr, $params = array())
{
return $this->andWhereIn($expr, $params, true);
}
/**
* Adds NOT IN condition to the query WHERE part
*
* @param string $expr The operand of the NOT IN
* @param mixed $params An array of parameters or a simple scalar
* @return Doctrine_Query
*/
public function orWhereNotIn($expr, $params = array())
{
return $this->orWhereIn($expr, $params, true);
}
/**
* Adds fields to the GROUP BY part of the query.
* <code>
* $q->groupBy('u.id');
* </code>
*
* @param string $groupby Query GROUP BY part
* @return Doctrine_Query
*/
public function addGroupBy($groupby)
{
return $this->_addDqlQueryPart('groupby', $groupby, true);
}
/**
* Adds conditions to the HAVING part of the query.
*
* This methods add HAVING clauses. These clauses are used to narrow the
* results by operating on aggregated values.
* <code>
* $q->having('num_phonenumbers > ?', 1);
* </code>
*
* @param string $having Query HAVING part
* @param mixed $params an array of parameters or a simple scalar
* @return Doctrine_Query
*/
public function addHaving($having, $params = array())
{
if (is_array($params)) {
$this->_params['having'] = array_merge($this->_params['having'], $params);
} else {
$this->_params['having'][] = $params;
}
return $this->_addDqlQueryPart('having', $having, true);
}
/**
* addOrderBy
* adds fields to the ORDER BY part of the query
*
* @param string $orderby Query ORDER BY part
* @return Doctrine_Query
*/
public function addOrderBy($orderby)
{
return $this->_addDqlQueryPart('orderby', $orderby, true);
}
/**
* select
* sets the SELECT part of the query
*
* @param string $select Query SELECT part
* @return Doctrine_Query
*/
public function select($select = null)
{
$this->_type = self::SELECT;
if ($select) {
return $this->_addDqlQueryPart('select', $select);
} else {
return $this;
}
}
/**
* distinct
* Makes the query SELECT DISTINCT.
* <code>
* $q->distinct();
* </code>
*
* @param bool $flag Whether or not the SELECT is DISTINCT (default true).
* @return Doctrine_Query
*/
public function distinct($flag = true)
{
$this->_sqlParts['distinct'] = (bool) $flag;
return $this;
}
/**
* forUpdate
* Makes the query SELECT FOR UPDATE.
*
* @param bool $flag Whether or not the SELECT is FOR UPDATE (default true).
* @return Doctrine_Query
*/
public function forUpdate($flag = true)
{
$this->_sqlParts['forUpdate'] = (bool) $flag;
return $this;
}
/**
* delete
* sets the query type to DELETE
*
* @return Doctrine_Query
*/
public function delete($from = null)
{
$this->_type = self::DELETE;
if ($from != null) {
return $this->_addDqlQueryPart('from', $from);
}
return $this;
}
/**
* update
* sets the UPDATE part of the query
*
* @param string $update Query UPDATE part
* @return Doctrine_Query
*/
public function update($from = null)
{
$this->_type = self::UPDATE;
if ($from != null) {
return $this->_addDqlQueryPart('from', $from);
}
return $this;
}
/**
* set
* sets the SET part of the query
*
* @param string $update Query UPDATE part
* @return Doctrine_Query
*/
public function set($key, $value = null, $params = null)
{
if (is_array($key)) {
foreach ($key as $k => $v) {
$this->set($k, '?', array($v));
}
return $this;
} else {
if ($params !== null) {
if (is_array($params)) {
$this->_params['set'] = array_merge($this->_params['set'], $params);
} else {
$this->_params['set'][] = $params;
}
}
return $this->_addDqlQueryPart('set', $key . ' = ' . $value, true);
}
}
/**
* from
* sets the FROM part of the query
* <code>
* $q->from('User u');
* </code>
*
* @param string $from Query FROM part
* @return Doctrine_Query
*/
public function from($from)
{
return $this->_addDqlQueryPart('from', $from);
}
/**
* innerJoin
* appends an INNER JOIN to the FROM part of the query
*
* @param string $join Query INNER JOIN
* @return Doctrine_Query
*/
public function innerJoin($join, $params = array())
{
if (is_array($params)) {
$this->_params['join'] = array_merge($this->_params['join'], $params);
} else {
$this->_params['join'][] = $params;
}
return $this->_addDqlQueryPart('from', 'INNER JOIN ' . $join, true);
}
/**
* leftJoin
* appends a LEFT JOIN to the FROM part of the query
*
* @param string $join Query LEFT JOIN
* @return Doctrine_Query
*/
public function leftJoin($join, $params = array())
{
if (is_array($params)) {
$this->_params['join'] = array_merge($this->_params['join'], $params);
} else {
$this->_params['join'][] = $params;
}
return $this->_addDqlQueryPart('from', 'LEFT JOIN ' . $join, true);
}
/**
* groupBy
* sets the GROUP BY part of the query
*
* @param string $groupby Query GROUP BY part
* @return Doctrine_Query
*/
public function groupBy($groupby)
{
return $this->_addDqlQueryPart('groupby', $groupby);
}
/**
* where
* sets the WHERE part of the query
*
* @param string $join Query WHERE part
* @param mixed $params an array of parameters or a simple scalar
* @return Doctrine_Query
*/
public function where($where, $params = array())
{
$this->_params['where'] = array();
if (is_array($params)) {
$this->_params['where'] = $params;
} else {
$this->_params['where'][] = $params;
}
return $this->_addDqlQueryPart('where', $where);
}
/**
* having
* sets the HAVING part of the query
*
* @param string $having Query HAVING part
* @param mixed $params an array of parameters or a simple scalar
* @return Doctrine_Query
*/
public function having($having, $params = array())
{
$this->_params['having'] = array();
if (is_array($params)) {
$this->_params['having'] = $params;
} else {
$this->_params['having'][] = $params;
}
return $this->_addDqlQueryPart('having', $having);
}
/**
* Sets the ORDER BY part of the query.
* <code>
* $q->orderBy('u.name');
* $query->orderBy('u.birthDate DESC');
* </code>
*
* @param string $orderby Query ORDER BY part
* @return Doctrine_Query
*/
public function orderBy($orderby)
{
return $this->_addDqlQueryPart('orderby', $orderby);
}
/**
* limit
* sets the Query query limit
*
* @param integer $limit limit to be used for limiting the query results
* @return Doctrine_Query
*/
public function limit($limit)
{
return $this->_addDqlQueryPart('limit', $limit);
}
/**
* offset
* sets the Query query offset
*
* @param integer $offset offset to be used for paginating the query
* @return Doctrine_Query
*/
public function offset($offset)
{
return $this->_addDqlQueryPart('offset', $offset);
}
/**
* Resets all the sql parts.
*
* @return void
*/
protected function clear()
{
$this->_sqlParts = array(
'select' => array(),
'distinct' => false,
'forUpdate' => false,
'from' => array(),
'set' => array(),
'join' => array(),
'where' => array(),
'groupby' => array(),
'having' => array(),
'orderby' => array(),
'limit' => false,
'offset' => false,
);
}
public function setHydrationMode($hydrationMode)
{
$this->_hydrator->setHydrationMode($hydrationMode);
return $this;
}
/**
* Gets the components of this query.
*/
public function getQueryComponents()
{
return $this->_queryComponents;
}
/**
* Return the SQL parts.
*
* @return array The parts
*/
public function getSqlParts()
{
return $this->_sqlParts;
}
/**
* getType
*
* returns the type of this query object
* by default the type is Doctrine_Query_Abstract::SELECT but if update() or delete()
* are being called the type is Doctrine_Query_Abstract::UPDATE and Doctrine_Query_Abstract::DELETE,
* respectively
*
* @see Doctrine_Query_Abstract::SELECT
* @see Doctrine_Query_Abstract::UPDATE
* @see Doctrine_Query_Abstract::DELETE
*
* @return integer return the query type
*/
public function getType()
{
return $this->_type;
}
/**
* useResultCache
*
* @param Doctrine_Cache_Interface|bool $driver cache driver
* @param integer $timeToLive how long the cache entry is valid
* @param string $resultCacheHash The key to use for storing the queries result cache entry
* @return Doctrine_Hydrate this object
*/
public function useResultCache($driver = true, $timeToLive = null, $resultCacheHash = null)
{
if ($driver !== null && $driver !== true && ! ($driver instanceOf Doctrine_Cache_Interface)) {
$msg = 'First argument should be instance of Doctrine_Cache_Interface or null.';
throw new Doctrine_Query_Exception($msg);
}
$this->_resultCache = $driver;
$this->_resultCacheHash = $resultCacheHash;
if ($timeToLive !== null) {
$this->setResultCacheLifeSpan($timeToLive);
}
return $this;
}
/**
* Set the result cache hash to be used for storing the results in the cache driver
*
* @param string $resultCacheHash
* @return void
*/
public function setResultCacheHash($resultCacheHash)
{
$this->_resultCacheHash = $resultCacheHash;
return $this;
}
/**
* Clear the result cache entry for this query
*
* @return void
*/
public function clearResultCache()
{
$this->getResultCacheDriver()
->delete($this->getResultCacheHash());
return $this;
}
/**
* useQueryCache
*
* @param Doctrine_Cache_Interface|bool $driver cache driver
* @param integer $timeToLive how long the cache entry is valid
* @return Doctrine_Hydrate this object
*/
public function useQueryCache($driver = true, $timeToLive = null)
{
if ($driver !== null && $driver !== true && $driver !== false && ! ($driver instanceOf Doctrine_Cache_Interface)) {
$msg = 'First argument should be instance of Doctrine_Cache_Interface or null.';
throw new Doctrine_Query_Exception($msg);
}
$this->_queryCache = $driver;
if ($timeToLive !== null) {
$this->setQueryCacheLifeSpan($timeToLive);
}
return $this;
}
/**
* expireCache
*
* @param boolean $expire whether or not to force cache expiration
* @return Doctrine_Hydrate this object
*/
public function expireResultCache($expire = true)
{
$this->_expireResultCache = $expire;
return $this;
}
/**
* expireQueryCache
*
* @param boolean $expire whether or not to force cache expiration
* @return Doctrine_Hydrate this object
*/
public function expireQueryCache($expire = true)
{
$this->_expireQueryCache = $expire;
return $this;
}
/**
* setResultCacheLifeSpan
*
* @param integer $timeToLive how long the cache entry is valid (in seconds)
* @return Doctrine_Hydrate this object
*/
public function setResultCacheLifeSpan($timeToLive)
{
if ($timeToLive !== null) {
$timeToLive = (int) $timeToLive;
}
$this->_resultCacheTTL = $timeToLive;
return $this;
}
/**
* Gets the life span of the result cache in seconds.
*
* @return integer
*/
public function getResultCacheLifeSpan()
{
return $this->_resultCacheTTL;
}
/**
* setQueryCacheLifeSpan
*
* @param integer $timeToLive how long the cache entry is valid
* @return Doctrine_Hydrate this object
*/
public function setQueryCacheLifeSpan($timeToLive)
{
if ($timeToLive !== null) {
$timeToLive = (int) $timeToLive;
}
$this->_queryCacheTTL = $timeToLive;
return $this;
}
/**
* Gets the life span of the query cache the Query object is using.
*
* @return integer The life span in seconds.
*/
public function getQueryCacheLifeSpan()
{
return $this->_queryCacheTTL;
}
/**
* getResultCacheDriver
* returns the cache driver used for caching result sets
*
* @return Doctrine_Cache_Interface|boolean|null cache driver
*/
public function getResultCacheDriver()
{
if ($this->_resultCache instanceof Doctrine_Cache_Interface) {
return $this->_resultCache;
} else {
return $this->_conn->getResultCacheDriver();
}
}
/**
* getQueryCacheDriver
* returns the cache driver used for caching queries
*
* @return Doctrine_Cache_Interface|boolean|null cache driver
*/
public function getQueryCacheDriver()
{
if ($this->_queryCache instanceof Doctrine_Cache_Interface) {
return $this->_queryCache;
} else {
return $this->_conn->getQueryCacheDriver();
}
}
/**
* getConnection
*
* @return Doctrine_Connection
*/
public function getConnection()
{
return $this->_conn;
}
/**
* Checks if there's at least one DQL part defined to the internal parts collection.
*
* @param string $queryPartName The name of the query part.
* @return boolean
*/
protected function _hasDqlQueryPart($queryPartName)
{
return count($this->_dqlParts[$queryPartName]) > 0;
}
/**
* Adds a DQL part to the internal parts collection.
*
* This method add the part specified to the array named by $queryPartName.
* Most part names support multiple parts addition.
*
* @see $_dqlParts;
* @see Doctrine_Query::getDqlPart()
* @param string $queryPartName The name of the query part.
* @param string $queryPart The actual query part to add.
* @param boolean $append Whether to append $queryPart to already existing
* parts under the same $queryPartName. Defaults to FALSE
* (previously added parts with the same name get overridden).
*/
protected function _addDqlQueryPart($queryPartName, $queryPart, $append = false)
{
// We should prevent nullable query parts
if ($queryPart === null) {
throw new Doctrine_Query_Exception('Cannot define NULL as part of query when defining \'' . $queryPartName . '\'.');
}
if ($append) {
$this->_dqlParts[$queryPartName][] = $queryPart;
} else {
$this->_dqlParts[$queryPartName] = array($queryPart);
}
$this->_state = Doctrine_Query::STATE_DIRTY;
return $this;
}
/**
* _processDqlQueryPart
* parses given query part
*
* @param string $queryPartName the name of the query part
* @param array $queryParts an array containing the query part data
* @return Doctrine_Query this object
* @todo Better description. "parses given query part" ??? Then wheres the difference
* between process/parseQueryPart? I suppose this does something different.
*/
protected function _processDqlQueryPart($queryPartName, $queryParts)
{
$this->removeSqlQueryPart($queryPartName);
if (is_array($queryParts) && ! empty($queryParts)) {
foreach ($queryParts as $queryPart) {
$parser = $this->_getParser($queryPartName);
$sql = $parser->parse($queryPart);
if (isset($sql)) {
if ($queryPartName == 'limit' || $queryPartName == 'offset') {
$this->setSqlQueryPart($queryPartName, $sql);
} else {
$this->addSqlQueryPart($queryPartName, $sql);
}
}
}
}
}
/**
* _getParser
* parser lazy-loader
*
* @throws Doctrine_Query_Exception if unknown parser name given
* @return Doctrine_Query_Part
* @todo Doc/Description: What is the parameter for? Which parsers are available?
*/
protected function _getParser($name)
{
if ( ! isset($this->_parsers[$name])) {
$class = 'Doctrine_Query_' . ucwords(strtolower($name));
Doctrine_Core::autoload($class);
if ( ! class_exists($class)) {
throw new Doctrine_Query_Exception('Unknown parser ' . $name);
}
$this->_parsers[$name] = new $class($this, $this->_tokenizer);
}
return $this->_parsers[$name];
}
/**
* Gets the SQL query that corresponds to this query object.
* The returned SQL syntax depends on the connection driver that is used
* by this query object at the time of this method call.
*
* @param array $params
*/
abstract public function getSqlQuery($params = array());
/**
* parseDqlQuery
* parses a dql query
*
* @param string $query query to be parsed
* @return Doctrine_Query_Abstract this object
*/
abstract public function parseDqlQuery($query);
/**
* toString magic call
* this method is automatically called when Doctrine_Query object is trying to be used as a string
* So, it it converted into its DQL correspondant
*
* @return string DQL string
*/
public function __toString()
{
return $this->getDql();
}
}
|