Actualización

vendor/doctrine/dbal/lib/Doctrine/DBAL/Query/Expression/CompositeExpression.php

@@ -0,0 +1,186 @@
+<?php
+
+namespace Doctrine\DBAL\Query\Expression;
+
+use Countable;
+use Doctrine\Deprecations\Deprecation;
+use ReturnTypeWillChange;
+
+use function array_merge;
+use function count;
+use function implode;
+
+/**
+ * Composite expression is responsible to build a group of similar expression.
+ */
+class CompositeExpression implements Countable
+{
+    /**
+     * Constant that represents an AND composite expression.
+     */
+    public const TYPE_AND = 'AND';
+
+    /**
+     * Constant that represents an OR composite expression.
+     */
+    public const TYPE_OR = 'OR';
+
+    /**
+     * The instance type of composite expression.
+     *
+     * @var string
+     */
+    private $type;
+
+    /**
+     * Each expression part of the composite expression.
+     *
+     * @var self[]|string[]
+     */
+    private $parts = [];
+
+    /**
+     * @internal Use the and() / or() factory methods.
+     *
+     * @param string          $type  Instance type of composite expression.
+     * @param self[]|string[] $parts Composition of expressions to be joined on composite expression.
+     */
+    public function __construct($type, array $parts = [])
+    {
+        $this->type = $type;
+
+        $this->addMultiple($parts);
+
+        Deprecation::triggerIfCalledFromOutside(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/pull/3864',
+            'Do not use CompositeExpression constructor directly, use static and() and or() factory methods.'
+        );
+    }
+
+    /**
+     * @param self|string $part
+     * @param self|string ...$parts
+     */
+    public static function and($part, ...$parts): self
+    {
+        return new self(self::TYPE_AND, array_merge([$part], $parts));
+    }
+
+    /**
+     * @param self|string $part
+     * @param self|string ...$parts
+     */
+    public static function or($part, ...$parts): self
+    {
+        return new self(self::TYPE_OR, array_merge([$part], $parts));
+    }
+
+    /**
+     * Adds multiple parts to composite expression.
+     *
+     * @deprecated This class will be made immutable. Use with() instead.
+     *
+     * @param self[]|string[] $parts
+     *
+     * @return CompositeExpression
+     */
+    public function addMultiple(array $parts = [])
+    {
+        Deprecation::triggerIfCalledFromOutside(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/issues/3844',
+            'CompositeExpression::addMultiple() is deprecated, use CompositeExpression::with() instead.'
+        );
+
+        foreach ($parts as $part) {
+            $this->add($part);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Adds an expression to composite expression.
+     *
+     * @deprecated This class will be made immutable. Use with() instead.
+     *
+     * @param mixed $part
+     *
+     * @return CompositeExpression
+     */
+    public function add($part)
+    {
+        Deprecation::triggerIfCalledFromOutside(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/issues/3844',
+            'CompositeExpression::add() is deprecated, use CompositeExpression::with() instead.'
+        );
+
+        if (empty($part)) {
+            return $this;
+        }
+
+        if ($part instanceof self && count($part) === 0) {
+            return $this;
+        }
+
+        $this->parts[] = $part;
+
+        return $this;
+    }
+
+    /**
+     * Returns a new CompositeExpression with the given parts added.
+     *
+     * @param self|string $part
+     * @param self|string ...$parts
+     */
+    public function with($part, ...$parts): self
+    {
+        $that = clone $this;
+
+        $that->parts[] = $part;
+
+        foreach ($parts as $part) {
+            $that->parts[] = $part;
+        }
+
+        return $that;
+    }
+
+    /**
+     * Retrieves the amount of expressions on composite expression.
+     *
+     * @return int
+     */
+    #[ReturnTypeWillChange]
+    public function count()
+    {
+        return count($this->parts);
+    }
+
+    /**
+     * Retrieves 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) . ')';
+    }
+
+    /**
+     * Returns the type of this composite expression (AND/OR).
+     *
+     * @return string
+     */
+    public function getType()
+    {
+        return $this->type;
+    }
+}

vendor/doctrine/dbal/lib/Doctrine/DBAL/Query/Expression/ExpressionBuilder.php

@@ -0,0 +1,322 @@
+<?php
+
+namespace Doctrine\DBAL\Query\Expression;
+
+use Doctrine\DBAL\Connection;
+use Doctrine\Deprecations\Deprecation;
+
+use function func_get_arg;
+use function func_get_args;
+use function func_num_args;
+use function implode;
+use function sprintf;
+
+/**
+ * ExpressionBuilder class is responsible to dynamically create SQL query parts.
+ */
+class ExpressionBuilder
+{
+    public const EQ  = '=';
+    public const NEQ = '<>';
+    public const LT  = '<';
+    public const LTE = '<=';
+    public const GT  = '>';
+    public const GTE = '>=';
+
+    /**
+     * The DBAL Connection.
+     *
+     * @var Connection
+     */
+    private $connection;
+
+    /**
+     * Initializes a new <tt>ExpressionBuilder</tt>.
+     *
+     * @param Connection $connection The DBAL Connection.
+     */
+    public function __construct(Connection $connection)
+    {
+        $this->connection = $connection;
+    }
+
+    /**
+     * Creates a conjunction of the given expressions.
+     *
+     * @param string|CompositeExpression $expression
+     * @param string|CompositeExpression ...$expressions
+     */
+    public function and($expression, ...$expressions): CompositeExpression
+    {
+        return CompositeExpression::and($expression, ...$expressions);
+    }
+
+    /**
+     * Creates a disjunction of the given expressions.
+     *
+     * @param string|CompositeExpression $expression
+     * @param string|CompositeExpression ...$expressions
+     */
+    public function or($expression, ...$expressions): CompositeExpression
+    {
+        return CompositeExpression::or($expression, ...$expressions);
+    }
+
+    /**
+     * @deprecated Use `and()` instead.
+     *
+     * @param mixed $x Optional clause. Defaults = null, but requires
+     *                 at least one defined when converting to string.
+     *
+     * @return CompositeExpression
+     */
+    public function andX($x = null)
+    {
+        Deprecation::trigger(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/pull/3851',
+            'ExpressionBuilder::andX() is deprecated, use ExpressionBuilder::and() instead.'
+        );
+
+        return new CompositeExpression(CompositeExpression::TYPE_AND, func_get_args());
+    }
+
+    /**
+     * @deprecated Use `or()` instead.
+     *
+     * @param mixed $x Optional clause. Defaults = null, but requires
+     *                 at least one defined when converting to string.
+     *
+     * @return CompositeExpression
+     */
+    public function orX($x = null)
+    {
+        Deprecation::trigger(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/pull/3851',
+            'ExpressionBuilder::orX() is deprecated, use ExpressionBuilder::or() instead.'
+        );
+
+        return new CompositeExpression(CompositeExpression::TYPE_OR, func_get_args());
+    }
+
+    /**
+     * Creates a comparison expression.
+     *
+     * @param mixed  $x        The left expression.
+     * @param string $operator One of the ExpressionBuilder::* constants.
+     * @param mixed  $y        The 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 The left expression.
+     * @param mixed $y The 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 The left expression.
+     * @param mixed $y The 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 The left expression.
+     * @param mixed $y The 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 The left expression.
+     * @param mixed $y The 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 The left expression.
+     * @param mixed $y The 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 The left expression.
+     * @param mixed $y The 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 The expression 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 The expression 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/*, ?string $escapeChar = null */)
+    {
+        return $this->comparison($x, 'LIKE', $y) .
+            (func_num_args() >= 3 ? sprintf(' ESCAPE %s', func_get_arg(2)) : '');
+    }
+
+    /**
+     * Creates a NOT LIKE() comparison expression with the given arguments.
+     *
+     * @param string $x Field in string format to be inspected by NOT LIKE() comparison.
+     * @param mixed  $y Argument to be used in NOT LIKE() comparison.
+     *
+     * @return string
+     */
+    public function notLike($x, $y/*, ?string $escapeChar = null */)
+    {
+        return $this->comparison($x, 'NOT LIKE', $y) .
+            (func_num_args() >= 3 ? sprintf(' ESCAPE %s', func_get_arg(2)) : '');
+    }
+
+    /**
+     * Creates a IN () comparison expression with the given arguments.
+     *
+     * @param string          $x The field in string format to be inspected by IN() comparison.
+     * @param string|string[] $y The placeholder or the array of values to be used by IN() comparison.
+     *
+     * @return string
+     */
+    public function in($x, $y)
+    {
+        return $this->comparison($x, 'IN', '(' . implode(', ', (array) $y) . ')');
+    }
+
+    /**
+     * Creates a NOT IN () comparison expression with the given arguments.
+     *
+     * @param string          $x The expression to be inspected by NOT IN() comparison.
+     * @param string|string[] $y The placeholder or the array of values to be used by NOT IN() comparison.
+     *
+     * @return string
+     */
+    public function notIn($x, $y)
+    {
+        return $this->comparison($x, 'NOT IN', '(' . implode(', ', (array) $y) . ')');
+    }
+
+    /**
+     * Quotes a given input parameter.
+     *
+     * @param mixed    $input The parameter to be quoted.
+     * @param int|null $type  The type of the parameter.
+     *
+     * @return string
+     */
+    public function literal($input, $type = null)
+    {
+        return $this->connection->quote($input, $type);
+    }
+}

vendor/doctrine/dbal/lib/Doctrine/DBAL/Query/QueryException.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace Doctrine\DBAL\Query;
+
+use Doctrine\DBAL\Exception;
+
+use function implode;
+
+/**
+ * @psalm-immutable
+ */
+class QueryException extends Exception
+{
+    /**
+     * @param string   $alias
+     * @param string[] $registeredAliases
+     *
+     * @return QueryException
+     */
+    public static 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) . '.');
+    }
+
+    /**
+     * @param string   $alias
+     * @param string[] $registeredAliases
+     *
+     * @return QueryException
+     */
+    public static function nonUniqueAlias($alias, $registeredAliases)
+    {
+        return new self("The given alias '" . $alias . "' is not unique " .
+            'in FROM and JOIN clause table. The currently registered ' .
+            'aliases are: ' . implode(', ', $registeredAliases) . '.');
+    }
+}