* $q = new Doctrine_Query();
* $e = $q->expr;
* $q->select('*')->from('table')
* ->where($e->eq('id', $e->not('null'));
*
*
* @param string $expression
*
* @return string a logical expression
*/
public function getNotExpression($expression)
{
return 'NOT(' . $expression . ')';
}
/**
* Returns the SQL to check if a value is one in a set of
* given values.
*
* in() accepts an arbitrary number of parameters. The first parameter
* must always specify the value that should be matched against. Successive
* must contain a logical expression or an array with logical expressions.
* These expressions will be matched against the first parameter.
*
* @param string $column the value that should be matched against
* @param string|array
* $qb = $conn->createQueryBuilder()
* ->select('u')
* ->from('users', 'u')
* ->where($qb->expr()->eq('u.id', 1));
*
*
* For more complex expression construction, consider storing the expression
* builder object in a local variable.
*
* @return \Doctrine\DBAL\Query\Expression\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;
}
/**
* Execute this query using the bound parameters and their types.
*
* Uses {@see Connection::executeQuery} for select statements and {@see Connection::executeUpdate}
* for insert, update and delete statements.
*
* @return mixed
*/
public function execute()
{
if ($this->type == self::SELECT) {
return $this->connection->executeQuery($this->getSQL(), $this->params, $this->paramTypes);
} else {
return $this->connection->executeUpdate($this->getSQL(), $this->params, $this->paramTypes);
}
}
/**
* Get the complete SQL string formed by the current specifications of this QueryBuilder.
*
*
* $qb = $em->createQueryBuilder()
* ->select('u')
* ->from('User', 'u')
* echo $qb->getSQL(); // SELECT u FROM User u
*
*
* @return string The sql 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.
*
*
* $qb = $conn->createQueryBuilder()
* ->select('u')
* ->from('users', 'u')
* ->where('u.id = :user_id')
* ->setParameter(':user_id', 1);
*
*
* @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.
*
*
* $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
* ));
*
*
* @param array $params The query parameters to set.
* @param array $types The query parameters types 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->state = self::STATE_DIRTY;
$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->state = self::STATE_DIRTY;
$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 boolean $append
* @return \Doctrine\DBAL\Query\QueryBuilder This QueryBuilder instance.
*/
public function add($sqlPartName, $sqlPart, $append = false)
{
$isArray = is_array($sqlPart);
$isMultiple = is_array($this->sqlParts[$sqlPartName]);
if ($isMultiple && !$isArray) {
$sqlPart = array($sqlPart);
}
$this->state = self::STATE_DIRTY;
if ($append) {
if ($sqlPartName == "orderBy" || $sqlPartName == "groupBy" || $sqlPartName == "select" || $sqlPartName == "set") {
foreach ($sqlPart as $part) {
$this->sqlParts[$sqlPartName][] = $part;
}
} else if ($isArray && is_array($sqlPart[key($sqlPart)])) {
$key = key($sqlPart);
$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.
*
*
* $qb = $conn->createQueryBuilder()
* ->select('u.id', 'p.id')
* ->from('users', 'u')
* ->leftJoin('u', 'phonenumbers', 'p', 'u.id = p.user_id');
*
*
* @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.
*
*
* $qb = $conn->createQueryBuilder()
* ->select('u.id')
* ->addSelect('p.id')
* ->from('users', 'u')
* ->leftJoin('u', 'phonenumbers', 'u.id = p.user_id');
*
*
* @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 table.
*
*
* $qb = $conn->createQueryBuilder()
* ->delete('users', 'u')
* ->where('u.id = :user_id');
* ->setParameter(':user_id', 1);
*
*
* @param string $delete The table whose rows are subject to the deletion.
* @param string $alias The table 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 table
*
*
* $qb = $conn->createQueryBuilder()
* ->update('users', 'u')
* ->set('u.password', md5('password'))
* ->where('u.id = ?');
*
*
* @param string $update The table whose rows are subject to the update.
* @param string $alias The table 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 table identified by the
* given alias, forming a cartesian product with any existing query roots.
*
*
* $qb = $conn->createQueryBuilder()
* ->select('u.id')
* ->from('users', 'u')
*
*
* @param string $from The table
* @param string $alias The alias of the table
* @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 to the query.
*
*
* $qb = $conn->createQueryBuilder()
* ->select('u.name')
* ->from('users', 'u')
* ->join('u', 'phonenumbers', 'p', 'p.is_primary = 1');
*
*
* @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 to the query.
*
*
* $qb = $conn->createQueryBuilder()
* ->select('u.name')
* ->from('users', 'u')
* ->innerJoin('u', 'phonenumbers', 'p', 'p.is_primary = 1');
*
*
* @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 to the query.
*
*
* $qb = $conn->createQueryBuilder()
* ->select('u.name')
* ->from('users', 'u')
* ->leftJoin('u', 'phonenumbers', 'p', 'p.is_primary = 1');
*
*
* @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);
}
/**
* Creates and adds a right join to the query.
*
*
* $qb = $conn->createQueryBuilder()
* ->select('u.name')
* ->from('users', 'u')
* ->rightJoin('u', 'phonenumbers', 'p', 'p.is_primary = 1');
*
*
* @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 rightJoin($fromAlias, $join, $alias, $condition = null)
{
return $this->add('join', array(
$fromAlias => array(
'joinType' => 'right',
'joinTable' => $join,
'joinAlias' => $alias,
'joinCondition' => $condition
)
), true);
}
/**
* Sets a new value for a column in a bulk update query.
*
*
* $qb = $conn->createQueryBuilder()
* ->update('users', 'u')
* ->set('u.password', md5('password'))
* ->where('u.id = ?');
*
*
* @param string $key The column to set.
* @param string $value The value, expression, placeholder, etc.
* @return QueryBuilder This QueryBuilder instance.
*/
public function set($key, $value)
{
return $this->add('set', $key .' = ' . $value, true);
}
/**
* Specifies one or more restrictions to the query result.
* Replaces any previously specified restrictions, if any.
*
*
* $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);
*
*
* @param mixed $predicates The restriction predicates.
* @return QueryBuilder This QueryBuilder instance.
*/
public function where($predicates)
{
if ( ! (func_num_args() == 1 && $predicates instanceof CompositeExpression) ) {
$predicates = new CompositeExpression(CompositeExpression::TYPE_AND, 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.
*
*
* $qb = $conn->createQueryBuilder()
* ->select('u')
* ->from('users', 'u')
* ->where('u.username LIKE ?')
* ->andWhere('u.is_active = 1');
*
*
* @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 = new CompositeExpression(CompositeExpression::TYPE_AND, $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.
*
*
* $qb = $em->createQueryBuilder()
* ->select('u.name')
* ->from('users', 'u')
* ->where('u.id = 1')
* ->orWhere('u.id = 2');
*
*
* @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 = new CompositeExpression(CompositeExpression::TYPE_OR, $args);
}
return $this->add('where', $where, true);
}
/**
* Specifies a grouping over the results of the query.
* Replaces any previously specified groupings, if any.
*
*
* $qb = $conn->createQueryBuilder()
* ->select('u.name')
* ->from('users', 'u')
* ->groupBy('u.id');
*
*
* @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.
*
*
* $qb = $conn->createQueryBuilder()
* ->select('u.name')
* ->from('users', 'u')
* ->groupBy('u.lastLogin');
* ->addGroupBy('u.createdAt')
*
*
* @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 = new CompositeExpression(CompositeExpression::TYPE_AND, 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 && $having->getType() === CompositeExpression::TYPE_AND) {
$having->addMultiple($args);
} else {
array_unshift($args, $having);
$having = new CompositeExpression(CompositeExpression::TYPE_AND, $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 && $having->getType() === CompositeExpression::TYPE_OR) {
$having->addMultiple($args);
} else {
array_unshift($args, $having);
$having = new CompositeExpression(CompositeExpression::TYPE_OR, $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', $sort . ' ' . (! $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', $sort . ' ' . (! $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 SQL 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 SQL 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;
}
private function getSQLForSelect()
{
$query = 'SELECT ' . implode(', ', $this->sqlParts['select']) . ' FROM ';
$fromClauses = array();
$joinsPending = true;
$joinAliases = array();
// Loop through all FROM clauses
foreach ($this->sqlParts['from'] as $from) {
$fromClause = $from['table'] . ' ' . $from['alias'];
if ($joinsPending && isset($this->sqlParts['join'][$from['alias']])) {
foreach ($this->sqlParts['join'] as $joins) {
foreach ($joins as $join) {
$fromClause .= ' ' . strtoupper($join['joinType'])
. ' JOIN ' . $join['joinTable'] . ' ' . $join['joinAlias']
. ' ON ' . ((string) $join['joinCondition']);
$joinAliases[$join['joinAlias']] = true;
}
}
$joinsPending = false;
}
$fromClauses[$from['alias']] = $fromClause;
}
// loop through all JOIN clauses for validation purpose
$knownAliases = array_merge($fromClauses,$joinAliases);
foreach ($this->sqlParts['join'] as $fromAlias => $joins) {
if ( ! isset($knownAliases[$fromAlias]) ) {
throw QueryException::unknownAlias($fromAlias, array_keys($knownAliases));
}
}
$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 && $this->firstResult == 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()
{
$table = $this->sqlParts['from']['table'] . ($this->sqlParts['from']['alias'] ? ' ' . $this->sqlParts['from']['alias'] : '');
$query = 'UPDATE ' . $table
. ' SET ' . implode(", ", $this->sqlParts['set'])
. ($this->sqlParts['where'] !== null ? ' WHERE ' . ((string) $this->sqlParts['where']) : '');
return $query;
}
/**
* Converts this instance into a DELETE string in SQL.
*
* @return string
*/
private function getSQLForDelete()
{
$table = $this->sqlParts['from']['table'] . ($this->sqlParts['from']['alias'] ? ' ' . $this->sqlParts['from']['alias'] : '');
$query = 'DELETE FROM ' . $table . ($this->sqlParts['where'] !== null ? ' WHERE ' . ((string) $this->sqlParts['where']) : '');
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();
}
/**
* Create a new named parameter and bind the value $value to it.
*
* This method provides a shortcut for PDOStatement::bindValue
* when using prepared statements.
*
* The parameter $value specifies the value that you want to bind. If
* $placeholder is not provided bindValue() will automatically create a
* placeholder for you. An automatic placeholder will be of the name
* ':dcValue1', ':dcValue2' etc.
*
* For more information see {@link http://php.net/pdostatement-bindparam}
*
* Example:
*
* $value = 2;
* $q->eq( 'id', $q->bindValue( $value ) );
* $stmt = $q->executeQuery(); // executed with 'id = 2'
*
*
* @license New BSD License
* @link http://www.zetacomponents.org
* @param mixed $value
* @param mixed $type
* @param string $placeHolder the name to bind with. The string must start with a colon ':'.
* @return string the placeholder name used.
*/
public function createNamedParameter( $value, $type = \PDO::PARAM_STR, $placeHolder = null )
{
if ( $placeHolder === null ) {
$this->boundCounter++;
$placeHolder = ":dcValue" . $this->boundCounter;
}
$this->setParameter(substr($placeHolder, 1), $value, $type);
return $placeHolder;
}
/**
* Create a new positional parameter and bind the given value to it.
*
* Attention: If you are using positional parameters with the query builder you have
* to be very careful to bind all parameters in the order they appear in the SQL
* statement , otherwise they get bound in the wrong order which can lead to serious
* bugs in your code.
*
* Example:
*
* $qb = $conn->createQueryBuilder();
* $qb->select('u.*')
* ->from('users', 'u')
* ->where('u.username = ' . $qb->createPositionalParameter('Foo', PDO::PARAM_STR))
* ->orWhere('u.username = ' . $qb->createPositionalParameter('Bar', PDO::PARAM_STR))
*
*
* @param mixed $value
* @param mixed $type
* @return string
*/
public function createPositionalParameter($value, $type = \PDO::PARAM_STR)
{
$this->boundCounter++;
$this->setParameter($this->boundCounter, $value, $type);
return "?";
}
}
DoctrineDBAL-2.3.4/Doctrine/DBAL/Query/QueryException.php 0000644 0001751 0001751 00000002737 12143374463 023113 0 ustar beberlei beberlei .
*/
namespace Doctrine\DBAL\Query;
use Doctrine\DBAL\DBALException;
/**
* Driver interface.
* Interface that all DBAL drivers must implement.
*
* @since 2.1.4
*/
class QueryException extends DBALException
{
static public function unknownAlias($alias, $registeredAliases)
{
return new self("The given alias '" . $alias . "' is not part of " .
"any FROM or JOIN clause table. The currently registered " .
"aliases are: " . implode(", ", $registeredAliases) . ".");
}
}
DoctrineDBAL-2.3.4/Doctrine/DBAL/Query/Expression/CompositeExpression.php 0000644 0001751 0001751 00000006725 12143374463 026311 0 ustar beberlei beberlei .
*/
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.1
* @author Guilherme Blanco
* $result = $sm->tryMethod('dropView', 'view_name');
*
*
* @return mixed
*/
public function tryMethod()
{
$args = func_get_args();
$method = $args[0];
unset($args[0]);
$args = array_values($args);
try {
return call_user_func_array(array($this, $method), $args);
} catch (\Exception $e) {
return false;
}
}
/**
* List the available databases for this connection
*
* @return array $databases
*/
public function listDatabases()
{
$sql = $this->_platform->getListDatabasesSQL();
$databases = $this->_conn->fetchAll($sql);
return $this->_getPortableDatabasesList($databases);
}
/**
* List the available sequences for this connection
*
* @return Sequence[]
*/
public function listSequences($database = null)
{
if (is_null($database)) {
$database = $this->_conn->getDatabase();
}
$sql = $this->_platform->getListSequencesSQL($database);
$sequences = $this->_conn->fetchAll($sql);
return $this->filterAssetNames($this->_getPortableSequencesList($sequences));
}
/**
* List the columns for a given table.
*
* In contrast to other libraries and to the old version of Doctrine,
* this column definition does try to contain the 'primary' field for
* the reason that it is not portable accross different RDBMS. Use
* {@see listTableIndexes($tableName)} to retrieve the primary key
* of a table. We're a RDBMS specifies more details these are held
* in the platformDetails array.
*
* @param string $table The name of the table.
* @param string $database
* @return Column[]
*/
public function listTableColumns($table, $database = null)
{
if ( ! $database) {
$database = $this->_conn->getDatabase();
}
$sql = $this->_platform->getListTableColumnsSQL($table, $database);
$tableColumns = $this->_conn->fetchAll($sql);
return $this->_getPortableTableColumnList($table, $database, $tableColumns);
}
/**
* List the indexes for a given table returning an array of Index instances.
*
* Keys of the portable indexes list are all lower-cased.
*
* @param string $table The name of the table
* @return Index[] $tableIndexes
*/
public function listTableIndexes($table)
{
$sql = $this->_platform->getListTableIndexesSQL($table, $this->_conn->getDatabase());
$tableIndexes = $this->_conn->fetchAll($sql);
return $this->_getPortableTableIndexesList($tableIndexes, $table);
}
/**
* Return true if all the given tables exist.
*
* @param array $tableNames
* @return bool
*/
public function tablesExist($tableNames)
{
$tableNames = array_map('strtolower', (array)$tableNames);
return count($tableNames) == count(\array_intersect($tableNames, array_map('strtolower', $this->listTableNames())));
}
/**
* Return a list of all tables in the current database
*
* @return array
*/
public function listTableNames()
{
$sql = $this->_platform->getListTablesSQL();
$tables = $this->_conn->fetchAll($sql);
$tableNames = $this->_getPortableTablesList($tables);
return $this->filterAssetNames($tableNames);
}
/**
* Filter asset names if they are configured to return only a subset of all
* the found elements.
*
* @param array $assetNames
* @return array
*/
protected function filterAssetNames($assetNames)
{
$filterExpr = $this->getFilterSchemaAssetsExpression();
if ( ! $filterExpr) {
return $assetNames;
}
return array_values (
array_filter($assetNames, function ($assetName) use ($filterExpr) {
$assetName = ($assetName instanceof AbstractAsset) ? $assetName->getName() : $assetName;
return preg_match($filterExpr, $assetName);
})
);
}
protected function getFilterSchemaAssetsExpression()
{
return $this->_conn->getConfiguration()->getFilterSchemaAssetsExpression();
}
/**
* List the tables for this connection
*
* @return Table[]
*/
public function listTables()
{
$tableNames = $this->listTableNames();
$tables = array();
foreach ($tableNames as $tableName) {
$tables[] = $this->listTableDetails($tableName);
}
return $tables;
}
/**
* @param string $tableName
* @return Table
*/
public function listTableDetails($tableName)
{
$columns = $this->listTableColumns($tableName);
$foreignKeys = array();
if ($this->_platform->supportsForeignKeyConstraints()) {
$foreignKeys = $this->listTableForeignKeys($tableName);
}
$indexes = $this->listTableIndexes($tableName);
return new Table($tableName, $columns, $indexes, $foreignKeys, false, array());
}
/**
* List the views this connection has
*
* @return View[]
*/
public function listViews()
{
$database = $this->_conn->getDatabase();
$sql = $this->_platform->getListViewsSQL($database);
$views = $this->_conn->fetchAll($sql);
return $this->_getPortableViewsList($views);
}
/**
* List the foreign keys for the given table
*
* @param string $table The name of the table
* @return ForeignKeyConstraint[]
*/
public function listTableForeignKeys($table, $database = null)
{
if (is_null($database)) {
$database = $this->_conn->getDatabase();
}
$sql = $this->_platform->getListTableForeignKeysSQL($table, $database);
$tableForeignKeys = $this->_conn->fetchAll($sql);
return $this->_getPortableTableForeignKeysList($tableForeignKeys);
}
/* drop*() Methods */
/**
* Drops a database.
*
* NOTE: You can not drop the database this SchemaManager is currently connected to.
*
* @param string $database The name of the database to drop
*/
public function dropDatabase($database)
{
$this->_execSql($this->_platform->getDropDatabaseSQL($database));
}
/**
* Drop the given table
*
* @param string $table The name of the table to drop
*/
public function dropTable($table)
{
$this->_execSql($this->_platform->getDropTableSQL($table));
}
/**
* Drop the index from the given table
*
* @param Index|string $index The name of the index
* @param string|Table $table The name of the table
*/
public function dropIndex($index, $table)
{
if($index instanceof Index) {
$index = $index->getQuotedName($this->_platform);
}
$this->_execSql($this->_platform->getDropIndexSQL($index, $table));
}
/**
* Drop the constraint from the given table
*
* @param Constraint $constraint
* @param string $table The name of the table
*/
public function dropConstraint(Constraint $constraint, $table)
{
$this->_execSql($this->_platform->getDropConstraintSQL($constraint, $table));
}
/**
* Drops a foreign key from a table.
*
* @param ForeignKeyConstraint|string $table The name of the table with the foreign key.
* @param Table|string $name The name of the foreign key.
* @return boolean $result
*/
public function dropForeignKey($foreignKey, $table)
{
$this->_execSql($this->_platform->getDropForeignKeySQL($foreignKey, $table));
}
/**
* Drops a sequence with a given name.
*
* @param string $name The name of the sequence to drop.
*/
public function dropSequence($name)
{
$this->_execSql($this->_platform->getDropSequenceSQL($name));
}
/**
* Drop a view
*
* @param string $name The name of the view
* @return boolean $result
*/
public function dropView($name)
{
$this->_execSql($this->_platform->getDropViewSQL($name));
}
/* create*() Methods */
/**
* Creates a new database.
*
* @param string $database The name of the database to create.
*/
public function createDatabase($database)
{
$this->_execSql($this->_platform->getCreateDatabaseSQL($database));
}
/**
* Create a new table.
*
* @param Table $table
* @param int $createFlags
*/
public function createTable(Table $table)
{
$createFlags = AbstractPlatform::CREATE_INDEXES|AbstractPlatform::CREATE_FOREIGNKEYS;
$this->_execSql($this->_platform->getCreateTableSQL($table, $createFlags));
}
/**
* Create a new sequence
*
* @param Sequence $sequence
* @throws \Doctrine\DBAL\ConnectionException if something fails at database level
*/
public function createSequence($sequence)
{
$this->_execSql($this->_platform->getCreateSequenceSQL($sequence));
}
/**
* Create a constraint on a table
*
* @param Constraint $constraint
* @param string|Table $table
*/
public function createConstraint(Constraint $constraint, $table)
{
$this->_execSql($this->_platform->getCreateConstraintSQL($constraint, $table));
}
/**
* Create a new index on a table
*
* @param Index $index
* @param string $table name of the table on which the index is to be created
*/
public function createIndex(Index $index, $table)
{
$this->_execSql($this->_platform->getCreateIndexSQL($index, $table));
}
/**
* Create a new foreign key
*
* @param ForeignKeyConstraint $foreignKey ForeignKey instance
* @param string|Table $table name of the table on which the foreign key is to be created
*/
public function createForeignKey(ForeignKeyConstraint $foreignKey, $table)
{
$this->_execSql($this->_platform->getCreateForeignKeySQL($foreignKey, $table));
}
/**
* Create a new view
*
* @param View $view
*/
public function createView(View $view)
{
$this->_execSql($this->_platform->getCreateViewSQL($view->getQuotedName($this->_platform), $view->getSql()));
}
/* dropAndCreate*() Methods */
/**
* Drop and create a constraint
*
* @param Constraint $constraint
* @param string $table
* @see dropConstraint()
* @see createConstraint()
*/
public function dropAndCreateConstraint(Constraint $constraint, $table)
{
$this->tryMethod('dropConstraint', $constraint, $table);
$this->createConstraint($constraint, $table);
}
/**
* Drop and create a new index on a table
*
* @param string|Table $table name of the table on which the index is to be created
* @param Index $index
*/
public function dropAndCreateIndex(Index $index, $table)
{
$this->tryMethod('dropIndex', $index->getQuotedName($this->_platform), $table);
$this->createIndex($index, $table);
}
/**
* Drop and create a new foreign key
*
* @param ForeignKeyConstraint $foreignKey associative array that defines properties of the foreign key to be created.
* @param string|Table $table name of the table on which the foreign key is to be created
*/
public function dropAndCreateForeignKey(ForeignKeyConstraint $foreignKey, $table)
{
$this->tryMethod('dropForeignKey', $foreignKey, $table);
$this->createForeignKey($foreignKey, $table);
}
/**
* Drop and create a new sequence
*
* @param Sequence $sequence
* @throws \Doctrine\DBAL\ConnectionException if something fails at database level
*/
public function dropAndCreateSequence(Sequence $sequence)
{
$this->tryMethod('dropSequence', $sequence->getQuotedName($this->_platform));
$this->createSequence($sequence);
}
/**
* Drop and create a new table.
*
* @param Table $table
*/
public function dropAndCreateTable(Table $table)
{
$this->tryMethod('dropTable', $table->getQuotedName($this->_platform));
$this->createTable($table);
}
/**
* Drop and creates a new database.
*
* @param string $database The name of the database to create.
*/
public function dropAndCreateDatabase($database)
{
$this->tryMethod('dropDatabase', $database);
$this->createDatabase($database);
}
/**
* Drop and create a new view
*
* @param View $view
*/
public function dropAndCreateView(View $view)
{
$this->tryMethod('dropView', $view->getQuotedName($this->_platform));
$this->createView($view);
}
/* alterTable() Methods */
/**
* Alter an existing tables schema
*
* @param TableDiff $tableDiff
*/
public function alterTable(TableDiff $tableDiff)
{
$queries = $this->_platform->getAlterTableSQL($tableDiff);
if (is_array($queries) && count($queries)) {
foreach ($queries as $ddlQuery) {
$this->_execSql($ddlQuery);
}
}
}
/**
* Rename a given table to another name
*
* @param string $name The current name of the table
* @param string $newName The new name of the table
*/
public function renameTable($name, $newName)
{
$tableDiff = new TableDiff($name);
$tableDiff->newName = $newName;
$this->alterTable($tableDiff);
}
/**
* Methods for filtering return values of list*() methods to convert
* the native DBMS data definition to a portable Doctrine definition
*/
protected function _getPortableDatabasesList($databases)
{
$list = array();
foreach ($databases as $value) {
if ($value = $this->_getPortableDatabaseDefinition($value)) {
$list[] = $value;
}
}
return $list;
}
protected function _getPortableDatabaseDefinition($database)
{
return $database;
}
protected function _getPortableFunctionsList($functions)
{
$list = array();
foreach ($functions as $value) {
if ($value = $this->_getPortableFunctionDefinition($value)) {
$list[] = $value;
}
}
return $list;
}
protected function _getPortableFunctionDefinition($function)
{
return $function;
}
protected function _getPortableTriggersList($triggers)
{
$list = array();
foreach ($triggers as $value) {
if ($value = $this->_getPortableTriggerDefinition($value)) {
$list[] = $value;
}
}
return $list;
}
protected function _getPortableTriggerDefinition($trigger)
{
return $trigger;
}
protected function _getPortableSequencesList($sequences)
{
$list = array();
foreach ($sequences as $value) {
if ($value = $this->_getPortableSequenceDefinition($value)) {
$list[] = $value;
}
}
return $list;
}
/**
* @param array $sequence
* @return Sequence
*/
protected function _getPortableSequenceDefinition($sequence)
{
throw DBALException::notSupported('Sequences');
}
/**
* Independent of the database the keys of the column list result are lowercased.
*
* The name of the created column instance however is kept in its case.
*
* @param string $table The name of the table.
* @param string $database
* @param array $tableColumns
* @return array
*/
protected function _getPortableTableColumnList($table, $database, $tableColumns)
{
$eventManager = $this->_platform->getEventManager();
$list = array();
foreach ($tableColumns as $tableColumn) {
$column = null;
$defaultPrevented = false;
if (null !== $eventManager && $eventManager->hasListeners(Events::onSchemaColumnDefinition)) {
$eventArgs = new SchemaColumnDefinitionEventArgs($tableColumn, $table, $database, $this->_conn);
$eventManager->dispatchEvent(Events::onSchemaColumnDefinition, $eventArgs);
$defaultPrevented = $eventArgs->isDefaultPrevented();
$column = $eventArgs->getColumn();
}
if ( ! $defaultPrevented) {
$column = $this->_getPortableTableColumnDefinition($tableColumn);
}
if ($column) {
$name = strtolower($column->getQuotedName($this->_platform));
$list[$name] = $column;
}
}
return $list;
}
/**
* Get Table Column Definition
*
* @param array $tableColumn
* @return Column
*/
abstract protected function _getPortableTableColumnDefinition($tableColumn);
/**
* Aggregate and group the index results according to the required data result.
*
* @param array $tableIndexRows
* @param string $tableName
* @return array
*/
protected function _getPortableTableIndexesList($tableIndexRows, $tableName=null)
{
$result = array();
foreach($tableIndexRows as $tableIndex) {
$indexName = $keyName = $tableIndex['key_name'];
if($tableIndex['primary']) {
$keyName = 'primary';
}
$keyName = strtolower($keyName);
if(!isset($result[$keyName])) {
$result[$keyName] = array(
'name' => $indexName,
'columns' => array($tableIndex['column_name']),
'unique' => $tableIndex['non_unique'] ? false : true,
'primary' => $tableIndex['primary'],
'flags' => isset($tableIndex['flags']) ? $tableIndex['flags'] : array(),
);
} else {
$result[$keyName]['columns'][] = $tableIndex['column_name'];
}
}
$eventManager = $this->_platform->getEventManager();
$indexes = array();
foreach($result as $indexKey => $data) {
$index = null;
$defaultPrevented = false;
if (null !== $eventManager && $eventManager->hasListeners(Events::onSchemaIndexDefinition)) {
$eventArgs = new SchemaIndexDefinitionEventArgs($data, $tableName, $this->_conn);
$eventManager->dispatchEvent(Events::onSchemaIndexDefinition, $eventArgs);
$defaultPrevented = $eventArgs->isDefaultPrevented();
$index = $eventArgs->getIndex();
}
if ( ! $defaultPrevented) {
$index = new Index($data['name'], $data['columns'], $data['unique'], $data['primary'], $data['flags']);
}
if ($index) {
$indexes[$indexKey] = $index;
}
}
return $indexes;
}
protected function _getPortableTablesList($tables)
{
$list = array();
foreach ($tables as $value) {
if ($value = $this->_getPortableTableDefinition($value)) {
$list[] = $value;
}
}
return $list;
}
protected function _getPortableTableDefinition($table)
{
return $table;
}
protected function _getPortableUsersList($users)
{
$list = array();
foreach ($users as $value) {
if ($value = $this->_getPortableUserDefinition($value)) {
$list[] = $value;
}
}
return $list;
}
protected function _getPortableUserDefinition($user)
{
return $user;
}
protected function _getPortableViewsList($views)
{
$list = array();
foreach ($views as $value) {
if ($view = $this->_getPortableViewDefinition($value)) {
$viewName = strtolower($view->getQuotedName($this->_platform));
$list[$viewName] = $view;
}
}
return $list;
}
protected function _getPortableViewDefinition($view)
{
return false;
}
protected function _getPortableTableForeignKeysList($tableForeignKeys)
{
$list = array();
foreach ($tableForeignKeys as $value) {
if ($value = $this->_getPortableTableForeignKeyDefinition($value)) {
$list[] = $value;
}
}
return $list;
}
protected function _getPortableTableForeignKeyDefinition($tableForeignKey)
{
return $tableForeignKey;
}
protected function _execSql($sql)
{
foreach ((array) $sql as $query) {
$this->_conn->executeUpdate($query);
}
}
/**
* Create a schema instance for the current database.
*
* @return Schema
*/
public function createSchema()
{
$sequences = array();
if($this->_platform->supportsSequences()) {
$sequences = $this->listSequences();
}
$tables = $this->listTables();
return new Schema($tables, $sequences, $this->createSchemaConfig());
}
/**
* Create the configuration for this schema.
*
* @return SchemaConfig
*/
public function createSchemaConfig()
{
$schemaConfig = new SchemaConfig();
$schemaConfig->setMaxIdentifierLength($this->_platform->getMaxIdentifierLength());
$searchPaths = $this->getSchemaSearchPaths();
if (isset($searchPaths[0])) {
$schemaConfig->setName($searchPaths[0]);
}
$params = $this->_conn->getParams();
if (isset($params['defaultTableOptions'])) {
$schemaConfig->setDefaultTableOptions($params['defaultTableOptions']);
}
return $schemaConfig;
}
/**
* The search path for namespaces in the currently connected database.
*
* The first entry is usually the default namespace in the Schema. All
* further namespaces contain tables/sequences which can also be addressed
* with a short, not full-qualified name.
*
* For databases that don't support subschema/namespaces this method
* returns the name of the currently connected database.
*
* @return array
*/
public function getSchemaSearchPaths()
{
return array($this->_conn->getDatabase());
}
/**
* Given a table comment this method tries to extract a typehint for Doctrine Type, or returns
* the type given as default.
*
* @param string $comment
* @param string $currentType
* @return string
*/
public function extractDoctrineTypeFromComment($comment, $currentType)
{
if (preg_match("(\(DC2Type:([a-zA-Z0-9_]+)\))", $comment, $match)) {
$currentType = $match[1];
}
return $currentType;
}
public function removeDoctrineTypeFromComment($comment, $type)
{
return str_replace('(DC2Type:'.$type.')', '', $comment);
}
}
DoctrineDBAL-2.3.4/Doctrine/DBAL/Schema/Column.php 0000644 0001751 0001751 00000021264 12143374463 021453 0 ustar beberlei beberlei .
*/
namespace Doctrine\DBAL\Schema;
use \Doctrine\DBAL\Types\Type;
use Doctrine\DBAL\Schema\Visitor\Visitor;
/**
* Object representation of a database column
*
*
* @link www.doctrine-project.org
* @since 2.0
* @version $Revision$
* @author Benjamin Eberlei | ' . $table->getName() . ' | ||
| '; $label .= '' . $columnLabel . ''; $label .= ' | ' . strtolower($column->getType()) . ' | '; $label .= ''; if ($table->hasPrimaryKey() && in_array($column->getName(), $table->getPrimaryKey()->getColumns())) { $label .= "\xe2\x9c\xb7"; } $label .= ' |