Add support for whereFullText (#30)

SingleStore's syntax is slightly different from MySQL https://docs.singlestore.com/managed-service/en/reference/sql-reference/full-text-search-functions/match.html

Author: fgilio

.gitignore

@@ -1,4 +1,5 @@
 .env
 /vendor/
 .phpunit.result.cache
-composer.lock
+composer.lock
+.idea

README.md

@@ -30,6 +30,7 @@ This repository contains the official SingleStoreDB Driver for Laravel. This dri
   - [Series Timestamps](#series-timestamps)
   - [Computed Columns](#computed-columns)
   - [Increment Columns without Primary Key](#increment-columns-without-primary-key)
+  - [Full-text search](#full-text-search-using-fulltext-indexes)
 - [Testing](#testing)
 - [License](#license)
 - [Resources](#resources)
@@ -395,6 +396,21 @@ Schema::create('test', function (Blueprint $table) {
 });
 ```
 
+### Full-text search using FULLTEXT indexes
+
+SingleStoreDB supports full-text search across text columns in a columnstore table using the `FULLTEXT` index type.
+
+Keep in mind that `FULLTEXT` is only supported when using the `utf8_unicode_ci` collation. An exception will be thrown if you try to add the index to a column with an unsupported collation.
+
+```php
+Schema::create('test', function (Blueprint $table) {
+    $table->id();
+    $table->text('first_name')->collation('utf8_unicode_ci');
+
+    $table->fullText(['first_name']);
+});
+```
+
 ## Testing
 
 Execute the tests using PHPUnit
@@ -425,6 +441,7 @@ This library is licensed under the Apache 2.0 License.
 
 * [SingleStore](https://singlestore.com)
 * [Laravel](https://laravel.com)
+* [Full-text search documentation](https://docs.singlestore.com/managed-service/en/reference/sql-reference/data-definition-language-ddl/create-table.html#fulltext-behavior)
 
 ## User agreement
 

src/Query/Grammar.php

@@ -7,6 +7,22 @@
 
 class Grammar extends MySqlGrammar
 {
+    /**
+     * Compile a "where fulltext" clause.
+     *
+     * @param  \Illuminate\Database\Query\Builder  $query
+     * @param  array  $where
+     * @return string
+     */
+    public function whereFullText(Builder $query, $where)
+    {
+        $columns = $this->columnize($where['columns']);
+
+        $value = $this->parameter($where['value']);
+
+        return "MATCH ({$columns}) AGAINST ({$value})";
+    }
+
     /**
      * @param $column
      * @param $value

src/Schema/Blueprint.php

@@ -2,7 +2,9 @@
 
 namespace SingleStore\Laravel\Schema;
 
+use Exception;
 use Illuminate\Database\Connection;
+use Illuminate\Database\QueryException;
 use Illuminate\Database\Schema\Blueprint as BaseBlueprint;
 use Illuminate\Database\Schema\Grammars\Grammar;
 use SingleStore\Laravel\Schema\Blueprint\AddsTableFlags;
@@ -31,4 +33,24 @@ public function toSql(Connection $connection, Grammar $grammar)
 
         return $this->creating() ? $this->inlineCreateIndexStatements($statements) : $statements;
     }
+
+    /**
+     * Execute the blueprint against the database.
+     *
+     * @param  \Illuminate\Database\Connection  $connection
+     * @param  \Illuminate\Database\Schema\Grammars\Grammar  $grammar
+     * @return void
+     */
+    public function build(Connection $connection, Grammar $grammar)
+    {
+        try {
+            parent::build($connection, $grammar);
+        } catch (QueryException $exception) {
+            if (str_contains($exception->getMessage(), 'FULLTEXT KEY with unsupported type')) {
+                throw new Exception('FULLTEXT is not supported when using the utf8mb4 collation.');
+            } else {
+                throw $exception;
+            }
+        }
+    }
 }

tests/Hybrid/CreateTable/MiscCreateTest.php

@@ -2,7 +2,6 @@
 
 namespace SingleStore\Laravel\Tests\Hybrid\CreateTable;
 
-use Illuminate\Foundation\Application;
 use SingleStore\Laravel\Schema\Blueprint;
 use SingleStore\Laravel\Tests\BaseTest;
 use SingleStore\Laravel\Tests\Hybrid\HybridTestHelpers;
@@ -14,24 +13,16 @@ class MiscCreateTest extends BaseTest
     /** @test */
     public function all_keys_are_added_in_create_columnstore()
     {
-        if (version_compare(Application::VERSION, '8.12.0', '<=')) {
-            // fulltext not added until later on in laravel 8 releases
-            $this->markTestSkipped('requires higher laravel version');
-
-            return;
-        }
-
         $blueprint = $this->createTable(function (Blueprint $table) {
             $table->string('primary')->primary('name1');
             $table->string('index')->index('name2');
             $table->string('foo');
             $table->index('foo', 'name3', 'hash');
-            $table->string('fulltext')->fulltext('name5')->charset('utf8');
         });
 
         $this->assertCreateStatement(
             $blueprint,
-            'create table `test` (`primary` varchar(255) not null, `index` varchar(255) not null, `foo` varchar(255) not null, `fulltext` varchar(255) character set utf8 not null, index `name3` using hash(`foo`), primary key `name1`(`primary`), index `name2`(`index`), fulltext `name5`(`fulltext`))'
+            'create table `test` (`primary` varchar(255) not null, `index` varchar(255) not null, `foo` varchar(255) not null, index `name3` using hash(`foo`), primary key `name1`(`primary`), index `name2`(`index`))'
         );
     }
 
@@ -51,27 +42,6 @@ public function all_keys_are_added_in_create_rowstore()
         );
     }
 
-    /** @test */
-    public function fulltext_index()
-    {
-        if (version_compare(Application::VERSION, '8.12.0', '<=')) {
-            // fulltext not added until later on in laravel 8 releases
-            $this->markTestSkipped('requires higher laravel version');
-
-            return;
-        }
-
-        $blueprint = $this->createTable(function (Blueprint $table) {
-            $table->string('name')->charset('utf8');
-            $table->fullText('name', 'idx');
-        });
-
-        $this->assertCreateStatement(
-            $blueprint,
-            'create table `test` (`name` varchar(255) character set utf8 not null, fulltext `idx`(`name`))'
-        );
-    }
-
     /** @test */
     public function medium_integer_id()
     {

tests/Hybrid/FulltextTest.php

@@ -0,0 +1,142 @@
+<?php
+
+namespace SingleStore\Laravel\Tests\Hybrid\Json;
+
+use Illuminate\Foundation\Application;
+use Illuminate\Support\Facades\DB;
+use SingleStore\Laravel\Schema\Blueprint;
+use SingleStore\Laravel\Tests\BaseTest;
+use SingleStore\Laravel\Tests\Hybrid\HybridTestHelpers;
+
+class FulltextTest extends BaseTest
+{
+    use HybridTestHelpers;
+
+    /** @test */
+    public function fulltext()
+    {
+        if (version_compare(Application::VERSION, '8.79.0', '<=')) {
+            // fulltext not added until later on in laravel 8 releases
+            $this->markTestSkipped('requires higher laravel version');
+
+            return;
+        }
+
+        $query = DB::table('test')->whereFullText('title', 'performance');
+
+        $this->assertEquals(
+            'select * from `test` where MATCH (`title`) AGAINST (?)',
+            $query->toSql()
+        );
+
+        $this->assertSame('performance', $query->getBindings()[0]);
+
+        if (! $this->runHybridIntegrations()) {
+            return;
+        }
+
+        $this->createTable(function (Blueprint $table) {
+            $table->id();
+            $table->text('title')->collation('utf8_unicode_ci');
+
+            $table->fullText(['title']);
+        });
+
+        DB::table('test')->insert([[
+            'title' => 'Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems',
+        ], [
+            'title' => 'Data Pipelines Pocket Reference: Moving and Processing Data for Analytics',
+        ], [
+            'title' => 'Data Quality Fundamentals',
+        ], [
+            'title' => 'High Performance MySQL: Optimization, Backups, and Replication',
+        ]]);
+
+        // Force the index to be updated immediately, as it may happen async a little later
+        DB::statement('OPTIMIZE TABLE test FLUSH');
+
+        $this->assertSame(
+            'High Performance MySQL: Optimization, Backups, and Replication',
+            $query->get()[0]->title
+        );
+    }
+
+    /** @test */
+    public function fulltext_multicolumn()
+    {
+        if (version_compare(Application::VERSION, '8.79.0', '<=')) {
+            // fulltext not added until later on in laravel 8 releases
+            $this->markTestSkipped('requires higher laravel version');
+
+            return;
+        }
+
+        $query = DB::table('test')->whereFullText(['name', 'race'], 'Laika');
+
+        $this->assertEquals(
+            'select * from `test` where MATCH (`name`, `race`) AGAINST (?)',
+            $query->toSql()
+        );
+
+        $this->assertSame('Laika', $query->getBindings()[0]);
+
+        if (! $this->runHybridIntegrations()) {
+            return;
+        }
+
+        $this->createTable(function (Blueprint $table) {
+            $table->id();
+            $table->text('name')->collation('utf8_unicode_ci');
+            $table->text('race')->collation('utf8_unicode_ci');
+
+            $table->fullText(['name', 'race']);
+        });
+
+        DB::table('test')->insert([[
+            'name' => 'Laika',
+            'race' => 'Dog',
+        ], [
+            'name' => 'Ham',
+            'race' => 'Monkey',
+        ]]);
+
+        // Force the index to be updated immediately, as it may happen async a little later
+        DB::statement('OPTIMIZE TABLE test FLUSH');
+
+        $this->assertSame('Laika', $query->get()[0]->name);
+    }
+
+    /** @test */
+    public function throws_exception_when_using_an_unsupported_collation()
+    {
+        if (version_compare(Application::VERSION, '8.79.0', '<=')) {
+            // fulltext not added until later on in laravel 8 releases
+            $this->markTestSkipped('requires higher laravel version');
+
+            return;
+        }
+
+        if (! $this->runHybridIntegrations()) {
+            return;
+        }
+
+        try {
+            // The default collation is utf8mb4_general_ci, which is unsupported for FULLTEXT
+            $this->createTable(function (Blueprint $table) {
+                $table->id();
+                $table->text('name');
+
+                $table->fullText(['name']);
+            });
+        } catch (\Exception $exception) {
+            $this->assertEquals(
+                'FULLTEXT is not supported when using the utf8mb4 collation.',
+                $exception->getMessage()
+            );
+
+            return;
+        }
+
+        $this->fail('Did not throw exception when using an unsupported collation');
+    }
+}