LikeConditionBuilder::build() - Code Metrics - Inspection of "Change return type for query one and query column" - yiisoft/db - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#343)

by Sergei

created 2022-07-09 20:00 UTC

LikeConditionBuilder::build() B

↳ Parent: LikeConditionBuilder

Complexity

Conditions	10
Paths	44

Size

Total Lines	44
Code Lines	26

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	10
eloc	26
nc	44
nop	2
dl	0
loc	44
rs	7.6666
c	0
b	0
f	0

How to fix Complexity

<?php

declare(strict_types=1);

namespace Yiisoft\Db\QueryBuilder\Conditions\Builder;

use Yiisoft\Db\Exception\Exception;
use Yiisoft\Db\Exception\InvalidArgumentException;
use Yiisoft\Db\Exception\InvalidConfigException;
use Yiisoft\Db\Exception\NotSupportedException;
use Yiisoft\Db\Expression\ExpressionBuilderInterface;
use Yiisoft\Db\Expression\ExpressionInterface;
use Yiisoft\Db\QueryBuilder\Conditions\Interface\LikeConditionInterface;
use Yiisoft\Db\QueryBuilder\QueryBuilderInterface;

use function implode;
use function is_array;
use function preg_match;
use function strtoupper;

/**
 * Class LikeConditionBuilder builds objects of {@see LikeCondition}.
 */
class LikeConditionBuilder implements ExpressionBuilderInterface
{
    public function __construct(private QueryBuilderInterface $queryBuilder)
    {
    }

    /**
     * @var array map of chars to their replacements in LIKE conditions. By default, it's configured to escape
     * `%`, `_` and `\` with `\`.
     */
    protected array $escapingReplacements = [
        '%' => '\%',
        '_' => '\_',
        '\\' => '\\\\',
    ];
    protected ?string $escapeCharacter = null;

    /**
     * @throws Exception|InvalidArgumentException|InvalidConfigException|NotSupportedException
     */
    public function build(LikeConditionInterface $expression, array &$params = []): string
    {
        $operator = strtoupper($expression->getOperator());
        $column = $expression->getColumn();
        $values = $expression->getValue();
        $escape = $expression->getEscapingReplacements();

        if ($escape === []) {
            $escape = $this->escapingReplacements;
        }

        [$andor, $not, $operator] = $this->parseOperator($operator);

        if (!is_array($values)) {
            $values = [$values];
        }

        if (empty($values)) {
            return $not ? '' : '0=1';
        }

        if ($column instanceof ExpressionInterface) {
            $column = $this->queryBuilder->buildExpression($column, $params);
        } elseif (!str_contains($column, '(')) {
            $column = $this->queryBuilder->quoter()->quoteColumnName($column);
        }

        $escapeSql = $this->getEscapeSql();
        $parts = [];

        /** @psalm-var string[] $values */
        foreach ($values as $value) {
            if ($value instanceof ExpressionInterface) {
                $phName = $this->queryBuilder->buildExpression($value, $params);
            } else {
                $phName = $this->queryBuilder->bindParam(
                    $escape === null ? $value : ('%' . strtr($value, $escape) . '%'),
                    $params
                );
            }
            $parts[] = "{$column} {$operator} {$phName}{$escapeSql}";
        }

        return implode($andor, $parts);
    }

    /**
     * @param string $operator
     *
     * @throws InvalidArgumentException
     *
     * @return array
     *
     * @psalm-return array{0: string, 1: bool, 2: string}
     */
    protected function parseOperator(string $operator): array
    {
        if (!preg_match('/^(AND |OR |)((NOT |)I?LIKE)/', $operator, $matches)) {
            throw new InvalidArgumentException("Invalid operator '$operator'.");
        }

        $andor = ' ' . (!empty($matches[1]) ? $matches[1] : 'AND ');
        $not = !empty($matches[3]);
        $operator = $matches[2];

        return [$andor, $not, $operator];
    }

