Add support for new "not" query types in database queries

Co-authored-by: jakeb994 <jakeb994@gmail.com>

src/Database/Adapter/MariaDB.php

@@ -1707,22 +1707,25 @@ protected function getSQLCondition(Query $query, array &$binds): string
 
                 return "{$alias}.{$attribute} BETWEEN :{$placeholder}_0 AND :{$placeholder}_1";
 
+            case Query::TYPE_NOT_BETWEEN:
+                $binds[":{$placeholder}_0"] = $query->getValues()[0];
+                $binds[":{$placeholder}_1"] = $query->getValues()[1];
+
+                return "{$alias}.{$attribute} NOT BETWEEN :{$placeholder}_0 AND :{$placeholder}_1";
+
             case Query::TYPE_IS_NULL:
             case Query::TYPE_IS_NOT_NULL:
 
                 return "{$alias}.{$attribute} {$this->getSQLOperator($query->getMethod())}";
 
             case Query::TYPE_CONTAINS:
-                if ($this->getSupportForJSONOverlaps() && $query->onArray()) {
-                    $binds[":{$placeholder}_0"] = json_encode($query->getValues());
-                    return "JSON_OVERLAPS({$alias}.{$attribute}, :{$placeholder}_0)";
-                }
-
-                // no break! continue to default case
             case Query::TYPE_NOT_CONTAINS:
                 if ($this->getSupportForJSONOverlaps() && $query->onArray()) {
                     $binds[":{$placeholder}_0"] = json_encode($query->getValues());
-                    return "NOT (JSON_OVERLAPS({$alias}.{$attribute}, :{$placeholder}_0))";
+                    $isNot = $query->getMethod() === Query::TYPE_NOT_CONTAINS;
+                    return $isNot 
+                        ? "NOT (JSON_OVERLAPS({$alias}.{$attribute}, :{$placeholder}_0))"
+                        : "JSON_OVERLAPS({$alias}.{$attribute}, :{$placeholder}_0)";
                 }
 
                 // no break! continue to default case

src/Database/Adapter/Postgres.php

@@ -1803,17 +1803,21 @@ protected function getSQLCondition(Query $query, array &$binds): string
                 $binds[":{$placeholder}_1"] = $query->getValues()[1];
                 return "{$alias}.{$attribute} BETWEEN :{$placeholder}_0 AND :{$placeholder}_1";
 
+            case Query::TYPE_NOT_BETWEEN:
+                $binds[":{$placeholder}_0"] = $query->getValues()[0];
+                $binds[":{$placeholder}_1"] = $query->getValues()[1];
+                return "{$alias}.{$attribute} NOT BETWEEN :{$placeholder}_0 AND :{$placeholder}_1";
+
             case Query::TYPE_IS_NULL:
             case Query::TYPE_IS_NOT_NULL:
                 return "{$alias}.{$attribute} {$this->getSQLOperator($query->getMethod())}";
 
             case Query::TYPE_CONTAINS:
-                $operator = $query->onArray() ? '@>' : null;
-
-                // no break
             case Query::TYPE_NOT_CONTAINS:
