Passed
Pull Request — master (#806)
by Sergei
23:43 queued 21:02
created

ExpressionBuilder::getUniqueName()   A

Complexity

Conditions 2
Paths 2

Size

Total Lines 9
Code Lines 4

Duplication

Lines 0
Ratio 0 %

Code Coverage

Tests 0
CRAP Score 6

Importance

Changes 0
Metric Value
cc 2
eloc 4
nc 2
nop 2
dl 0
loc 9
rs 10
c 0
b 0
f 0
ccs 0
cts 0
cp 0
crap 6
1
<?php
2
3
declare(strict_types=1);
4
5
namespace Yiisoft\Db\Expression;
6
7
use Yiisoft\Db\QueryBuilder\QueryBuilderInterface;
8
9
use function array_intersect_key;
10
use function array_merge;
11
use function preg_quote;
12
use function preg_replace;
13
use function str_starts_with;
14
15
/**
16
 * It's used to build expressions for use in database queries.
17
 *
18
 * It provides a methods {@see build()} for creating various types of expressions, such as conditions, joins, and
19 333
 * ordering clauses.
20
 *
21 333
 * These expressions can be used with the query builder to build complex and customizable database queries
22
 * {@see Expression} class.
23 333
 */
24
class ExpressionBuilder implements ExpressionBuilderInterface
25
{
26
    public function __construct(private QueryBuilderInterface $queryBuilder)
27
    {
28
    }
29
30
    public function build(Expression $expression, array &$params = []): string
31
    {
32
        $sql = $expression->__toString();
33
        $expressionParams = $expression->getParams();
34
35
        if (empty($expressionParams)) {
36
            return $sql;
37
        }
38
39
        if (isset($params[0]) || isset($expressionParams[0])) {
40
            $params = array_merge($params, $expressionParams);
41
            return $sql;
42
        }
43
44
        $sql = $this->appendParams($sql, $expressionParams, $params);
45
46
        return $this->replaceParamExpressions($sql, $expressionParams, $params);
47
    }
48
49
    private function appendParams(string $sql, array &$expressionParams, array &$params): string
50
    {
51
        $nonUniqueParams = array_intersect_key($expressionParams, $params);
52
        $params += $expressionParams;
53
54
        /** @var string $name */
55
        foreach ($nonUniqueParams as $name => $value) {
56
            $pattern = $this->getPattern($name);
57
            $uniqueName = $this->getUniqueName($name, $params);
58
59
            $replacement = !str_starts_with($uniqueName, ':') ? ":$uniqueName" : $uniqueName;
60
61
            $sql = preg_replace($pattern, $replacement, $sql, 1);
62
63
            $params[$uniqueName] = $value;
64
            $expressionParams[$uniqueName] = $value;
65
            unset($expressionParams[$name]);
66
        }
67
68
        return $sql;
69
    }
70
71
    private function replaceParamExpressions(string $sql, array $expressionParams, array &$params): string
72
    {
73
        /** @var string $name */
74
        foreach ($expressionParams as $name => $value) {
75
            if (!$value instanceof ExpressionInterface) {
76
                continue;
77
            }
78
79
            $pattern = $this->getPattern($name);
80
            $replacement = $this->queryBuilder->buildExpression($value, $params);
81
82
            $sql = preg_replace($pattern, $replacement, $sql, 1);
83
84
            unset($params[$name]);
85
        }
86
87
        return $sql;
88
    }
89
90
    /** @psalm-return non-empty-string */
91
    private function getPattern(string $name): string
92
    {
93
        if (!str_starts_with($name, ':')) {
94
            $name = ":$name";
95
        }
96
97
        return '/' . preg_quote($name, '/') . '\b/';
98
    }
99
100
    private function getUniqueName(string $name, array $params): string
101
    {
102
        $uniqueName = $name . '_0';
103
104
        for ($i = 1; isset($params[$uniqueName]); ++$i) {
105
            $uniqueName = $name . '_' . $i;
106
        }
107
108
        return $uniqueName;
109
    }
110
}
111