    /**
     * @return string character used to escape special characters in LIKE conditions. By default,
     * it's assumed to be `\`.
     */
    private function getEscapeSql(): string
    {
        if ($this->escapeCharacter !== null) {
            return " ESCAPE '{$this->escapeCharacter}'";
        }

        return '';
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Yiisoft\Db\QueryBuilder\Conditions\Builder;
6
7			use Yiisoft\Db\Exception\Exception;
8			use Yiisoft\Db\Exception\InvalidArgumentException;
9			use Yiisoft\Db\Exception\InvalidConfigException;
10			use Yiisoft\Db\Exception\NotSupportedException;
11			use Yiisoft\Db\Expression\ExpressionBuilderInterface;
12			use Yiisoft\Db\Expression\ExpressionInterface;
13			use Yiisoft\Db\QueryBuilder\Conditions\Interface\LikeConditionInterface;
14			use Yiisoft\Db\QueryBuilder\QueryBuilderInterface;
15
16			use function implode;
17			use function is_array;
18			use function preg_match;
19			use function strtoupper;
20
21			/**
22			* Class LikeConditionBuilder builds objects of {@see LikeCondition}.
23			*/
24			class LikeConditionBuilder implements ExpressionBuilderInterface
25			{
26			public function __construct(private QueryBuilderInterface $queryBuilder)
27			{
28			}
29
30			/**
31			* @var array map of chars to their replacements in LIKE conditions. By default, it's configured to escape
32			* `%`, `_` and `\` with `\`.
33			*/
34			protected array $escapingReplacements = [
35			'%' => '\%',
36			'_' => '\_',
37			'\\' => '\\\\',
38			];
39			protected ?string $escapeCharacter = null;
40
41			/**
42			* @throws Exception\|InvalidArgumentException\|InvalidConfigException\|NotSupportedException
43			*/
44			public function build(LikeConditionInterface $expression, array &$params = []): string
45			{
46			$operator = strtoupper($expression->getOperator());
47			$column = $expression->getColumn();
48			$values = $expression->getValue();
49			$escape = $expression->getEscapingReplacements();
50
51			if ($escape === []) {
52			$escape = $this->escapingReplacements;
53			}
54
55			[$andor, $not, $operator] = $this->parseOperator($operator);
56
57			if (!is_array($values)) {
58			$values = [$values];
59			}
60
61			if (empty($values)) {
62			return $not ? '' : '0=1';
63			}
64
65			if ($column instanceof ExpressionInterface) {
66			$column = $this->queryBuilder->buildExpression($column, $params);
67			} elseif (!str_contains($column, '(')) {
68			$column = $this->queryBuilder->quoter()->quoteColumnName($column);
69			}
70
71			$escapeSql = $this->getEscapeSql();
72			$parts = [];
73
74			/** @psalm-var string[] $values */
75			foreach ($values as $value) {
76			if ($value instanceof ExpressionInterface) {
77			$phName = $this->queryBuilder->buildExpression($value, $params);
78			} else {
79			$phName = $this->queryBuilder->bindParam(
80			$escape === null ? $value : ('%' . strtr($value, $escape) . '%'),
81			$params
82			);
83			}
84			$parts[] = "{$column} {$operator} {$phName}{$escapeSql}";
85			}
86
87			return implode($andor, $parts);
88			}
89
90			/**
91			* @param string $operator
92			*
93			* @throws InvalidArgumentException
94			*
95			* @return array
96			*
97			* @psalm-return array{0: string, 1: bool, 2: string}
98			*/
99			protected function parseOperator(string $operator): array
100			{
101			if (!preg_match('/^(AND \|OR \|)((NOT \|)I?LIKE)/', $operator, $matches)) {
102			throw new InvalidArgumentException("Invalid operator '$operator'.");
103			}
104
105			$andor = ' ' . (!empty($matches[1]) ? $matches[1] : 'AND ');
106			$not = !empty($matches[3]);
107			$operator = $matches[2];
108
109			return [$andor, $not, $operator];
110			}
111
112			/**
113			* @return string character used to escape special characters in LIKE conditions. By default,
114			* it's assumed to be `\`.
115			*/
116			private function getEscapeSql(): string
117			{
118			if ($this->escapeCharacter !== null) {
119			return " ESCAPE '{$this->escapeCharacter}'";
120			}
121
122			return '';
123			}
124			}
125

yiisoft / db

Pull Request — master (#343)

LikeConditionBuilder::build() B

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like