wip

Author: pascalbaljet

.github/workflows/run-tests.yml

@@ -14,6 +14,7 @@ jobs:
         php: [8.4, 8.3, 8.2]
         laravel: ["10.*", "11.*", "12.*"]
         dependency-version: [prefer-lowest, prefer-stable]
+        db_connection: [mysql, sqlite]
         include:
           - laravel: 10.*
             testbench: ^8.32
@@ -22,7 +23,7 @@ jobs:
           - laravel: 12.*
             testbench: ^10.0
 
-    name: P${{ matrix.php }} - L${{ matrix.laravel }} - ${{ matrix.dependency-version }}
+    name: P${{ matrix.php }} - L${{ matrix.laravel }} - ${{ matrix.db_connection }} - ${{ matrix.dependency-version }}
 
     services:
       mysql:
@@ -62,6 +63,7 @@ jobs:
       - name: Execute tests
         run: vendor/bin/phpunit
         env:
+          DB_CONNECTION: ${{ matrix.db_connection }}
           DB_DATABASE: protone_media_db_test
           DB_USERNAME: protone_media_db_test
           DB_PASSWORD: secret

README.md

@@ -16,9 +16,18 @@ This Laravel package allows you to search through multiple Eloquent models. It s
 ## Requirements
 
 * PHP 8.2 or higher
-* MySQL 8.0+
+* MySQL 8.0+ or SQLite 3.8+
 * Laravel 10.0+
 
+## Database Support
+
+This package supports both **MySQL** and **SQLite** databases. Most features work identically across both database systems, with the following limitations for SQLite:
+
+* **Sounds Like**: The `soundsLike()` method falls back to regular `LIKE` matching since SQLite doesn't support the `SOUNDS LIKE` operator
+* **Full-Text Search**: MySQL's `MATCH() AGAINST()` full-text search falls back to `LIKE` matching on SQLite
+
+All other features including cross-model search, pagination, sorting, and relationship searching work identically on both database systems.
+
 ## Features
 
 * Search through one or more [Eloquent models](https://laravel.com/docs/master/eloquent).
@@ -253,6 +262,8 @@ Search::new()
     ->search('framework -css');
 ```
 
+**Note**: On SQLite databases, full-text search automatically falls back to regular `LIKE` matching since SQLite doesn't support MySQL's `MATCH() AGAINST()` syntax.
+
 ### Sounds like
 
 MySQL has a *soundex* algorithm built-in so you can search for terms that sound almost the same. You can use this feature by calling the `soundsLike` method:
@@ -265,6 +276,8 @@ Search::new()
     ->search('larafel');
 ```
 
+**Note**: On SQLite databases, this feature automatically falls back to regular `LIKE` matching since SQLite doesn't support the `SOUNDS LIKE` operator.
+
 ### Eager load relationships
 
 Not much to explain here, but this is supported as well :)

src/DatabaseGrammarFactory.php

@@ -0,0 +1,40 @@
+<?php declare(strict_types=1);
+
+namespace ProtoneMedia\LaravelCrossEloquentSearch;
+
+use Illuminate\Database\Connection;
+use ProtoneMedia\LaravelCrossEloquentSearch\Grammars\MySqlSearchGrammar;
+use ProtoneMedia\LaravelCrossEloquentSearch\Grammars\SQLiteSearchGrammar;
+use ProtoneMedia\LaravelCrossEloquentSearch\Grammars\SearchGrammarInterface;
+
+/**
+ * Factory for creating database-specific search grammar instances.
+ *
+ * This factory provides database-agnostic access to search functionality by 
+ * creating the appropriate grammar implementation based on the database driver.
+ * Currently supports MySQL/MariaDB and SQLite.
+ */
+class DatabaseGrammarFactory
+{
+    /**
+     * Create a search grammar instance for the given database connection.
+     *
+     * @param \Illuminate\Database\Connection $connection
+     * @return \ProtoneMedia\LaravelCrossEloquentSearch\Grammars\SearchGrammarInterface
+     * @throws \InvalidArgumentException
+     */
+    public static function make(Connection $connection): SearchGrammarInterface
+    {
+        $driver = $connection->getDriverName();
+
+        switch ($driver) {
+            case 'mysql':
+            case 'mariadb':
+                return new MySqlSearchGrammar($connection);
+            case 'sqlite':
+                return new SQLiteSearchGrammar($connection);
+            default:
+                throw new \InvalidArgumentException("Database driver '{$driver}' is not supported for cross-eloquent search.");
+        }
+    }
+}

src/Grammars/MySqlSearchGrammar.php

@@ -0,0 +1,137 @@
+<?php declare(strict_types=1);
+
+namespace ProtoneMedia\LaravelCrossEloquentSearch\Grammars;
+
+use Illuminate\Database\Connection;
+use Illuminate\Database\Query\Grammars\MySqlGrammar;
+
+/**
+ * MySQL-specific search grammar implementation.
+ */
+class MySqlSearchGrammar implements SearchGrammarInterface
+{
+    protected Connection $connection;
+    protected MySqlGrammar $grammar;
+
+    /**
+     * Create a new MySQL search grammar instance.
+     *
+     * @param \Illuminate\Database\Connection $connection
+     */
+    public function __construct(Connection $connection)
+    {
+        $this->connection = $connection;
+        $this->grammar = new MySqlGrammar($connection);
+    }
+
+    /**
+     * Wrap a column or table name with appropriate identifier quotes.
+     *
+     * @param mixed $value
+     * @return string
+     */
+    public function wrap($value): string
+    {
+        return $this->grammar->wrap($value);
+    }
+
+    /**
+     * Create a case-insensitive column expression.
+     *
+     * @param string $column
+     * @return string
+     */
+    public function caseInsensitive(string $column): string
+    {
+        return "LOWER({$column})";
+    }
+
+    /**
+     * Create a COALESCE expression with the given values.
+     *
+     * @param array $values
+     * @return string
+     */
+    public function coalesce(array $values): string
+    {
+        $valueList = implode(',', $values);
+        return "COALESCE({$valueList})";
+    }
+
+    /**
+     * Create a character length expression for the given column.
+     *
+     * @param string $column
+     * @return string
+     */
+    public function charLength(string $column): string
+    {
+        return "CHAR_LENGTH({$column})";
+    }
+
+    /**
+     * Create a string replace expression.
+     *
+     * @param string $column
+     * @param string $search
+     * @param string $replace
+     * @return string
+     */
+    public function replace(string $column, string $search, string $replace): string
+    {
+        return "REPLACE({$column}, {$search}, {$replace})";
+    }
+
+    /**
+     * Create a lowercase expression for the given column.
+     *
+     * @param string $column
+     * @return string
+     */
+    public function lower(string $column): string
+    {
+        return "LOWER({$column})";
+    }
+
+    /**
+     * Get the operator used for phonetic/sounds-like matching.
+     *
+     * @return string
+     */
+    public function soundsLikeOperator(): string
+    {
+        return 'sounds like';
+    }
+
+    /**
+     * Check if the database supports phonetic/sounds-like matching.
+     *
+     * @return bool
+     */
+    public function supportsSoundsLike(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Check if the database supports complex ordering in UNION queries.
+     *
+     * @return bool
+     */
+    public function supportsUnionOrdering(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Wrap a UNION query for databases that need special handling.
+     *
+     * @param string $sql
+     * @param array $bindings
+     * @return array
+     */
+    public function wrapUnionQuery(string $sql, array $bindings): array
+    {
+        return ['sql' => $sql, 'bindings' => $bindings];
+    }
+}