Split Like condition to Like and NotLike (#1023)

Author: vjik

CHANGELOG.md

@@ -125,6 +125,7 @@
 - Chg #1017: Split `Between` condition to `Between` and `NotBetween` (@vjik)
 - New #1020: Support column's collation (@Tigrov)
 - Chg #1021: Move conjunction type from operator string value to `Like` condition constructor parameter (@vjik)
+- Chg #1023: Split `Like` condition to `Like` and `NotLike` (@vjik)
 
 ## 1.3.0 March 21, 2024
 

src/QueryBuilder/AbstractDQLQueryBuilder.php

@@ -58,7 +58,7 @@ abstract class AbstractDQLQueryBuilder implements DQLQueryBuilderInterface
      *
      * ```php
      * return [
-     *     'LIKE' => \Yiisoft\Db\Condition\LikeCondition::class,
+     *     'LIKE' => \Yiisoft\Db\QueryBuilder\Condition\Like::class,
      * ];
      * ```
      *
@@ -523,7 +523,7 @@ protected function defaultConditionClasses(): array
             'IN' => Condition\In::class,
             'NOT IN' => Condition\NotIn::class,
             'LIKE' => Condition\Like::class,
-            'NOT LIKE' => Condition\Like::class,
+            'NOT LIKE' => Condition\NotLike::class,
             'EXISTS' => Condition\Exists::class,
             'NOT EXISTS' => Condition\Exists::class,
             'ARRAY OVERLAPS' => Condition\ArrayOverlaps::class,
@@ -554,6 +554,7 @@ protected function defaultExpressionBuilders(): array
             Condition\In::class => Condition\Builder\InBuilder::class,
             Condition\NotIn::class => Condition\Builder\InBuilder::class,
             Condition\Like::class => Condition\Builder\LikeBuilder::class,
+            Condition\NotLike::class => Condition\Builder\LikeBuilder::class,
             Condition\Equals::class => Condition\Builder\EqualsBuilder::class,
             Condition\Exists::class => Condition\Builder\ExistsBuilder::class,
             Simple::class => Condition\Builder\SimpleBuilder::class,

src/QueryBuilder/Condition/AbstractLike.php

@@ -0,0 +1,135 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Db\QueryBuilder\Condition;
+
+use InvalidArgumentException;
+use Yiisoft\Db\Expression\ExpressionInterface;
+
+use function is_int;
+use function is_string;
+use function sprintf;
+
+/**
+ * @internal
+ *
+ * Condition that represents `LIKE` operator.
+ */
+abstract class AbstractLike implements ConditionInterface
+{
+    private const DEFAULT_ESCAPE = true;
+    private const DEFAULT_MODE = LikeMode::Contains;
+    private const DEFAULT_CONJUNCTION = LikeConjunction::And;
+
+    /**
+     * @param ExpressionInterface|string $column The column name.
+     * @param ExpressionInterface|int|iterable|string|null $value The value to the right of operator.
+     * @param bool|null $caseSensitive Whether the comparison is case-sensitive. `null` means using the default
+     * behavior.
+     * @param bool $escape Whether to escape the value. Defaults to `true`. If `false`, the value will be used as is
+     * without escaping.
+     * @param LikeMode $mode The mode for the LIKE operation (contains, starts with, ends with or custom pattern).
+     * @param LikeConjunction $conjunction The conjunction to use for combining multiple LIKE conditions.
+     */
+    final public function __construct(
+        public readonly string|ExpressionInterface $column,
+        public readonly iterable|int|string|ExpressionInterface|null $value,
+        public readonly ?bool $caseSensitive = null,
+        public readonly bool $escape = self::DEFAULT_ESCAPE,
+        public readonly LikeMode $mode = self::DEFAULT_MODE,
+        public readonly LikeConjunction $conjunction = self::DEFAULT_CONJUNCTION,
+    ) {
+    }
+
+    /**
+     * Creates a condition based on the given operator and operands.
+     *
+     * @throws InvalidArgumentException If the number of operands isn't 2.
+     */
+    final public static function fromArrayDefinition(string $operator, array $operands): static
+    {
+        if (!isset($operands[0], $operands[1])) {
+            throw new InvalidArgumentException("Operator '$operator' requires two operands.");
+        }
+
+        if (isset($operands['mode'])) {
+            $mode = $operands['mode'];
+            if (!$mode instanceof LikeMode) {
+                throw new InvalidArgumentException(
+                    sprintf(
+                        'Operator "%s" requires "mode" to be an instance of %s. Got %s.',
+                        $operator,
+                        LikeMode::class,
+                        get_debug_type($mode),
+                    ),
+                );
+            }
+        } else {
+            $mode = self::DEFAULT_MODE;
+        }
+
+        if (isset($operands['conjunction'])) {
+            $conjunction = $operands['conjunction'];
+            if (!$conjunction instanceof LikeConjunction) {
+                throw new InvalidArgumentException(
+                    sprintf(
+                        'Operator "%s" requires "conjunction" to be an instance of %s. Got %s.',
+                        $operator,
+                        LikeConjunction::class,
+                        get_debug_type($conjunction),
+                    ),
+                );
+            }
+        } else {
+            $conjunction = self::DEFAULT_CONJUNCTION;
+        }
+
+        return new static(
+            self::validateColumn($operator, $operands[0]),
+            self::validateValue($operator, $operands[1]),
+            isset($operands['caseSensitive']) ? (bool) $operands['caseSensitive'] : null,
+            isset($operands['escape']) ? (bool) $operands['escape'] : self::DEFAULT_ESCAPE,
+            $mode,
+            $conjunction,
+        );
+    }
+
+    /**
+     * Validates the given column to be `string` or `ExpressionInterface`.
+     *
+     * @throws InvalidArgumentException
+     */
+    private static function validateColumn(string $operator, mixed $column): string|ExpressionInterface
+    {
+        if (is_string($column) || $column instanceof ExpressionInterface) {
+            return $column;
+        }
+
+        throw new InvalidArgumentException("Operator '$operator' requires column to be string or ExpressionInterface.");
+    }
+
+    /**
+     * Validates the given values to be `string`, `int`, `iterable` or `ExpressionInterface`.
+     *
+     * @throws InvalidArgumentException If the values aren't `string`, `int`, `iterable` or `ExpressionInterface`.
+     */
+    private static function validateValue(
+        string $operator,
+        mixed $value
+    ): iterable|int|string|ExpressionInterface|null {
+        if (
+            is_string($value) ||
+            is_iterable($value) ||
+            is_int($value) ||
+            $value instanceof ExpressionInterface ||
+            $value === null
+        ) {
+            return $value;
+        }
+
+        throw new InvalidArgumentException(
+            "Operator '$operator' requires value to be string, int, iterable or ExpressionInterface."
+        );
+    }
+}

src/QueryBuilder/Condition/Builder/LikeBuilder.php

@@ -4,6 +4,7 @@
 
 namespace Yiisoft\Db\QueryBuilder\Condition\Builder;
 
+use Traversable;
 use Yiisoft\Db\Command\Param;
 use Yiisoft\Db\Constant\DataType;
 use Yiisoft\Db\Exception\Exception;
@@ -15,27 +16,25 @@
 use Yiisoft\Db\QueryBuilder\Condition\Like;
 use Yiisoft\Db\QueryBuilder\Condition\LikeConjunction;
 use Yiisoft\Db\QueryBuilder\Condition\LikeMode;
+use Yiisoft\Db\QueryBuilder\Condition\NotLike;
 use Yiisoft\Db\QueryBuilder\QueryBuilderInterface;
 
 use function implode;
-use function is_array;
-use function preg_match;
+use function is_string;
 use function str_contains;
-use function strtoupper;
 use function strtr;
 
 /**
- * Build an object of {@see Like} into SQL expressions.
+ * Build an object of {@see Like} or {@see NotLike} into SQL expressions.
  *
- * @implements ExpressionBuilderInterface<Like>
+ * @implements ExpressionBuilderInterface<Like|NotLike>
  */
 class LikeBuilder implements ExpressionBuilderInterface
 {
-    public function __construct(
-        private readonly QueryBuilderInterface $queryBuilder,
-        private readonly string|null $escapeSql = null
-    ) {
-    }
+    /**
+     * @var string SQL fragment to append to the end of `LIKE` conditions.
+     */
+    protected const ESCAPE_SQL = '';
 
     /**
      * @var array Map of chars to their replacements in `LIKE` conditions. By default, it's configured to escape
@@ -47,10 +46,15 @@ public function __construct(
         '\\' => '\\\\',
     ];
 
+    public function __construct(
+        private readonly QueryBuilderInterface $queryBuilder,
+    ) {
+    }
+
     /**
-     * Build SQL for {@see Like}.
+     * Build SQL for {@see Like} or {@see NotLike}.
      *
-     * @param Like $expression
+     * @param Like|NotLike $expression
      *
      * @throws Exception
      * @throws InvalidArgumentException
@@ -61,24 +65,30 @@ public function build(ExpressionInterface $expression, array &$params = []): str
     {
         $values = $expression->value;
 
-        [$not, $operator] = $this->parseOperator($expression);
+        [$not, $operator] = $this->getOperatorData($expression);
 
-        if (!is_array($values)) {
-            $values = [$values];
+        if ($values === null) {
+            return $this->buildForEmptyValue($not);
         }
 
-        if (empty($values)) {
-            return $not ? '' : '0=1';
+        if (is_iterable($values)) {
+            if ($values instanceof Traversable) {
+                $values = iterator_to_array($values);
+            }
+            if (empty($values)) {
+                return $this->buildForEmptyValue($not);
+            }
+        } else {
+            $values = [$values];
         }
 
         $column = $this->prepareColumn($expression, $params);
 
         $parts = [];
-
-        /** @psalm-var list<string|ExpressionInterface> $values */
         foreach ($values as $value) {
+            /** @var ExpressionInterface|int|string $value */
             $placeholderName = $this->preparePlaceholderName($value, $expression, $params);
-            $parts[] = "$column $operator $placeholderName$this->escapeSql";
+            $parts[] = "$column $operator $placeholderName" . static::ESCAPE_SQL;
         }
 
         $conjunction = match ($expression->conjunction) {
@@ -97,7 +107,7 @@ public function build(ExpressionInterface $expression, array &$params = []): str
      * @throws InvalidConfigException
      * @throws NotSupportedException
      */
-    protected function prepareColumn(Like $condition, array &$params): string
+    protected function prepareColumn(Like|NotLike $condition, array &$params): string
     {
         $column = $condition->column;
 
@@ -122,45 +132,43 @@ protected function prepareColumn(Like $condition, array &$params): string
      * @return string
      */
     protected function preparePlaceholderName(
-        string|ExpressionInterface $value,
-        Like $condition,
+        string|int|ExpressionInterface $value,
+        Like|NotLike $condition,
         array &$params,
     ): string {
         if ($value instanceof ExpressionInterface) {
             return $this->queryBuilder->buildExpression($value, $params);
         }
 
-        if ($condition->escape) {
+        if (is_string($value) && $condition->escape) {
             $value = strtr($value, $this->escapingReplacements);
         }
 
         $value = match ($condition->mode) {
             LikeMode::Contains => '%' . $value . '%',
             LikeMode::StartsWith => $value . '%',
             LikeMode::EndsWith => '%' . $value,
-            LikeMode::Custom => $value,
+            LikeMode::Custom => (string) $value,
         };
 
         return $this->queryBuilder->bindParam(new Param($value, DataType::STRING), $params);
     }
 
     /**
-     * Parses operator and returns its parts.
-     *
-     * @throws InvalidArgumentException
+     * Get operator and `not` flag for the given condition.
      *
      * @psalm-return array{0: bool, 1: string}
      */
-    protected function parseOperator(Like $condition): array
+    protected function getOperatorData(Like|NotLike $condition): array
     {
-        $operator = strtoupper($condition->operator);
-        if (!preg_match('/^((NOT |)I?LIKE)/', $operator, $matches)) {
-            throw new InvalidArgumentException("Invalid operator in like condition: \"$operator\"");
-        }
-
-        $not = !empty($matches[2]);
-        $operator = $matches[1];
+        return match ($condition::class) {
+            Like::class => [false, 'LIKE'],
+            NotLike::class => [true, 'NOT LIKE'],
+        };
+    }
 
-        return [$not, $operator];
+    private function buildForEmptyValue(bool $not): string
+    {
+        return $not ? '' : '0=1';
     }
 }