Skip to content

D
doctrine-dbal
Commit c9f5132b authored by Benjamin Eberlei's avatar Benjamin Eberlei
Browse files
Options

Merge branch 'master' of github.com:doctrine/dbal

parents 8aa45b5e 10ff0e0e
Hide whitespace changes
Inline Side-by-side
Showing with 1715 additions and 3 deletions
lib/Doctrine/DBAL/Connection.php
View file @ c9f5132b
......@@ -100,6 +100,11 @@ class Connection implements DriverConnection
* @var Doctrine\Common\EventManager
*/
protected $_eventManager;
/**
* @var Doctrine\DBAL\Query\ExpressionBuilder
*/
protected $_expr;
/**
* Whether or not a connection has been established.
......@@ -195,6 +200,9 @@ class Connection implements DriverConnection
$this->_config = $config;
$this->_eventManager = $eventManager;
$this->_expr = new Query\Expression\ExpressionBuilder($this);
if ( ! isset($params['platform'])) {
$this->_platform = $driver->getDatabasePlatform();
} else if ($params['platform'] instanceof Platforms\AbstractPlatform) {
......@@ -202,6 +210,7 @@ class Connection implements DriverConnection
} else {
throw DBALException::invalidPlatformSpecified();
}
$this->_transactionIsolationLevel = $this->_platform->getDefaultTransactionIsolationLevel();
}
......@@ -304,7 +313,17 @@ class Connection implements DriverConnection
{
return $this->_platform;
}
/**
* Gets the ExpressionBuilder for the connection.
*
* @return Doctrine\DBAL\Query\ExpressionBuilder
*/
public function getExpressionBuilder()
{
return $this->_expr;
}
/**
* Establishes the connection with the database.
*
......
lib/Doctrine/DBAL/Logging/SQLLogger.php
View file @ c9f5132b
......@@ -40,7 +40,7 @@ interface SQLLogger
*
* @param string $sql The SQL to be executed.
* @param array $params The SQL parameters.
* @param float $executionMS The microtime difference it took to execute this query.
* @param array $types The SQL parameter types.
* @return void
*/
public function startQuery($sql, array $params = null, array $types = null);
......
lib/Doctrine/DBAL/Query/Expression/CompositeExpression.php 0 → 100644
View file @ c9f5132b
<?php
/*
* 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.doctrine-project.org>.
*/
namespace Doctrine\DBAL\Query\Expression;
/**
* Composite expression is responsible to build a group of similar expression.
*
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.org
* @since 2.0
* @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @author Benjamin Eberlei <kontakt@beberlei.de>
*/
class CompositeExpression implements \Countable
{
/**
* Constant that represents an AND composite expression
*/
const TYPE_AND = 'AND';
/**
* Constant that represents an OR composite expression
*/
const TYPE_OR = 'OR';
/**
* @var string Holds the instance type of composite expression
*/
private $type;
/**
* @var array Each expression part of the composite expression
*/
private $parts = array();
/**
* Constructor.
*
* @param string $type Instance type of composite expression
* @param array $parts Composition of expressions to be joined on composite expression
*/
public function __construct($type, array $parts = array())
{
$this->type = $type;
$this->addMultiple($parts);
}
/**
* Adds multiple parts to composite expression.
*
* @param array $args
*
* @return CompositeExpression
*/
public function addMultiple(array $parts = array())
{
foreach ((array) $parts as $part) {
$this->add($part);
}
return $this;
}
/**
* Adds an expression to composite expression.
*
* @param mixed $part
* @return CompositeExpression
*/
public function add($part)
{
if ( ! empty($part) || ($part instanceof self && $part->count() > 0)) {
$this->parts[] = $part;
}
return $this;
}
/**
* Retrieves the amount of expressions on composite expression.
*
* @return integer
*/
public function count()
{
return count($this->parts);
}
/**
* Retrieve the string representation of this composite expression.
*
* @return string
*/
public function __toString()
{
if ($this->count() === 1) {
return (string) $this->parts[0];
}
return '(' . implode(') ' . $this->type . ' (', $this->parts) . ')';
}
}
\ No newline at end of file
lib/Doctrine/DBAL/Query/Expression/ExpressionBuilder.php 0 → 100644
View file @ c9f5132b
<?php
/*
* 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.doctrine-project.org>.
*/
namespace Doctrine\DBAL\Query\Expression;
use Doctrine\DBAL\Connection;
/**
* ExpressionBuilder class is responsible to dynamically create SQL query parts.
*
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.com
* @since 1.0
* @version $Revision$
* @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @author Benjamin Eberlei <kontakt@beberlei.de>
*/
class ExpressionBuilder
{
const EQ = '=';
const NEQ = '<>';
const LT = '<';
const LTE = '<=';
const GT = '>';
const GTE = '>=';
/**
* @var Doctrine\DBAL\Connection DBAL Connection
*/
private $connection = null;
/**
* Initializes a new <tt>ExpressionBuilder</tt>.
*
* @param Doctrine\DBAL\Connection $connection DBAL Connection
*/
public function __construct(Connection $connection)
{
$this->connection = $connection;
}
/**
* Creates a conjunction of the given boolean expressions.
*
* Example:
*
* [php]
* // (u.type = ?) AND (u.role = ?)
* $expr->andX('u.type = ?', 'u.role = ?'));
*
* @param mixed $x Optional clause. Defaults = null, but requires
* at least one defined when converting to string.
* @return CompositeExpression
*/
public function andX($x = null)
{
return new CompositeExpression(CompositeExpression::TYPE_AND, func_get_args());
}
/**
* Creates a disjunction of the given boolean expressions.
*
* Example:
*
* [php]
* // (u.type = ?) OR (u.role = ?)
* $qb->where($qb->expr()->orX('u.type = ?', 'u.role = ?'));
*
* @param mixed $x Optional clause. Defaults = null, but requires
* at least one defined when converting to string.
* @return CompositeExpression
*/
public function orX($x = null)
{
return new CompositeExpression(CompositeExpression::TYPE_OR, func_get_args());
}
/**
* Creates a comparison expression.
*
* @param mixed $x Left expression
* @param string $operator One of the ExpressionBuikder::* constants.
* @param mixed $y Right expression
* @return string
*/
public function comparison($x, $operator, $y)
{
return $x . ' ' . $operator . ' ' . $y;
}
/**
* Creates an equality comparison expression with the given arguments.
*
* First argument is considered the left expression and the second is the right expression.
* When converted to string, it will generated a <left expr> = <right expr>. Example:
*
* [php]
* // u.id = ?
* $expr->eq('u.id', '?');
*
* @param mixed $x Left expression
* @param mixed $y Right expression
* @return string
*/
public function eq($x, $y)
{
return $this->comparison($x, self::EQ, $y);
}
/**
* Creates a non equality comparison expression with the given arguments.
* First argument is considered the left expression and the second is the right expression.
* When converted to string, it will generated a <left expr> <> <right expr>. Example:
*
* [php]
* // u.id <> 1
* $q->where($q->expr()->neq('u.id', '1'));
*
* @param mixed $x Left expression
* @param mixed $y Right expression
* @return string
*/
public function neq($x, $y)
{
return $this->comparison($x, self::NEQ, $y);
}
/**
* Creates a lower-than comparison expression with the given arguments.
* First argument is considered the left expression and the second is the right expression.
* When converted to string, it will generated a <left expr> < <right expr>. Example:
*
* [php]
* // u.id < ?
* $q->where($q->expr()->lt('u.id', '?'));
*
* @param mixed $x Left expression
* @param mixed $y Right expression
* @return string
*/
public function lt($x, $y)
{
return $this->comparison($x, self::LT, $y);
}
/**
* Creates a lower-than-equal comparison expression with the given arguments.
* First argument is considered the left expression and the second is the right expression.
* When converted to string, it will generated a <left expr> <= <right expr>. Example:
*
* [php]
* // u.id <= ?
* $q->where($q->expr()->lte('u.id', '?'));
*
* @param mixed $x Left expression
* @param mixed $y Right expression
* @return string
*/
public function lte($x, $y)
{
return $this->comparison($x, self::LTE, $y);
}
/**
* Creates a greater-than comparison expression with the given arguments.
* First argument is considered the left expression and the second is the right expression.
* When converted to string, it will generated a <left expr> > <right expr>. Example:
*
* [php]
* // u.id > ?
* $q->where($q->expr()->gt('u.id', '?'));
*
* @param mixed $x Left expression
* @param mixed $y Right expression
* @return string
*/
public function gt($x, $y)
{
return $this->comparison($x, self::GT, $y);
}
/**
* Creates a greater-than-equal comparison expression with the given arguments.
* First argument is considered the left expression and the second is the right expression.
* When converted to string, it will generated a <left expr> >= <right expr>. Example:
*
* [php]
* // u.id >= ?
* $q->where($q->expr()->gte('u.id', '?'));
*
* @param mixed $x Left expression
* @param mixed $y Right expression
* @return string
*/
public function gte($x, $y)
{
return $this->comparison($x, self::GTE, $y);
}
/**
* Creates an IS NULL expression with the given arguments.
*
* @param string $x Field in string format to be restricted by IS NULL
*
* @return string
*/
public function isNull($x)
{
return $x . ' IS NULL';
}
/**
* Creates an IS NOT NULL expression with the given arguments.
*
* @param string $x Field in string format to be restricted by IS NOT NULL
*
* @return string
*/
public function isNotNull($x)
{
return $x . ' IS NOT NULL';
}
/**
* Creates a LIKE() comparison expression with the given arguments.
*
* @param string $x Field in string format to be inspected by LIKE() comparison.
* @param mixed $y Argument to be used in LIKE() comparison.
*
* @return string
*/
public function like($x, $y)
{
return $this->comparison($x, 'LIKE', $y);
}
/**
* Quotes a given input parameter.
*
* @param mixed $input Parameter to be quoted.
* @param string $type Type of the parameter.
*
* @return string
*/
public function literal($input, $type = null)
{
return $this->connection->quote($input, $type);
}
}
\ No newline at end of file
lib/Doctrine/DBAL/Query/QueryBuilder.php 0 → 100644
View file @ c9f5132b
<?php
/*
* 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.doctrine-project.org>.
*/
namespace Doctrine\DBAL\Query;
use Doctrine\DBAL\Query\Expression\CompositeExpression,
Doctrine\DBAL\Connection;
/**
* QueryBuilder class is responsible to dynamically create SQL queries.
*
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.com
* @since 1.0
* @version $Revision$
* @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @author Benjamin Eberlei <kontakt@beberlei.de>
*/
class QueryBuilder
{
/* The query types. */
const SELECT = 0;
const DELETE = 1;
const UPDATE = 2;
/** The builder states. */
const STATE_DIRTY = 0;
const STATE_CLEAN = 1;
/**
* @var Doctrine\DBAL\Connection DBAL Connection
*/
private $connection = null;
/**
* @var array The array of DQL parts collected.
*/
private $sqlParts = array(
'select' => array(),
'from' => array(),
'join' => array(),
'set' => array(),
'where' => null,
'groupBy' => array(),
'having' => null,
'orderBy' => array()
);
/**
* @var string The complete SQL string for this query.
*/
private $sql;
/**
* @var array The query parameters.
*/
private $params = array();
/**
* @var array The parameter type map of this query.
*/
private $paramTypes = array();
/**
* @var integer The type of query this is. Can be select, update or delete.
*/
private $type = self::SELECT;
/**
* @var integer The state of the query object. Can be dirty or clean.
*/
private $state = self::STATE_CLEAN;
/**
* @var integer The index of the first result to retrieve.
*/
private $firstResult = null;
/**
* @var integer The maximum number of results to retrieve.
*/
private $maxResults = null;
/**
* Initializes a new <tt>QueryBuilder</tt>.
*
* @param Doctrine\DBAL\Connection $connection DBAL Connection
*/
public function __construct(Connection $connection)
{
$this->connection = $connection;
}
/**
* Gets an ExpressionBuilder used for object-oriented construction of query expressions.
* This producer method is intended for convenient inline usage. Example:
*
* <code>
* $qb = $conn->createQueryBuilder()
* ->select('u')
* ->from('users', 'u')
* ->where($qb->expr()->eq('u.id', 1));
* </code>
*
* For more complex expression construction, consider storing the expression
* builder object in a local variable.
*
* @return Doctrine\DBAL\Query\ExpressionBuilder
*/
public function expr()
{
return $this->connection->getExpressionBuilder();
}
/**
* Get the type of the currently built query.
*
* @return integer
*/
public function getType()
{
return $this->type;
}
/**
* Get the associated DBAL Connection for this query builder.
*
* @return Doctrine\DBAL\Connection
*/
public function getConnection()
{
return $this->connection;
}
/**
* Get the state of this query builder instance.
*
* @return integer Either QueryBuilder::STATE_DIRTY or QueryBuilder::STATE_CLEAN.
*/
public function getState()
{
return $this->state;
}
/**
* Get the complete DQL string formed by the current specifications of this QueryBuilder.
*
* <code>
* $qb = $em->createQueryBuilder()
* ->select('u')
* ->from('User', 'u')
* echo $qb->getDql(); // SELECT u FROM User u
* </code>
*
* @return string The DQL query string.
*/
public function getSQL()
{
if ($this->sql !== null && $this->state === self::STATE_CLEAN) {
return $this->sql;
}
$sql = '';
switch ($this->type) {
case self::DELETE:
$sql = $this->getSQLForDelete();
break;
case self::UPDATE:
$sql = $this->getSQLForUpdate();
break;
case self::SELECT:
default:
$sql = $this->getSQLForSelect();
break;
}
$this->state = self::STATE_CLEAN;
$this->sql = $sql;
return $sql;
}
/**
* Sets a query parameter for the query being constructed.
*
* <code>
* $qb = $conn->createQueryBuilder()
* ->select('u')
* ->from('users', 'u')
* ->where('u.id = :user_id')
* ->setParameter(':user_id', 1);
* </code>
*
* @param string|integer $key The parameter position or name.
* @param mixed $value The parameter value.
* @param string|null $type PDO::PARAM_*
* @return QueryBuilder This QueryBuilder instance.
*/
public function setParameter($key, $value, $type = null)
{
if ($type !== null) {
$this->paramTypes[$key] = $type;
}
$this->params[$key] = $value;
return $this;
}
/**
* Sets a collection of query parameters for the query being constructed.
*
* <code>
* $qb = $conn->createQueryBuilder()
* ->select('u')
* ->from('users', 'u')
* ->where('u.id = :user_id1 OR u.id = :user_id2')
* ->setParameters(array(
* ':user_id1' => 1,
* ':user_id2' => 2
* ));
* </code>
*
* @param array $params The query parameters to set.
* @return QueryBuilder This QueryBuilder instance.
*/
public function setParameters(array $params, array $types = array())
{
$this->paramTypes = $types;
$this->params = $params;
return $this;
}
/**
* Gets all defined query parameters for the query being constructed.
*
* @return array The currently defined query parameters.
*/
public function getParameters()
{
return $this->params;
}
/**
* Gets a (previously set) query parameter of the query being constructed.
*
* @param mixed $key The key (index or name) of the bound parameter.
* @return mixed The value of the bound parameter.
*/
public function getParameter($key)
{
return isset($this->params[$key]) ? $this->params[$key] : null;
}
/**
* Sets the position of the first result to retrieve (the "offset").
*
* @param integer $firstResult The first result to return.
* @return Doctrine\DBAL\Query\QueryBuilder This QueryBuilder instance.
*/
public function setFirstResult($firstResult)
{
$this->firstResult = $firstResult;
return $this;
}
/**
* Gets the position of the first result the query object was set to retrieve (the "offset").
* Returns NULL if {@link setFirstResult} was not applied to this QueryBuilder.
*
* @return integer The position of the first result.
*/
public function getFirstResult()
{
return $this->firstResult;
}
/**
* Sets the maximum number of results to retrieve (the "limit").
*
* @param integer $maxResults The maximum number of results to retrieve.
* @return Doctrine\DBAL\Query\QueryBuilder This QueryBuilder instance.
*/
public function setMaxResults($maxResults)
{
$this->maxResults = $maxResults;
return $this;
}
/**
* Gets the maximum number of results the query object was set to retrieve (the "limit").
* Returns NULL if {@link setMaxResults} was not applied to this query builder.
*
* @return integer Maximum number of results.
*/
public function getMaxResults()
{
return $this->maxResults;
}
/**
* Either appends to or replaces a single, generic query part.
*
* The available parts are: 'select', 'from', 'set', 'where',
* 'groupBy', 'having' and 'orderBy'.
*
* @param string $sqlPartName
* @param string $sqlPart
* @param string $append
* @return Doctrine\DBAL\Query\QueryBuilder This QueryBuilder instance.
*/
public function add($sqlPartName, $sqlPart, $append = false)
{
$isMultiple = is_array($this->sqlParts[$sqlPartName]);
if ($isMultiple && ! is_array($sqlPart)) {
$sqlPart = array($sqlPart);
}
$this->state = self::STATE_DIRTY;
if ($append) {
$key = key($sqlPart);
if (is_array($sqlPart[$key])) {
$this->sqlParts[$sqlPartName][$key][] = $sqlPart[$key];
} else if ($isMultiple) {
$this->sqlParts[$sqlPartName][] = $sqlPart;
} else {
$this->sqlParts[$sqlPartName] = $sqlPart;
}
return $this;
}
$this->sqlParts[$sqlPartName] = $sqlPart;
return $this;
}
/**
* Specifies an item that is to be returned in the query result.
* Replaces any previously specified selections, if any.
*
* <code>
* $qb = $conn->createQueryBuilder()
* ->select('u.id', 'p.id')
* ->from('users', 'u')
* ->leftJoin('u', 'phonenumbers', 'p', 'u.id = p.user_id');
* </code>
*
* @param mixed $select The selection expressions.
* @return QueryBuilder This QueryBuilder instance.
*/
public function select($select = null)
{
$this->type = self::SELECT;
if (empty($select)) {
return $this;
}
$selects = is_array($select) ? $select : func_get_args();
return $this->add('select', $selects, false);
}
/**
* Adds an item that is to be returned in the query result.
*
* <code>
* $qb = $conn->createQueryBuilder()
* ->select('u.id')
* ->addSelect('p.id')
* ->from('users', 'u')
* ->leftJoin('u', 'phonenumbers', 'u.id = p.user_id');
* </code>
*
* @param mixed $select The selection expression.
* @return QueryBuilder This QueryBuilder instance.
*/
public function addSelect($select = null)
{
$this->type = self::SELECT;
if (empty($select)) {
return $this;
}
$selects = is_array($select) ? $select : func_get_args();
return $this->add('select', $selects, true);
}
/**
* Turns the query being built into a bulk delete query that ranges over
* a certain entity type.
*
* <code>
* $qb = $conn->createQueryBuilder()
* ->delete('users', 'u')
* ->where('u.id = :user_id');
* ->setParameter(':user_id', 1);
* </code>
*
* @param string $delete The class/type whose instances are subject to the deletion.
* @param string $alias The class/type alias used in the constructed query.
* @return QueryBuilder This QueryBuilder instance.
*/
public function delete($delete = null, $alias = null)
{
$this->type = self::DELETE;
if ( ! $delete) {
return $this;
}
return $this->add('from', array(
'table' => $delete,
'alias' => $alias
));
}
/**
* Turns the query being built into a bulk update query that ranges over
* a certain entity type.
*
* <code>
* $qb = $conn->createQueryBuilder()
* ->update('users', 'u')
* ->set('u.password', md5('password'))
* ->where('u.id = ?');
* </code>
*
* @param string $update The class/type whose instances are subject to the update.
* @param string $alias The class/type alias used in the constructed query.
* @return QueryBuilder This QueryBuilder instance.
*/
public function update($update = null, $alias = null)
{
$this->type = self::UPDATE;
if ( ! $update) {
return $this;
}
return $this->add('from', array(
'table' => $update,
'alias' => $alias
));
}
/**
* Create and add a query root corresponding to the entity identified by the
* given alias, forming a cartesian product with any existing query roots.
*
* <code>
* $qb = $conn->createQueryBuilder()
* ->select('u.id')
* ->from('users', 'u')
* </code>
*
* @param string $from The class name.
* @param string $alias The alias of the class.
* @return QueryBuilder This QueryBuilder instance.
*/
public function from($from, $alias)
{
return $this->add('from', array(
'table' => $from,
'alias' => $alias
), true);
}
/**
* Creates and adds a join over an entity association to the query.
*
* The entities in the joined association will be fetched as part of the query
* result if the alias used for the joined association is placed in the select
* expressions.
*
* <code>
* $qb = $conn->createQueryBuilder()
* ->select('u.name')
* ->from('users', 'u')
* ->join('u', 'phonenumbers', 'p', 'p.is_primary = 1');
* </code>
*
* @param string $fromAlias The alias that points to a from clause
* @param string $join The table name to join
* @param string $alias The alias of the join table
* @param string $condition The condition for the join
* @return QueryBuilder This QueryBuilder instance.
*/
public function join($fromAlias, $join, $alias, $condition = null)
{
return $this->innerJoin($fromAlias, $join, $alias, $condition);
}
/**
* Creates and adds a join over an entity association to the query.
*
* The entities in the joined association will be fetched as part of the query
* result if the alias used for the joined association is placed in the select
* expressions.
*
* <code>
* $qb = $conn->createQueryBuilder()
* ->select('u.name')
* ->from('users', 'u')
* ->innerJoin('u', 'phonenumbers', 'p', 'p.is_primary = 1');
* </code>
*
* @param string $fromAlias The alias that points to a from clause
* @param string $join The table name to join
* @param string $alias The alias of the join table
* @param string $condition The condition for the join
* @return QueryBuilder This QueryBuilder instance.
*/
public function innerJoin($fromAlias, $join, $alias, $condition = null)
{
return $this->add('join', array(
$fromAlias => array(
'joinType' => 'inner',
'joinTable' => $join,
'joinAlias' => $alias,
'joinCondition' => $condition
)
), true);
}
/**
* Creates and adds a left join over an entity association to the query.
*
* The entities in the joined association will be fetched as part of the query
* result if the alias used for the joined association is placed in the select
* expressions.
*
* <code>
* $qb = $conn->createQueryBuilder()
* ->select('u.name')
* ->from('users', 'u')
* ->leftJoin('u', 'phonenumbers', 'p', 'p.is_primary = 1');
* </code>
*
* @param string $fromAlias The alias that points to a from clause
* @param string $join The table name to join
* @param string $alias The alias of the join table
* @param string $condition The condition for the join
* @return QueryBuilder This QueryBuilder instance.
*/
public function leftJoin($fromAlias, $join, $alias, $condition = null)
{
return $this->add('join', array(
$fromAlias => array(
'joinType' => 'left',
'joinTable' => $join,
'joinAlias' => $alias,
'joinCondition' => $condition
)
), true);
}
/**
* Sets a new value for a field in a bulk update query.
*
* <code>
* $qb = $conn->createQueryBuilder()
* ->update('users', 'u')
* ->set('u.password', md5('password'))
* ->where('u.id = ?');
* </code>
*
* @param string $key The key/field to set.
* @param string $value The value, expression, placeholder, etc.
* @return QueryBuilder This QueryBuilder instance.
*/
public function set($key, $value)
{
return $this->add('set', $this->expr()->eq($key, '=', $value), true);
}
/**
* Specifies one or more restrictions to the query result.
* Replaces any previously specified restrictions, if any.
*
* <code>
* $qb = $conn->createQueryBuilder()
* ->select('u.name')
* ->from('users', 'u')
* ->where('u.id = ?');
*
* // You can optionally programatically build and/or expressions
* $qb = $conn->createQueryBuilder();
*
* $or = $qb->expr()->orx();
* $or->add($qb->expr()->eq('u.id', 1));
* $or->add($qb->expr()->eq('u.id', 2));
*
* $qb->update('users', 'u')
* ->set('u.password', md5('password'))
* ->where($or);
* </code>
*
* @param mixed $predicates The restriction predicates.
* @return QueryBuilder This QueryBuilder instance.
*/
public function where($predicates)
{
if ( ! (func_num_args() == 1 && $predicates instanceof CompositeExpression)) {
$predicates = $this->expr()->andX(func_get_args());
}
return $this->add('where', $predicates);
}
/**
* Adds one or more restrictions to the query results, forming a logical
* conjunction with any previously specified restrictions.
*
* <code>
* $qb = $conn->createQueryBuilder()
* ->select('u')
* ->from('users', 'u')
* ->where('u.username LIKE ?')
* ->andWhere('u.is_active = 1');
* </code>
*
* @param mixed $where The query restrictions.
* @return QueryBuilder This QueryBuilder instance.
* @see where()
*/
public function andWhere($where)
{
$where = $this->getQueryPart('where');
$args = func_get_args();
if ($where instanceof CompositeExpression && $where->getType() === CompositeExpression::TYPE_AND) {
$where->addMultiple($args);
} else {
array_unshift($args, $where);
$where = $this->expr()->andX($args);
}
return $this->add('where', $where, true);
}
/**
* Adds one or more restrictions to the query results, forming a logical
* disjunction with any previously specified restrictions.
*
* <code>
* $qb = $em->createQueryBuilder()
* ->select('u.name')
* ->from('users', 'u')
* ->where('u.id = 1')
* ->orWhere('u.id = 2');
* </code>
*
* @param mixed $where The WHERE statement
* @return QueryBuilder $qb
* @see where()
*/
public function orWhere($where)
{
$where = $this->getQueryPart('where');
$args = func_get_args();
if ($where instanceof CompositeExpression && $where->getType() === CompositeExpression::TYPE_OR) {
$where->addMultiple($args);
} else {
array_unshift($args, $where);
$where = $this->expr()->orX($args);
}
return $this->add('where', $where, true);
}
/**
* Specifies a grouping over the results of the query.
* Replaces any previously specified groupings, if any.
*
* <code>
* $qb = $conn->createQueryBuilder()
* ->select('u.name')
* ->from('users', 'u')
* ->groupBy('u.id');
* </code>
*
* @param mixed $groupBy The grouping expression.
* @return QueryBuilder This QueryBuilder instance.
*/
public function groupBy($groupBy)
{
if (empty($groupBy)) {
return $this;
}
$groupBy = is_array($groupBy) ? $groupBy : func_get_args();
return $this->add('groupBy', $groupBy, false);
}
/**
* Adds a grouping expression to the query.
*
* <code>
* $qb = $conn->createQueryBuilder()
* ->select('u.name')
* ->from('users', 'u')
* ->groupBy('u.lastLogin');
* ->addGroupBy('u.createdAt')
* </code>
*
* @param mixed $groupBy The grouping expression.
* @return QueryBuilder This QueryBuilder instance.
*/
public function addGroupBy($groupBy)
{
if (empty($groupBy)) {
return $this;
}
$groupBy = is_array($groupBy) ? $groupBy : func_get_args();
return $this->add('groupBy', $groupBy, true);
}
/**
* Specifies a restriction over the groups of the query.
* Replaces any previous having restrictions, if any.
*
* @param mixed $having The restriction over the groups.
* @return QueryBuilder This QueryBuilder instance.
*/
public function having($having)
{
if ( ! (func_num_args() == 1 && $having instanceof CompositeExpression)) {
$having = $this->expr()->andX(func_get_args());
}
return $this->add('having', $having);
}
/**
* Adds a restriction over the groups of the query, forming a logical
* conjunction with any existing having restrictions.
*
* @param mixed $having The restriction to append.
* @return QueryBuilder This QueryBuilder instance.
*/
public function andHaving($having)
{
$having = $this->getQueryPart('having');
$args = func_get_args();
if ($having instanceof CompositeExpression && $where->getType() === CompositeExpression::TYPE_AND) {
$having->addMultiple($args);
} else {
array_unshift($args, $having);
$having = $this->expr()->andX($args);
}
return $this->add('having', $having);
}
/**
* Adds a restriction over the groups of the query, forming a logical
* disjunction with any existing having restrictions.
*
* @param mixed $having The restriction to add.
* @return QueryBuilder This QueryBuilder instance.
*/
public function orHaving($having)
{
$having = $this->getQueryPart('having');
$args = func_get_args();
if ($having instanceof CompositeExpression && $where->getType() === CompositeExpression::TYPE_OR) {
$having->addMultiple($args);
} else {
array_unshift($args, $having);
$having = $this->expr()->orX($args);
}
return $this->add('having', $having);
}
/**
* Specifies an ordering for the query results.
* Replaces any previously specified orderings, if any.
*
* @param string $sort The ordering expression.
* @param string $order The ordering direction.
* @return QueryBuilder This QueryBuilder instance.
*/
public function orderBy($sort, $order = null)
{
return $this->add('orderBy', array(
'sort' => $sort,
'order' => ! $order ? 'ASC' : $order
), false);
}
/**
* Adds an ordering to the query results.
*
* @param string $sort The ordering expression.
* @param string $order The ordering direction.
* @return QueryBuilder This QueryBuilder instance.
*/
public function addOrderBy($sort, $order = null)
{
return $this->add('orderBy', array(
'sort' => $sort,
'order' => ! $order ? 'ASC' : $order
), true);
}
/**
* Get a query part by its name.
*
* @param string $queryPartName
* @return mixed $queryPart
*/
public function getQueryPart($queryPartName)
{
return $this->sqlParts[$queryPartName];
}
/**
* Get all query parts.
*
* @return array $sqlParts
*/
public function getQueryParts()
{
return $this->sqlParts;
}
/**
* Reset DQL parts
*
* @param array $queryPartNames
* @return QueryBuilder
*/
public function resetQueryParts($queryPartNames = null)
{
if (is_null($queryPartNames)) {
$queryPartNames = array_keys($this->sqlParts);
}
foreach ($queryPartNames as $queryPartName) {
$this->resetQueryPart($queryPartName);
}
return $this;
}
/**
* Reset single DQL part
*
* @param string $queryPartName
* @return QueryBuilder
*/
public function resetQueryPart($queryPartName)
{
$this->sqlParts[$queryPartName] = is_array($this->sqlParts[$queryPartName])
? array() : null;
$this->state = self::STATE_DIRTY;
return $this;
}
/**
* Converts this instance into a SELECT string in SQL.
*
* @return string
*/
private function getSQLForSelect()
{
$query = 'SELECT ' . implode(', ', $this->sqlParts['select']) . ' FROM ';
$fromClauses = array();
// Loop through all FROM clauses
foreach ($this->sqlParts['from'] as $from) {
$fromClause = $from['table'] . ' ' . $from['alias'];
if (isset($this->sqlParts['join'][$from['alias']])) {
foreach ($this->sqlParts['join'][$from['alias']] as $join) {
$fromClause .= ' ' . strtoupper($join['joinType'])
. ' JOIN ' . $join['joinTable'] . ' ' . $join['joinAlias']
. ' ON ' . ((string) $join['joinCondition']);
}
}
$fromClauses[] = $fromClause;
}
$query .= implode(', ', $fromClauses)
. ($this->sqlParts['where'] !== null ? ' WHERE ' . ((string) $this->sqlParts['where']) : '')
. ($this->sqlParts['groupBy'] ? ' GROUP BY ' . implode(', ', $this->sqlParts['groupBy']) : '')
. ($this->sqlParts['having'] !== null ? ' HAVING ' . ((string) $this->sqlParts['having']) : '')
. ($this->sqlParts['orderBy'] ? ' ORDER BY ' . implode(', ', $this->sqlParts['orderBy']) : '');
return ($this->maxResults === null)
? $query
: $this->connection->getDatabasePlatform()->modifyLimitQuery($query, $this->maxResults, $this->firstResult);
}
/**
* Converts this instance into an UPDATE string in SQL.
*
* @return string
*/
private function getSQLForUpdate()
{
$query = 'UPDATE ';
return $query;
}
/**
* Converts this instance into a DELETE string in SQL.
*
* @return string
*/
private function getSQLForDelete()
{
$query = 'DELETE ';
return $query;
}
/**
* Gets a string representation of this QueryBuilder which corresponds to
* the final SQL query being constructed.
*
* @return string The string representation of this QueryBuilder.
*/
public function __toString()
{
return $this->getSQL();
}
}
\ No newline at end of file
Console @ 4200b4bc
Subproject commit 76280e55c7058afcbce623eae571cf1bf7c22b84
Subproject commit 4200b4bc95ae3c1b03d943cd875277e35a17898a
tests/Doctrine/Tests/DBAL/AllTests.php
View file @ c9f5132b
......@@ -55,6 +55,11 @@ class AllTests
$suite->addTestSuite('Doctrine\Tests\DBAL\Schema\ComparatorTest');
$suite->addTestSuite('Doctrine\Tests\DBAL\Schema\SchemaDiffTest');
// Query Builder tests
$suite->addTestSuite('Doctrine\Tests\DBAL\Query\Expression\CompositeExpressionTest');
$suite->addTestSuite('Doctrine\Tests\DBAL\Query\Expression\ExpressionBuilderTest');
$suite->addTestSuite('Doctrine\Tests\DBAL\Query\QueryBuilderTest');
// Driver manager test
$suite->addTestSuite('Doctrine\Tests\DBAL\DriverManagerTest');
......
tests/Doctrine/Tests/DBAL/Query/Expression/CompositeExpressionTest.php 0 → 100644
View file @ c9f5132b
<?php
namespace Doctrine\Tests\DBAL\Query\Expression;
use Doctrine\DBAL\Query\Expression\CompositeExpression;
require_once __DIR__ . '/../../../TestInit.php';
class CompositeExpressionTest extends \Doctrine\Tests\DbalTestCase
{
public function testCount()
{
$expr = new CompositeExpression(CompositeExpression::TYPE_OR, array('u.group_id = 1'));
$this->assertEquals(1, count($expr));
$expr->add('u.group_id = 2');
$this->assertEquals(2, count($expr));
}
/**
* @dataProvider provideDataForConvertToString
*/
public function testCompositeUsageAndGeneration($type, $parts, $expects)
{
$expr = new CompositeExpression($type, $parts);
$this->assertEquals($expects, (string) $expr);
}
public function provideDataForConvertToString()
{
return array(
array(
CompositeExpression::TYPE_AND,
array('u.user = 1'),
'u.user = 1'
),
array(
CompositeExpression::TYPE_AND,
array('u.user = 1', 'u.group_id = 1'),
'(u.user = 1) AND (u.group_id = 1)'
),
array(
CompositeExpression::TYPE_OR,
array('u.user = 1'),
'u.user = 1'
),
array(
CompositeExpression::TYPE_OR,
array('u.group_id = 1', 'u.group_id = 2'),
'(u.group_id = 1) OR (u.group_id = 2)'
),
array(
CompositeExpression::TYPE_AND,
array(
'u.user = 1',
new CompositeExpression(
CompositeExpression::TYPE_OR,
array('u.group_id = 1', 'u.group_id = 2')
)
),
'(u.user = 1) AND ((u.group_id = 1) OR (u.group_id = 2))'
),
array(
CompositeExpression::TYPE_OR,
array(
'u.group_id = 1',
new CompositeExpression(
CompositeExpression::TYPE_AND,
array('u.user = 1', 'u.group_id = 2')
)
),
'(u.group_id = 1) OR ((u.user = 1) AND (u.group_id = 2))'
),
);
}
}
\ No newline at end of file
tests/Doctrine/Tests/DBAL/Query/Expression/ExpressionBuilderTest.php 0 → 100644
View file @ c9f5132b
<?php
namespace Doctrine\Tests\DBAL\Query\Expression;
use Doctrine\DBAL\Query\Expression\ExpressionBuilder,
Doctrine\DBAL\Query\Expression\CompositeExpression;
require_once __DIR__ . '/../../../TestInit.php';
class ExpressionBuilderTest extends \Doctrine\Tests\DbalTestCase
{
protected $expr;
public function setUp()
{
$conn = $this->getMock('Doctrine\DBAL\Connection', array(), array(), '', false);
$this->expr = new ExpressionBuilder($conn);
$conn->expects($this->any())
->method('getExpressionBuilder')
->will($this->returnValue($this->expr));
}
/**
* @dataProvider provideDataForAndX
*/
public function testAndX($parts, $expected)
{
$composite = $this->expr->andX();
foreach ($parts as $part) {
$composite->add($part);
}
$this->assertEquals($expected, (string) $composite);
}
public function provideDataForAndX()
{
return array(
array(
array('u.user = 1'),
'u.user = 1'
),
array(
array('u.user = 1', 'u.group_id = 1'),
'(u.user = 1) AND (u.group_id = 1)'
),
array(
array('u.user = 1'),
'u.user = 1'
),
array(
array('u.group_id = 1', 'u.group_id = 2'),
'(u.group_id = 1) AND (u.group_id = 2)'
),
array(
array(
'u.user = 1',
new CompositeExpression(
CompositeExpression::TYPE_OR,
array('u.group_id = 1', 'u.group_id = 2')
)
),
'(u.user = 1) AND ((u.group_id = 1) OR (u.group_id = 2))'
),
array(
array(
'u.group_id = 1',
new CompositeExpression(
CompositeExpression::TYPE_AND,
array('u.user = 1', 'u.group_id = 2')
)
),
'(u.group_id = 1) AND ((u.user = 1) AND (u.group_id = 2))'
),
);
}
/**
* @dataProvider provideDataForOrX
*/
public function testOrX($parts, $expected)
{
$composite = $this->expr->orX();
foreach ($parts as $part) {
$composite->add($part);
}
$this->assertEquals($expected, (string) $composite);
}
public function provideDataForOrX()
{
return array(
array(
array('u.user = 1'),
'u.user = 1'
),
array(
array('u.user = 1', 'u.group_id = 1'),
'(u.user = 1) OR (u.group_id = 1)'
),
array(
array('u.user = 1'),
'u.user = 1'
),
array(
array('u.group_id = 1', 'u.group_id = 2'),
'(u.group_id = 1) OR (u.group_id = 2)'
),
array(
array(
'u.user = 1',
new CompositeExpression(
CompositeExpression::TYPE_OR,
array('u.group_id = 1', 'u.group_id = 2')
)
),
'(u.user = 1) OR ((u.group_id = 1) OR (u.group_id = 2))'
),
array(
array(
'u.group_id = 1',
new CompositeExpression(
CompositeExpression::TYPE_AND,
array('u.user = 1', 'u.group_id = 2')
)
),
'(u.group_id = 1) OR ((u.user = 1) AND (u.group_id = 2))'
),
);
}
/**
* @dataProvider provideDataForComparison
*/
public function testComparison($leftExpr, $operator, $rightExpr, $expected)
{
$part = $this->expr->comparison($leftExpr, $operator, $rightExpr);
$this->assertEquals($expected, (string) $part);
}
public function provideDataForComparison()
{
return array(
array('u.user_id', ExpressionBuilder::EQ, '1', 'u.user_id = 1'),
array('u.user_id', ExpressionBuilder::NEQ, '1', 'u.user_id <> 1'),
array('u.salary', ExpressionBuilder::LT, '10000', 'u.salary < 10000'),
array('u.salary', ExpressionBuilder::LTE, '10000', 'u.salary <= 10000'),
array('u.salary', ExpressionBuilder::GT, '10000', 'u.salary > 10000'),
array('u.salary', ExpressionBuilder::GTE, '10000', 'u.salary >= 10000'),
);
}
public function testEq()
{
$this->assertEquals('u.user_id = 1', $this->expr->eq('u.user_id', '1'));
}
public function testNeq()
{
$this->assertEquals('u.user_id <> 1', $this->expr->neq('u.user_id', '1'));
}
public function testLt()
{
$this->assertEquals('u.salary < 10000', $this->expr->lt('u.salary', '10000'));
}
public function testLte()
{
$this->assertEquals('u.salary <= 10000', $this->expr->lte('u.salary', '10000'));
}
public function testGt()
{
$this->assertEquals('u.salary > 10000', $this->expr->gt('u.salary', '10000'));
}
public function testGte()
{
$this->assertEquals('u.salary >= 10000', $this->expr->gte('u.salary', '10000'));
}
public function testIsNull()
{
$this->assertEquals('u.deleted IS NULL', $this->expr->isNull('u.deleted'));
}
public function testIsNotNull()
{
$this->assertEquals('u.updated IS NOT NULL', $this->expr->isNotNull('u.updated'));
}
}
\ No newline at end of file
tests/Doctrine/Tests/DBAL/Query/QueryBuilderTest.php 0 → 100644
View file @ c9f5132b
<?php
namespace Doctrine\Tests\DBAL\Query;
use Doctrine\DBAL\Query\Expression\ExpressionBuilder,
Doctrine\DBAL\Query\QueryBuilder;
require_once __DIR__ . '/../../TestInit.php';
class QueryBuilderTest extends \Doctrine\Tests\DbalTestCase
{
protected $conn;
public function setUp()
{
$this->conn = $this->getMock('Doctrine\DBAL\Connection', array(), array(), '', false);
$expressionBuilder = new ExpressionBuilder($this->conn);
$this->conn->expects($this->any())
->method('getExpressionBuilder')
->will($this->returnValue($expressionBuilder));
}
public function testSimpleSelect()
{
$qb = new QueryBuilder($this->conn);
$qb->select('u.id')
->from('users', 'u');
$this->assertEquals('SELECT u.id FROM users u', (string) $qb);
}
public function testSelectWithSimpleWhere()
{
$qb = new QueryBuilder($this->conn);
$expr = $qb->expr();
$qb->select('u.id')
->from('users', 'u')
->where($expr->andX($expr->eq('u.nickname', '?')));
$this->assertEquals("SELECT u.id FROM users u WHERE u.nickname = ?", (string) $qb);
}
public function testSelectWithJoin()
{
$qb = new QueryBuilder($this->conn);
$expr = $qb->expr();
$qb->select('u.*', 'p.*')
->from('users', 'u')
->leftJoin('u', 'phones', 'p', $expr->eq('p.user_id', 'u.id'));
$this->assertEquals('SELECT u.*, p.* FROM users u LEFT JOIN phones p ON p.user_id = u.id', (string) $qb);
}
}
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment