A first stab at making querying method configurable

Author: pmatseykanets

src/PostgresEngine.php

@@ -7,6 +7,9 @@
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Collection;
 use Illuminate\Database\ConnectionResolverInterface;
+use ScoutEngines\Postgres\TsQuery\PhraseToTsQuery;
+use ScoutEngines\Postgres\TsQuery\PlainToTsQuery;
+use ScoutEngines\Postgres\TsQuery\ToTsQuery;
 
 class PostgresEngine extends Engine
 {
@@ -155,7 +158,7 @@ public function delete($models)
 
         $ids = $models->pluck($key)->all();
 
-        return $this->database
+        $this->database
             ->table($model->searchableAs())
             ->whereIn($key, $ids)
             ->update([$indexColumn => null]);
@@ -213,29 +216,20 @@ protected function performSearch(Builder $builder, $perPage = 0, $page = 1)
     {
         // We have to preserve the model in order to allow for
         // correct behavior of mapIds() method which currently
-        // does not revceive a model instance
+        // does not receive a model instance
         $this->preserveModel($builder->model);
 
         $bindings = collect([]);
 
-        // The choices of parser, dictionaries and which types of tokens to index are determined
-        // by the selected text search configuration which can be set globally in config/scout.php
-        // file or individually for each model in searchableOptions()
-        // See https://www.postgresql.org/docs/current/static/textsearch-controls.html
-        $tsQuery = 'plainto_tsquery(COALESCE(?, get_current_ts_config()), ?) AS query';
-        $bindings->push($this->searchConfig($builder->model) ?: null)
-            ->push($builder->query);
-
         $indexColumn = $this->getIndexColumn($builder->model);
 
-        // Build the query
+        // Build the SQL query
         $query = $this->database
             ->table($builder->index ?: $builder->model->searchableAs())
-            ->crossJoin($this->database->raw($tsQuery))
             ->select($builder->model->getKeyName())
             ->selectRaw("{$this->rankingExpression($builder->model, $indexColumn)} AS rank")
             ->selectRaw('COUNT(*) OVER () AS total_count')
-            ->whereRaw("$indexColumn @@ query");
+            ->whereRaw("$indexColumn @@ \"tsquery\"");
 
         // Apply where clauses that were set on the builder instance if any
         foreach ($builder->wheres as $key => $value) {
@@ -267,10 +261,45 @@ protected function performSearch(Builder $builder, $perPage = 0, $page = 1)
                 ->limit($perPage);
         }
 
+        // The choices of parser, dictionaries and which types of tokens to index are determined
+        // by the selected text search configuration which can be set globally in config/scout.php
+        // file or individually for each model in searchableOptions()
+        // See https://www.postgresql.org/docs/current/static/textsearch-controls.html
+        $tsQuery = $builder->callback
+            ? call_user_func($builder->callback, $builder, $this->searchConfig($builder->model))
+            : $this->defaultQueryMethod($builder->query, $this->searchConfig($builder->model));
+
+        $query->crossJoin($this->database->raw($tsQuery->sql().' AS "tsquery"'));
+
+        // Transfer bindings
+        foreach ($tsQuery->bindings() as $binding) {
+            $bindings->prepend($binding);
+        }
+
         return $this->database
             ->select($query->toSql(), $bindings->all());
     }
 
+    /**
+     * Returns the default query method.
+     *
+     * @param string $query
+     * @param string $config
+     * @return \ScoutEngines\Postgres\TsQuery\TsQueryable
+     */
+    public function defaultQueryMethod($query, $config)
+    {
+        switch (strtolower($this->config('search_using', 'plain'))) {
+            case 'tsquery':
+                return new ToTsQuery($query, $config);
+            case 'phrasequery':
+                return new PhraseToTsQuery($query, $config);
+            case 'plainquery':
+            default:
+                return new PlainToTsQuery($query, $config);
+        }
+    }
+
     /**
      * Pluck and return the primary keys of the given results.
      *
@@ -345,7 +374,7 @@ protected function connect()
      */
     protected function rankingExpression(Model $model, $indexColumn)
     {
-        $args = collect([$indexColumn, 'query']);
+        $args = collect([$indexColumn, '"tsquery"']);
 
         if ($weights = $this->rankWeights($model)) {
             $args->prepend("'$weights'");
@@ -504,7 +533,7 @@ protected function preserveModel(Model $model)
      */
     protected function searchConfig(Model $model)
     {
-        return $this->option($model, 'config', $this->config('config', ''));
+        return $this->option($model, 'config', $this->config('config', '')) ?: null;
     }
 
     /**

src/PostgresEngineServiceProvider.php

@@ -2,15 +2,50 @@
 
 namespace ScoutEngines\Postgres;
 
+use Laravel\Scout\Builder;
 use Laravel\Scout\EngineManager;
 use Illuminate\Support\ServiceProvider;
+use ScoutEngines\Postgres\TsQuery\PhraseToTsQuery;
+use ScoutEngines\Postgres\TsQuery\PlainToTsQuery;
+use ScoutEngines\Postgres\TsQuery\RawQuery;
+use ScoutEngines\Postgres\TsQuery\ToTsQuery;
 
 class PostgresEngineServiceProvider extends ServiceProvider
 {
     public function boot()
     {
-        app(EngineManager::class)->extend('pgsql', function () {
-            return new PostgresEngine($this->app['db'], config('scout.pgsql', []));
+        $this->app->make(EngineManager::class)->extend('pgsql', function () {
+            return new PostgresEngine($this->app['db'], $this->app['config']->get('scout.pgsql', []));
         });
+
+        if (! Builder::hasMacro('usingPhraseQuery')) {
+            Builder::macro('usingPhraseQuery', function () {
+                $this->callback = function ($builder, $config) {
+                    return new PhraseToTsQuery($builder->query, $config);
+                };
+
+                return $this;
+            });
+        }
+
+        if (! Builder::hasMacro('usingPlainQuery')) {
+            Builder::macro('usingPlainQuery', function () {
+                $this->callback = function ($builder, $config) {
+                    return new PlainToTsQuery($builder->query, $config);
+                };
+
+                return $this;
+            });
+        }
+
+        if (! Builder::hasMacro('usingTsQuery')) {
+            Builder::macro('usingTsQuery', function () {
+                $this->callback = function ($builder, $config) {
+                    return new ToTsQuery($builder->query, $config);
+                };
+
+                return $this;
+            });
+        }
     }
 }

src/TsQuery/BaseTsQueryable.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace ScoutEngines\Postgres\TsQuery;
+
+abstract class BaseTsQueryable implements TsQueryable
+{
+    /**
+     * Text Search Query.
+     *
+     * @var string
+     */
+    public $query;
+
+    /**
+     * PostgreSQL Text search configuration.
+     *
+     * @var string|null
+     */
+    public $config;
+
+    /**
+     * PostgreSQL Text Search Function.
+     *
+     * @var string
+     */
+    protected $tsFunction = '';
+
+    /**
+     * Create a new instance.
+     *
+     * @param string $query
+     * @param string $config
+     */
+    public function __construct($query, $config = null)
+    {
+        $this->query = $query;
+        $this->config = $config;
+    }
+
+    /**
+     * Render the SQL representation.
+     *
+     * @return string
+     */
+    public function sql()
+    {
+        return sprintf('%s(COALESCE(?, get_current_ts_config()), ?)', $this->tsFunction);
+    }
+
+    /**
+     * Return value bindings for the SQL representation.
+     *
+     * @return array
+     */
+    public function bindings()
+    {
+        return [$this->query, $this->config];
+    }
+}

src/TsQuery/PhraseToTsQuery.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace ScoutEngines\Postgres\TsQuery;
+
+class PhraseToTsQuery extends BaseTsQueryable
+{
+    protected $tsFunction = 'phraseto_tsquery';
+}

src/TsQuery/PlainToTsQuery.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace ScoutEngines\Postgres\TsQuery;
+
+class PlainToTsQuery extends BaseTsQueryable
+{
+    protected $tsFunction = 'plainto_tsquery';
+}

src/TsQuery/ToTsQuery.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace ScoutEngines\Postgres\TsQuery;
+
+class ToTsQuery extends BaseTsQueryable
+{
+    protected $tsFunction = 'to_tsquery';
+}

src/TsQuery/TsQueryable.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace ScoutEngines\Postgres\TsQuery;
+
+interface TsQueryable
+{
+    /**
+     * Render the SQL representation.
+     *
+     * @return string
+     */
+    public function sql();
+
+    /**
+     * Return value bindings for the SQL representation.
+     *
+     * @return array
+     */
+    public function bindings();
+}

tests/PostgresEngineTest.php

@@ -200,7 +200,7 @@ public function test_maps_results_to_models()
         $model->shouldReceive('get')->once()->andReturn(Collection::make([new TestModel()]));
 
         $results = $engine->map(
-            json_decode('[{"id": 1, "rank": 0.33, "total_count": 1}]'), $model);
+            json_decode('[{"id": 1, "tsrank": 0.33, "total_count": 1}]'), $model);
 
         $this->assertCount(1, $results);
     }
@@ -219,7 +219,7 @@ public function test_map_filters_out_no_longer_existing_models()
         $model->shouldReceive('get')->once()->andReturn(Collection::make([$expectedModel]));
 
         $models = $engine->map(
-            json_decode('[{"id": 1, "rank": 0.33, "total_count": 2}, {"id": 2, "rank": 0.31, "total_count": 2}]'), $model);
+            json_decode('[{"id": 1, "tsrank": 0.33, "total_count": 2}, {"id": 2, "tsrank": 0.31, "total_count": 2}]'), $model);
 
         $this->assertCount(1, $models);
         $this->assertEquals(2, $models->first()->id);
@@ -230,7 +230,7 @@ public function test_it_returns_total_count()
         list($engine) = $this->getEngine();
 
         $count = $engine->getTotalCount(
-            json_decode('[{"id": 1, "rank": 0.33, "total_count": 100}]')
+            json_decode('[{"id": 1, "tsrank": 0.33, "total_count": 100}]')
         );
 
         $this->assertEquals(100, $count);
@@ -269,17 +269,17 @@ protected function setDbExpectations($db, $withDefaultOrderBy = true)
         $db->shouldReceive('table')
             ->andReturn($table = Mockery::mock('stdClass'));
         $db->shouldReceive('raw')
-            ->with('plainto_tsquery(COALESCE(?, get_current_ts_config()), ?) AS query')
-            ->andReturn('plainto_tsquery(COALESCE(?, get_current_ts_config()), ?) AS query');
+            ->with('plainto_tsquery(COALESCE(?, get_current_ts_config()), ?) AS "tsquery"')
+            ->andReturn('plainto_tsquery(COALESCE(?, get_current_ts_config()), ?) AS "tsquery"');
 
         $table->shouldReceive('crossJoin')
-                ->with('plainto_tsquery(COALESCE(?, get_current_ts_config()), ?) AS query')
+                ->with('plainto_tsquery(COALESCE(?, get_current_ts_config()), ?) AS "tsquery"')
                 ->andReturnSelf()
             ->shouldReceive('select')
                 ->with('id')
                 ->andReturnSelf()
             ->shouldReceive('selectRaw')
-                ->with('ts_rank(searchable,query) AS rank')
+                ->with('ts_rank(searchable,"tsquery") AS rank')
                 ->andReturnSelf()
             ->shouldReceive('selectRaw')
                 ->with('COUNT(*) OVER () AS total_count')