Process expressions inside param values when build a query

src/Expression/ExpressionBuilder.php

@@ -4,7 +4,14 @@
 
 namespace Yiisoft\Db\Expression;
 
+use Yiisoft\Db\Connection\ConnectionInterface;
+use Yiisoft\Db\QueryBuilder\QueryBuilderInterface;
+use Yiisoft\Db\Syntax\SqlParser;
+
 use function array_merge;
+use function strlen;
+use function substr;
+use function substr_replace;
 
 /**
  * It's used to build expressions for use in database queries.
@@ -14,12 +21,178 @@
  *
  * These expressions can be used with the query builder to build complex and customizable database queries
  * {@see Expression} class.
+ *
+ * @psalm-import-type ParamsType from ConnectionInterface
  */
 class ExpressionBuilder implements ExpressionBuilderInterface
 {
+    public function __construct(private QueryBuilderInterface|null $queryBuilder = null)
+    {
+    }
+
+    /**
+     * Builds SQL statement from the given expression.
+     *
+     * @param Expression $expression The expression to be built.
+     * @param array $params The parameters to be bound to the query.
+     *
+     * @psalm-param ParamsType $params
+     *
+     * @return string SQL statement.
+     */
     public function build(Expression $expression, array &$params = []): string
     {
-        $params = array_merge($params, $expression->getParams());
-        return $expression->__toString();
+        $sql = $expression->__toString();
+        $expressionParams = $expression->getParams();
+
+        if (empty($expressionParams)) {
+            return $sql;
+        }
+
+        if ($this->queryBuilder === null || isset($expressionParams[0])) {
+            $params = array_merge($params, $expressionParams);
+            return $sql;
+        }
+
+        $sql = $this->appendParams($sql, $expressionParams, $params);
+
+        return $this->replaceParamExpressions($sql, $expressionParams, $params);
+    }
+
+    /**
+     * Appends parameters to the list of query parameters replacing non-unique parameters with unique ones.
+     *
+     * @param string $sql SQL statement of the expression.
+     * @param array $expressionParams Parameters to be appended.
+     * @param array $params Parameters to be bound to the query.
+     *
+     * @psalm-param ParamsType $params
+     *
+     * @return string SQL statement with unique parameters.
+     */
+    private function appendParams(string $sql, array &$expressionParams, array &$params): string
+    {
+        $nonUniqueParams = [];
+
+        /** @var non-empty-string $name */
+        foreach ($expressionParams as $name => $value) {
+            $paramName = $name[0] === ':' ? substr($name, 1) : $name;
+
+            if (!isset($params[$paramName]) && !isset($params[":$paramName"])) {
+                $params[$name] = $value;
+                continue;
+            }
+
+            $nonUniqueParams[$name] = $value;
+        }
+
+        /** @var non-empty-string $name */
+        foreach ($nonUniqueParams as $name => $value) {
+            $paramName = $name[0] === ':' ? substr($name, 1) : $name;
+            $uniqueName = $this->getUniqueName($paramName, $params);
+
+            $sql = $this->replacePlaceholder($sql, ":$paramName", ":$uniqueName");
+
+            if ($name[0] === ':') {
+                $uniqueName = ":$uniqueName";
+            }
+
+            $params[$uniqueName] = $value;
+            $expressionParams[$uniqueName] = $value;
+            unset($expressionParams[$name]);
+        }
+
+        return $sql;
+    }
+
+    /**
+     * Replaces parameters with expression values in SQL statement.
+     *
+     * @param string $sql SQL statement where parameters should be replaced.
+     * @param array $expressionParams Parameters to be replaced.
+     * @param array $params Parameters to be bound to the query.
+     *
+     * @psalm-param ParamsType $expressionParams
+     * @psalm-param ParamsType $params
+     *
+     * @return string SQL statement with replaced parameters.
+     */
+    private function replaceParamExpressions(string $sql, array $expressionParams, array &$params): string
+    {
+        /** @var non-empty-string $name */
+        foreach ($expressionParams as $name => $value) {
+            if (!$value instanceof ExpressionInterface) {
+                continue;
+            }
+
+            $placeholder = $name[0] !== ':' ? ":$name" : $name;
+            /** @psalm-suppress PossiblyNullReference */
+            $replacement = $this->queryBuilder->buildExpression($value, $params);
+
+            $sql = $this->replacePlaceholder($sql, $placeholder, $replacement);
+
+            /** @psalm-var ParamsType $params */
+            unset($params[$name]);
+        }
+
+        return $sql;
+    }
+
+    /**
+     * Returns a unique name for the parameter without colon at the beginning.
+     *
+     * @param string $name Name of the parameter without colon at the beginning.
+     * @param array $params Parameters to be bound to the query.
+     *
+     * @psalm-param ParamsType $params
+     *
+     * @return string Unique name of the parameter with colon at the beginning.
+     *
+     * @psalm-return non-empty-string
+     */
+    private function getUniqueName(string $name, array $params): string
+    {
+        $uniqueName = $name . '_0';
+
+        for ($i = 1; isset($params[$uniqueName]) || isset($params[":$uniqueName"]); ++$i) {
+            $uniqueName = $name . '_' . $i;
+        }
+
+        return $uniqueName;
+    }
+
+    /**
+     * Replaces the placeholder with the replacement in SQL statement.
+     *
+     * @param string $sql SQL statement where the placeholder should be replaced.
+     * @param string $placeholder Placeholder to be replaced.
+     * @param string $replacement Replacement for the placeholder.
+     *
+     * @return string SQL with the replaced placeholder.
+     */
+    private function replacePlaceholder(string $sql, string $placeholder, string $replacement): string
+    {
+        $parser = $this->createSqlParser($sql);
+
+        while (null !== $parsedPlaceholder = $parser->getNextPlaceholder($position)) {
+            if ($parsedPlaceholder === $placeholder) {
+                /** @var int $position */
+                return substr_replace($sql, $replacement, $position, strlen($placeholder));
+            }
+        }
+
+        return $sql;
+    }
+
+    /**
+     * Creates an instance of {@see SqlParser} for the given SQL statement.
+     *
+     * @param string $sql SQL statement to be parsed.
+     *
+     * @return SqlParser SQL parser instance.
+     */
+    protected function createSqlParser(string $sql): SqlParser
+    {
+        return new SqlParser($sql);
     }
 }

src/QueryBuilder/AbstractDQLQueryBuilder.php

@@ -105,25 +105,7 @@ public function build(QueryInterface $query, array $params = []): array
             $this->buildHaving($query->getHaving(), $params),
         ];
         $sql = implode($this->separator, array_filter($clauses));
-        $sql = $this->buildOrderByAndLimit($sql, $query->getOrderBy(), $query->getLimit(), $query->getOffset());
-
-        if (!empty($query->getOrderBy())) {
-            /** @psalm-var array<string, ExpressionInterface|string> */
-            foreach ($query->getOrderBy() as $expression) {
-                if ($expression instanceof ExpressionInterface) {
-                    $this->buildExpression($expression, $params);
-                }
-            }
-        }
-
-        if (!empty($query->getGroupBy())) {
-            /** @psalm-var array<string, ExpressionInterface|string> */
-            foreach ($query->getGroupBy() as $expression) {
-                if ($expression instanceof ExpressionInterface) {
-                    $this->buildExpression($expression, $params);
-                }
-            }
-        }
+        $sql = $this->buildOrderByAndLimit($sql, $query->getOrderBy(), $query->getLimit(), $query->getOffset(), $params);
 
         $union = $this->buildUnion($query->getUnions(), $params);
 
@@ -165,19 +147,22 @@ public function buildColumns(array|string $columns): string
 
     public function buildCondition(array|string|ExpressionInterface|null $condition, array &$params = []): string
     {
-        if (is_array($condition)) {
-            if (empty($condition)) {
-                return '';
+        if (empty($condition)) {
+            if ($condition === '0') {
+                return '0';
             }
 
-            $condition = $this->createConditionFromArray($condition);
+            return '';
         }
 
-        if ($condition instanceof ExpressionInterface) {
-            return $this->buildExpression($condition, $params);
+        if (is_array($condition)) {
+            $condition = $this->createConditionFromArray($condition);
+        } elseif (is_string($condition)) {
+            $condition = new Expression($condition, $params);
+            $params = [];
         }
 
-        return $condition ?? '';
+        return $this->buildExpression($condition, $params);
     }
 
     public function buildExpression(ExpressionInterface $expression, array &$params = []): string
@@ -208,10 +193,7 @@ public function buildGroupBy(array $columns, array &$params = []): string
         /** @psalm-var array<string, ExpressionInterface|string> $columns */
         foreach ($columns as $i => $column) {
             if ($column instanceof ExpressionInterface) {
-                $columns[$i] = $this->buildExpression($column);
-                if ($column instanceof Expression || $column instanceof QueryInterface) {
-                    $params = array_merge($params, $column->getParams());
-                }
+                $columns[$i] = $this->buildExpression($column, $params);
             } elseif (!str_contains($column, '(')) {
                 $columns[$i] = $this->quoter->quoteColumnName($column);
             }
@@ -299,10 +281,7 @@ public function buildOrderBy(array $columns, array &$params = []): string
         /** @psalm-var array<string, ExpressionInterface|int|string> $columns */
         foreach ($columns as $name => $direction) {
             if ($direction instanceof ExpressionInterface) {
-                $orders[] = $this->buildExpression($direction);
-                if ($direction instanceof Expression || $direction instanceof QueryInterface) {
-                    $params = array_merge($params, $direction->getParams());
-                }
+                $orders[] = $this->buildExpression($direction, $params);
             } else {
                 $orders[] = $this->quoter->quoteColumnName($name) . ($direction === SORT_DESC ? ' DESC' : '');
             }