Process expressions inside param values when build a query

src/Expression/ExpressionBuilder.php

@@ -4,7 +4,12 @@
 
 namespace Yiisoft\Db\Expression;
 
+use Yiisoft\Db\QueryBuilder\QueryBuilderInterface;
+
+use function array_intersect_key;
 use function array_merge;
+use function preg_quote;
+use function preg_replace;
 
 /**
  * It's used to build expressions for use in database queries.
@@ -17,9 +22,99 @@
  */
 class ExpressionBuilder implements ExpressionBuilderInterface
 {
+    public function __construct(private QueryBuilderInterface|null $queryBuilder = null)
+    {
+    }
+
     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);
+    }
+
+    private function appendParams(string $sql, array &$expressionParams, array &$params): string
+    {
+        $nonUniqueParams = array_intersect_key($expressionParams, $params);
+        $params += $expressionParams;
+
+        if (empty($nonUniqueParams)) {
+            return $sql;
+        }
+
+        $patterns = [];
+        $replacements = [];
+
+        /** @var string $name */
+        foreach ($nonUniqueParams as $name => $value) {
+            $patterns[] = $this->getPattern($name);
+            $uniqueName = $this->getUniqueName($name, $params);
+
+            $replacements[] = $uniqueName[0] !== ':' ? ":$uniqueName" : $uniqueName;
+
+            $params[$uniqueName] = $value;
+            $expressionParams[$uniqueName] = $value;
+            unset($expressionParams[$name]);
+        }
+
+        return preg_replace($patterns, $replacements, $sql, 1);
+    }
+
+    private function replaceParamExpressions(string $sql, array $expressionParams, array &$params): string
+    {
+        $patterns = [];
+        $replacements = [];
+
+        /** @var string $name */
+        foreach ($expressionParams as $name => $value) {
+            if (!$value instanceof ExpressionInterface) {
+                continue;
+            }
+
+            $patterns[] = $this->getPattern($name);
+            /** @psalm-suppress PossiblyNullReference */
+            $replacements[] = $this->queryBuilder->buildExpression($value, $params);
+
+            unset($params[$name]);
+        }
+
+        if (empty($patterns)) {
+            return $sql;
+        }
+
+        return preg_replace($patterns, $replacements, $sql, 1);
+    }
+
+    /** @psalm-return non-empty-string */
+    private function getPattern(string $name): string
+    {
+        if ($name[0] !== ':') {
+            $name = ":$name";
+        }
+
+        return '/' . preg_quote($name, '/') . '\b/';
+    }
+
+    private function getUniqueName(string $name, array $params): string
+    {
+        $uniqueName = $name . '_0';
+
+        for ($i = 1; isset($params[$uniqueName]); ++$i) {
+            $uniqueName = $name . '_' . $i;
+        }
+
+        return $uniqueName;
     }
 }

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' : '');
             }

tests/AbstractQueryBuilderTest.php

@@ -2194,16 +2194,18 @@ public function testUpdate(
         string $table,
         array $columns,
         array|string $condition,
-        string $expectedSQL,
+        array $params,
+        string $expectedSql,
         array $expectedParams
     ): void {
         $db = $this->getConnection();
-
         $qb = $db->getQueryBuilder();
-        $actualParams = [];
 
-        $this->assertSame($expectedSQL, $qb->update($table, $columns, $condition, $actualParams));
-        $this->assertSame($expectedParams, $actualParams);
+        $sql = $qb->update($table, $columns, $condition, $params);
+        $sql = $qb->quoter()->quoteSql($sql);
+
+        $this->assertSame($expectedSql, $sql);
+        $this->assertEquals($expectedParams, $params);
     }
 
     /**
@@ -2274,7 +2276,7 @@ public function testOverrideParameters1(): void
     {
         $db = $this->getConnection();
 
-        $params = [':id' => 1, ':pv2' => new Expression('(select type from {{%animal}}) where id=1')];
+        $params = [':id' => 1, ':pv2' => 'test'];
         $expression = new Expression('id = :id AND type = :pv2', $params);
 
         $query = new Query($db);
@@ -2289,7 +2291,7 @@ public function testOverrideParameters1(): void
         $this->assertEquals([':id', ':pv2', ':pv2_0',], array_keys($command->getParams()));
         $this->assertEquals(
             DbHelper::replaceQuotes(
-                'SELECT * FROM [[animal]] WHERE (id = 1 AND type = (select type from {{%animal}}) where id=1) AND ([[type]]=\'test1\')',
+                'SELECT * FROM [[animal]] WHERE (id = 1 AND type = \'test\') AND ([[type]]=\'test1\')',
                 $db->getDriverName()
             ),
             $command->getRawSql()

tests/Common/CommonCommandTest.php

@@ -1888,14 +1888,25 @@ public function testUpdate(
         array $columns,
         array|string $conditions,
         array $params,
-        string $expected
+        array $expectedValues,
+        int $expectedCount,
     ): void {
-        $db = $this->getConnection();
+        $db = $this->getConnection(true);
 
         $command = $db->createCommand();
-        $sql = $command->update($table, $columns, $conditions, $params)->getSql();
+        $count = $command->update($table, $columns, $conditions, $params)->execute();
+
+        $this->assertSame($expectedCount, $count);
 
-        $this->assertSame($expected, $sql);
+        $values = (new Query($db))
+            ->from($table)
+            ->where($conditions, $params)
+            ->limit(1)
+            ->one();
+
+        foreach ($expectedValues as $name => $expectedValue) {
+            $this->assertEquals($expectedValue, $values[$name]);
+        }
 
         $db->close();
     }

tests/Db/QueryBuilder/QueryBuilderTest.php

@@ -253,17 +253,20 @@ public function testUpdate(
         string $table,
         array $columns,
         array|string $condition,
-        string $expectedSQL,
+        array $params,
+        string $expectedSql,
         array $expectedParams
     ): void {
         $db = $this->getConnection();
 
         $schemaMock = $this->createMock(Schema::class);
         $qb = new QueryBuilder($db->getQuoter(), $schemaMock);
-        $actualParams = [];
 
-        $this->assertSame($expectedSQL, $qb->update($table, $columns, $condition, $actualParams));
-        $this->assertSame($expectedParams, $actualParams);
+        $sql = $qb->update($table, $columns, $condition, $params);
+        $sql = $qb->quoter()->quoteSql($sql);
+
+        $this->assertSame($expectedSql, $sql);
+        $this->assertEquals($expectedParams, $params);
     }
 
     /**