-                if ($query->getMethod() === Query::TYPE_NOT_CONTAINS) {
-                    $operator = $query->onArray() ? 'NOT @>' : null;
+                if ($query->onArray()) {
+                    $operator = $query->getMethod() === Query::TYPE_NOT_CONTAINS ? 'NOT @>' : '@>';
+                } else {
+                    $operator = null;
                 }
 
                 // no break

src/Database/Query.php

@@ -21,6 +21,7 @@ class Query
     public const TYPE_IS_NULL = 'isNull';
     public const TYPE_IS_NOT_NULL = 'isNotNull';
     public const TYPE_BETWEEN = 'between';
+    public const TYPE_NOT_BETWEEN = 'notBetween';
     public const TYPE_STARTS_WITH = 'startsWith';
     public const TYPE_NOT_STARTS_WITH = 'notStartsWith';
     public const TYPE_ENDS_WITH = 'endsWith';
@@ -58,6 +59,7 @@ class Query
         self::TYPE_IS_NULL,
         self::TYPE_IS_NOT_NULL,
         self::TYPE_BETWEEN,
+        self::TYPE_NOT_BETWEEN,
         self::TYPE_STARTS_WITH,
         self::TYPE_NOT_STARTS_WITH,
         self::TYPE_ENDS_WITH,
@@ -226,6 +228,7 @@ public static function isMethod(string $value): bool
             self::TYPE_IS_NULL,
             self::TYPE_IS_NOT_NULL,
             self::TYPE_BETWEEN,
+            self::TYPE_NOT_BETWEEN,
             self::TYPE_STARTS_WITH,
             self::TYPE_NOT_STARTS_WITH,
             self::TYPE_ENDS_WITH,
@@ -466,6 +469,19 @@ public static function between(string $attribute, string|int|float|bool $start,
         return new self(self::TYPE_BETWEEN, $attribute, [$start, $end]);
     }
 
+    /**
+     * Helper method to create Query with notBetween method
+     *
+     * @param string $attribute
+     * @param string|int|float|bool $start
+     * @param string|int|float|bool $end
+     * @return Query
+     */
+    public static function notBetween(string $attribute, string|int|float|bool $start, string|int|float|bool $end): self
+    {
+        return new self(self::TYPE_NOT_BETWEEN, $attribute, [$start, $end]);
+    }
+
     /**
      * Helper method to create Query with search method
      *

src/Database/Validator/Queries.php

@@ -97,6 +97,7 @@ public function isValid($value): bool
                 Query::TYPE_IS_NULL,
                 Query::TYPE_IS_NOT_NULL,
                 Query::TYPE_BETWEEN,
+                Query::TYPE_NOT_BETWEEN,
                 Query::TYPE_STARTS_WITH,
                 Query::TYPE_NOT_STARTS_WITH,
                 Query::TYPE_CONTAINS,

src/Database/Validator/Query/Filter.php

@@ -260,6 +260,7 @@ public function isValid($value): bool
                 return $this->isValidAttributeAndValues($attribute, $value->getValues(), $method);
 
             case Query::TYPE_BETWEEN:
+            case Query::TYPE_NOT_BETWEEN:
                 if (count($value->getValues()) != 2) {
                     $this->message = \ucfirst($method) . ' queries require exactly two values.';
                     return false;

tests/unit/Adapter/NewQueryAdapterTest.php

@@ -0,0 +1,189 @@
+<?php
+
+namespace Tests\Unit\Adapter;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Query;
+use Utopia\Database\Adapter\MariaDB;
+use Utopia\Database\Adapter\Postgres;
+
+class NewQueryAdapterTest extends TestCase
+{
+    protected function getMockMariaDBAdapter(): MariaDB
+    {
+        // Create a mock MariaDB adapter to test SQL generation
+        $mock = $this->getMockBuilder(MariaDB::class)
+            ->disableOriginalConstructor()
+            ->onlyMethods(['getPDO', 'getInternalKeyForAttribute', 'filter', 'quote', 'escapeWildcards', 'getSupportForJSONOverlaps', 'getSQLOperator', 'getFulltextValue'])
+            ->getMock();
+
+        $mock->method('getInternalKeyForAttribute')->willReturnArgument(0);
+        $mock->method('filter')->willReturnArgument(0);
+        $mock->method('quote')->willReturnCallback(function($value) { return "`{$value}`"; });
+        $mock->method('escapeWildcards')->willReturnArgument(0);
+        $mock->method('getSupportForJSONOverlaps')->willReturn(true);
+        $mock->method('getSQLOperator')->willReturn('LIKE');
+        $mock->method('getFulltextValue')->willReturnArgument(0);
+
+        return $mock;
+    }
+
+    protected function getMockPostgresAdapter(): Postgres
+    {
+        // Create a mock Postgres adapter to test SQL generation
+        $mock = $this->getMockBuilder(Postgres::class)
+            ->disableOriginalConstructor()
+            ->onlyMethods(['getPDO', 'getInternalKeyForAttribute', 'filter', 'quote', 'escapeWildcards', 'getSQLOperator', 'getFulltextValue'])
+            ->getMock();
+
+        $mock->method('getInternalKeyForAttribute')->willReturnArgument(0);
+        $mock->method('filter')->willReturnArgument(0);
+        $mock->method('quote')->willReturnCallback(function($value) { return "\"{$value}\""; });
+        $mock->method('escapeWildcards')->willReturnArgument(0);
+        $mock->method('getSQLOperator')->willReturn('LIKE');
+        $mock->method('getFulltextValue')->willReturnArgument(0);
+
+        return $mock;
+    }
+
+    public function testMariaDBNotSearchSQLGeneration(): void
+    {
+        $adapter = $this->getMockMariaDBAdapter();
+        $query = Query::notSearch('content', 'unwanted');
+        $binds = [];
+
+        $result = $adapter->getSQLCondition($query, $binds);
+
+        $this->assertStringContainsString('NOT (MATCH', $result);
+        $this->assertStringContainsString('AGAINST', $result);
+        $this->assertArrayHasKey(':uid_0', $binds);
+        $this->assertEquals('unwanted', $binds[':uid_0']);
+    }
+
+    public function testMariaDBNotBetweenSQLGeneration(): void
+    {
+        $adapter = $this->getMockMariaDBAdapter();
+        $query = Query::notBetween('score', 10, 20);
+        $binds = [];
+
+        $result = $adapter->getSQLCondition($query, $binds);
+
+        $this->assertStringContainsString('NOT BETWEEN', $result);
+        $this->assertArrayHasKey(':uid_0', $binds);
+        $this->assertArrayHasKey(':uid_1', $binds);
+        $this->assertEquals(10, $binds[':uid_0']);
+        $this->assertEquals(20, $binds[':uid_1']);
+    }
+
+    public function testMariaDBNotContainsArraySQLGeneration(): void
+    {
+        $adapter = $this->getMockMariaDBAdapter();
+        $query = Query::notContains('tags', ['unwanted', 'spam']);
+        $query->setOnArray(true);
+        $binds = [];
+
+        $result = $adapter->getSQLCondition($query, $binds);
+
+        $this->assertStringContainsString('NOT (JSON_OVERLAPS', $result);
+    }
+
+    public function testMariaDBNotContainsStringSQLGeneration(): void
+    {
+        $adapter = $this->getMockMariaDBAdapter();
+        $query = Query::notContains('title', ['unwanted']);
+        $binds = [];
+
+        $result = $adapter->getSQLCondition($query, $binds);
+
+        $this->assertStringContainsString('NOT LIKE', $result);
+        $this->assertStringContainsString('%unwanted%', array_values($binds)[0]);
+    }
+
+    public function testMariaDBNotStartsWithSQLGeneration(): void
+    {
+        $adapter = $this->getMockMariaDBAdapter();
+        $query = Query::notStartsWith('title', 'temp');
+        $binds = [];
+
+        $result = $adapter->getSQLCondition($query, $binds);
+
+        $this->assertStringContainsString('NOT LIKE', $result);
+        $this->assertStringContainsString('temp%', array_values($binds)[0]);
+    }
+
+    public function testMariaDBNotEndsWithSQLGeneration(): void
+    {
+        $adapter = $this->getMockMariaDBAdapter();
+        $query = Query::notEndsWith('filename', '.tmp');
+        $binds = [];
+
+        $result = $adapter->getSQLCondition($query, $binds);
+
+        $this->assertStringContainsString('NOT LIKE', $result);
+        $this->assertStringContainsString('%.tmp', array_values($binds)[0]);
+    }
+
+    public function testPostgresNotSearchSQLGeneration(): void
+    {
+        $adapter = $this->getMockPostgresAdapter();
+        $query = Query::notSearch('content', 'unwanted');
+        $binds = [];
+
+        $result = $adapter->getSQLCondition($query, $binds);
+
+        $this->assertStringContainsString('NOT (to_tsvector', $result);
+        $this->assertStringContainsString('websearch_to_tsquery', $result);
+        $this->assertArrayHasKey(':uid_0', $binds);
+    }
+
+    public function testPostgresNotBetweenSQLGeneration(): void
+    {
+        $adapter = $this->getMockPostgresAdapter();
+        $query = Query::notBetween('score', 10, 20);
+        $binds = [];
+
+        $result = $adapter->getSQLCondition($query, $binds);
+
+        $this->assertStringContainsString('NOT BETWEEN', $result);
+        $this->assertArrayHasKey(':uid_0', $binds);
+        $this->assertArrayHasKey(':uid_1', $binds);
+    }
+
+    public function testPostgresNotContainsArraySQLGeneration(): void
+    {
+        $adapter = $this->getMockPostgresAdapter();
+        $query = Query::notContains('tags', ['unwanted']);
+        $query->setOnArray(true);
+        $binds = [];
+
+        $result = $adapter->getSQLCondition($query, $binds);
+
+        $this->assertStringContainsString('NOT @>', $result);
+    }
+
+    public function testNotQueryUsesAndLogic(): void
+    {
+        // Test that NOT queries use AND logic instead of OR
+        $adapter = $this->getMockMariaDBAdapter();
+        $query = Query::notContains('tags', ['unwanted', 'spam']);
+        $binds = [];
+
+        $result = $adapter->getSQLCondition($query, $binds);
+
+        // For NOT queries, multiple values should be combined with AND
+        $this->assertStringContainsString(' AND ', $result);
+    }
+
+    public function testRegularQueryUsesOrLogic(): void
+    {
+        // Test that regular queries still use OR logic
+        $adapter = $this->getMockMariaDBAdapter();
+        $query = Query::contains('tags', ['wanted', 'good']);
+        $binds = [];
+
+        $result = $adapter->getSQLCondition($query, $binds);
+
+        // For regular queries, multiple values should be combined with OR
+        $this->assertStringContainsString(' OR ', $result);
+    }
+}