pg_search 2.3.7 → 2.4.0

data/README.md

@@ -13,10 +13,10 @@ Read the blog post introducing PgSearch at https://tanzu.vmware.com/content/blog
 
 ## REQUIREMENTS
 
-*   Ruby 3.0+
-*   Active Record 6.1+
-*   PostgreSQL 9.2+
-*   [PostgreSQL extensions](https://github.com/Casecommons/pg_search/wiki/Installing-PostgreSQL-Extensions) for certain features
+- Ruby 3.3+
+- Active Record 8.0+
+- PostgreSQL 9.2+
+- [PostgreSQL extensions](https://github.com/Casecommons/pg_search/wiki/Installing-PostgreSQL-Extensions) for certain features
 
 ## INSTALL
 
@@ -51,45 +51,46 @@ end
 ```
 
 ### Contents
-* [Multi-search vs. search scopes](#multi-search-vs-search-scopes)
-* [Multi-search](#multi-search)
-  * [Setup](#setup)
-  * [`multisearchable`](#multisearchable)
-  * [More Options ](#more-options)
-  * [Multi-search associations](#multi-search-associations)
-  * [Searching in the global search index](#searching-in-the-global-search-index)
-  * [Chaining method calls onto the results](#chaining-method-calls-onto-the-results)
-  * [Configuring multi-search](#configuring-multi-search)
-  * [Rebuilding search documents for a given class](#rebuilding-search-documents-for-a-given-class)
-  * [Disabling multi-search indexing temporarily](#disabling-multi-search-indexing-temporarily)
-* [`pg_search_scope`](#pg_search_scope)
-  * [Searching against one column](#searching-against-one-column)
-  * [Searching against multiple columns](#searching-against-multiple-columns)
-  * [Dynamic search scopes](#dynamic-search-scopes)
-  * [Searching through associations](#searching-through-associations)
-* [Searching using different search features](#searching-using-different-search-features)
-  * [`:tsearch` (Full Text Search)](#tsearch-full-text-search)
-    * [Weighting](#weighting)
-    * [`:prefix` (PostgreSQL 8.4 and newer only)](#prefix-postgresql-84-and-newer-only)
-    * [`:negation`](#negation)
-    * [`:dictionary`](#dictionary)
-    * [`:normalization`](#normalization)
-    * [`:any_word`](#any_word)
-    * [`:sort_only`](#sort_only)
-    * [`:highlight`](#highlight)
-  * [`:dmetaphone` (Double Metaphone soundalike search)](#dmetaphone-double-metaphone-soundalike-search)
-  * [`:trigram` (Trigram search)](#trigram-trigram-search)
-    * [`:threshold`](#threshold)
-    * [`:word_similarity`](#word_similarity)
-* [Limiting Fields When Combining Features](#limiting-fields-when-combining-features)
-* [Ignoring accent marks](#ignoring-accent-marks)
-* [Using tsvector columns](#using-tsvector-columns)
-  * [Combining multiple tsvectors](#combining-multiple-tsvectors)
-* [Configuring ranking and ordering](#configuring-ranking-and-ordering)
-  * [`:ranked_by` (Choosing a ranking algorithm)](#ranked_by-choosing-a-ranking-algorithm)
-  * [`:order_within_rank` (Breaking ties)](#order_within_rank-breaking-ties)
-  * [`PgSearch#pg_search_rank` (Reading a record's rank as a Float)](#pgsearchpg_search_rank-reading-a-records-rank-as-a-float)
-  * [Search rank and chained scopes](#search-rank-and-chained-scopes)
+
+- [Multi-search vs. search scopes](#multi-search-vs-search-scopes)
+- [Multi-search](#multi-search)
+  - [Setup](#setup)
+  - [`multisearchable`](#multisearchable)
+  - [More Options ](#more-options)
+  - [Multi-search associations](#multi-search-associations)
+  - [Searching in the global search index](#searching-in-the-global-search-index)
+  - [Chaining method calls onto the results](#chaining-method-calls-onto-the-results)
+  - [Configuring multi-search](#configuring-multi-search)
+  - [Rebuilding search documents for a given class](#rebuilding-search-documents-for-a-given-class)
+  - [Disabling multi-search indexing temporarily](#disabling-multi-search-indexing-temporarily)
+- [`pg_search_scope`](#pg_search_scope)
+  - [Searching against one column](#searching-against-one-column)
+  - [Searching against multiple columns](#searching-against-multiple-columns)
+  - [Dynamic search scopes](#dynamic-search-scopes)
+  - [Searching through associations](#searching-through-associations)
+- [Searching using different search features](#searching-using-different-search-features)
+  - [`:tsearch` (Full Text Search)](#tsearch-full-text-search)
+    - [Weighting](#weighting)
+    - [`:prefix` (PostgreSQL 8.4 and newer only)](#prefix-postgresql-84-and-newer-only)
+    - [`:negation`](#negation)
+    - [`:dictionary`](#dictionary)
+    - [`:normalization`](#normalization)
+    - [`:any_word`](#any_word)
+    - [`:sort_only`](#sort_only)
+    - [`:highlight`](#highlight)
+  - [`:dmetaphone` (Double Metaphone soundalike search)](#dmetaphone-double-metaphone-soundalike-search)
+  - [`:trigram` (Trigram search)](#trigram-trigram-search)
+    - [`:threshold`](#threshold)
+    - [`:word_similarity`](#word_similarity)
+- [Limiting Fields When Combining Features](#limiting-fields-when-combining-features)
+- [Ignoring accent marks](#ignoring-accent-marks)
+- [Using tsvector columns](#using-tsvector-columns)
+  - [Combining multiple tsvectors](#combining-multiple-tsvectors)
+- [Configuring ranking and ordering](#configuring-ranking-and-ordering)
+  - [`:ranked_by` (Choosing a ranking algorithm)](#ranked_by-choosing-a-ranking-algorithm)
+  - [`:order_within_rank` (Breaking ties)](#order_within_rank-breaking-ties)
+  - [`PgSearch#pg_search_rank` (Reading a record's rank as a Float)](#pgsearchpg_search_rank-reading-a-records-rank-as-a-float)
+  - [Search rank and chained scopes](#search-rank-and-chained-scopes)
 
 ### Multi-search vs. search scopes
 
@@ -246,8 +247,8 @@ This allows much faster searches without joins later on by doing something like:
 PgSearch.multisearch(params['search']).where(author_id: 2)
 ```
 
-*NOTE: You must currently manually call `record.update_pg_search_document` for
-the additional attribute to be included in the pg_search_documents table*
+_NOTE: You must currently manually call `record.update_pg_search_document` for
+the additional attribute to be included in the pg_search_documents table_
 
 #### Multi-search associations
 
@@ -331,18 +332,18 @@ To regenerate the documents for a given class, run:
 PgSearch::Multisearch.rebuild(Product)
 ```
 
-The ```rebuild``` method will delete all the documents for the given class
+The `rebuild` method will delete all the documents for the given class
 before regenerating them. In some situations this may not be desirable,
-such as when you're using single-table inheritance and ```searchable_type```
-is your base class. You can prevent ```rebuild``` from deleting your records
+such as when you're using single-table inheritance and `searchable_type`
+is your base class. You can prevent `rebuild` from deleting your records
 like so:
 
 ```ruby
 PgSearch::Multisearch.rebuild(Product, clean_up: false)
 ```
 
-```rebuild``` runs inside a single transaction. To run outside of a transaction,
-you can pass ```transactional: false``` like so:
+`rebuild` runs inside a single transaction. To run outside of a transaction,
+you can pass `transactional: false` like so:
 
 ```ruby
 PgSearch::Multisearch.rebuild(Product, transactional: false)
@@ -399,7 +400,8 @@ class Movie < ActiveRecord::Base
   end
 end
 ```
-**Note:** If using PostgreSQL before 9.1, replace the `CONCAT_WS()` function call with double-pipe concatenation, eg. `(movies.name || ' ' || directors.name)`. However, now be aware that if *any* of the joined values is NULL then the final `content` value will also be NULL, whereas `CONCAT_WS()` will selectively ignore NULL values.
+
+**Note:** If using PostgreSQL before 9.1, replace the `CONCAT_WS()` function call with double-pipe concatenation, eg. `(movies.name || ' ' || directors.name)`. However, now be aware that if _any_ of the joined values is NULL then the final `content` value will also be NULL, whereas `CONCAT_WS()` will selectively ignore NULL values.
 
 #### Disabling multi-search indexing temporarily
 
@@ -569,11 +571,10 @@ end
 
 The currently implemented features are
 
-*   :tsearch - [Full text search](http://www.postgresql.org/docs/current/static/textsearch-intro.html), which is built-in to PostgreSQL
-*   :trigram - [Trigram search](http://www.postgresql.org/docs/current/static/pgtrgm.html), which
-    requires the trigram extension
-*   :dmetaphone - [Double Metaphone search](http://www.postgresql.org/docs/current/static/fuzzystrmatch.html#AEN177521), which requires the fuzzystrmatch extension
-
+- :tsearch - [Full text search](http://www.postgresql.org/docs/current/static/textsearch-intro.html), which is built-in to PostgreSQL
+- :trigram - [Trigram search](http://www.postgresql.org/docs/current/static/pgtrgm.html), which
+  requires the trigram extension
+- :dmetaphone - [Double Metaphone search](http://www.postgresql.org/docs/current/static/fuzzystrmatch.html#AEN177521), which requires the fuzzystrmatch extension
 
 #### :tsearch (Full Text Search)
 
@@ -581,6 +582,7 @@ PostgreSQL's built-in full text search supports weighting, prefix searches,
 and stemming in multiple languages.
 
 ##### Weighting
+
 Each searchable column can be given a weight of "A", "B", "C", or "D". Columns
 with earlier letters are weighted higher than those with later letters. So, in
 the following example, the title is the most important, followed by the
@@ -644,6 +646,7 @@ robin = Superhero.create name: 'Robin'
 
 Superhero.whose_name_starts_with("Bat") # => [batman, batgirl]
 ```
+
 ##### :negation
 
 PostgreSQL's full text search matches all search terms by default. If you want
@@ -804,7 +807,6 @@ Person.search('ash hines') # => [exact, one_exact_one_close, one_exact]
 Adding .with_pg_search_highlight after the pg_search_scope you can access to
 `pg_highlight` attribute for each object.
 
-
 ```ruby
 class Person < ActiveRecord::Base
   include PgSearch::Model
@@ -815,8 +817,8 @@ class Person < ActiveRecord::Base
                       highlight: {
                         StartSel: '<b>',
                         StopSel: '</b>',
-                        MaxWords: 123,
-                        MinWords: 456,
+                        MinWords: 123,
+                        MaxWords: 456,
                         ShortWord: 4,
                         HighlightAll: true,
                         MaxFragments: 3,
@@ -1053,31 +1055,31 @@ as it offloads creation of the tsvector that the tsquery is evaluated against.
 
 To use this functionality you'll need to do a few things:
 
-*   Create a column of type tsvector that you'd like to search against. If you
-    want to search using multiple search methods, for example tsearch and
-    dmetaphone, you'll need a column for each.
-*   Create a trigger function that will update the column(s) using the
-    expression appropriate for that type of search. See:
-    [the PostgreSQL documentation for text search triggers](http://www.postgresql.org/docs/current/static/textsearch-features.html#TEXTSEARCH-UPDATE-TRIGGERS)
-*   Should you have any pre-existing data in the table, update the
-    newly-created tsvector columns with the expression that your trigger
-    function uses.
-*   Add the option to pg_search_scope, e.g:
-
-    ```ruby
-    pg_search_scope :fast_content_search,
-                    against: :content,
-                    using: {
-                      dmetaphone: {
-                        tsvector_column: 'tsvector_content_dmetaphone'
-                      },
-                      tsearch: {
-                        dictionary: 'english',
-                        tsvector_column: 'tsvector_content_tsearch'
-                      },
-                      trigram: {} # trigram does not use tsvectors
-                    }
-    ```
+- Create a column of type tsvector that you'd like to search against. If you
+  want to search using multiple search methods, for example tsearch and
+  dmetaphone, you'll need a column for each.
+- Create a trigger function that will update the column(s) using the
+  expression appropriate for that type of search. See:
+  [the PostgreSQL documentation for text search triggers](http://www.postgresql.org/docs/current/static/textsearch-features.html#TEXTSEARCH-UPDATE-TRIGGERS)
+- Should you have any pre-existing data in the table, update the
+  newly-created tsvector columns with the expression that your trigger
+  function uses.
+- Add the option to pg_search_scope, e.g:
+
+  ```ruby
+  pg_search_scope :fast_content_search,
+                  against: :content,
+                  using: {
+                    dmetaphone: {
+                      tsvector_column: 'tsvector_content_dmetaphone'
+                    },
+                    tsearch: {
+                      dictionary: 'english',
+                      tsvector_column: 'tsvector_content_tsearch'
+                    },
+                    trigram: {} # trigram does not use tsvectors
+                  }
+  ```
 
 Please note that the :against column is only used when the tsvector_column is
 not present for the search type.
@@ -1190,9 +1192,9 @@ shirt_brands[1].pg_search_rank #=> 0.0607927
 
 #### Search rank and chained scopes
 
-Each PgSearch scope generates a named subquery for the search rank.  If you
+Each PgSearch scope generates a named subquery for the search rank. If you
 chain multiple scopes then PgSearch will generate a ranking query for each
-scope, so the ranking queries must have unique names.  If you need to reference
+scope, so the ranking queries must have unique names. If you need to reference
 the ranking query (e.g. in a GROUP BY clause) you can regenerate the subquery
 name with the `PgScope::Configuration.alias` method by passing the name of the
 queried table.
@@ -1218,5 +1220,5 @@ for discussing pg_search and other Casebook PBC open source projects.
 
 ## LICENSE
 
-Copyright © 2010–2022 [Casebook PBC](http://www.casebook.net).
+Copyright © 2010–2026 [Casebook PBC](http://www.casebook.net).
 Licensed under the MIT license, see [LICENSE](/LICENSE) file.

data/Rakefile

@@ -8,10 +8,4 @@ RSpec::Core::RakeTask.new(:spec)
 
 require "standard/rake"
 
-desc "Check test coverage"
-task :undercover do
-  system("git fetch --unshallow") if ENV["CI"]
-  exit(1) unless system("bin/undercover --compare origin/master")
-end
-
-task default: %w[spec standard undercover]
+task default: %w[spec standard]

data/doc/plans/2026-09-05-arel-stack.md

@@ -0,0 +1,43 @@
+# Incremental Arel migration
+
+Replace useful SQL-string construction with composable Arel expressions in five
+small, independently mergeable changes. Complete elimination of interpolation is
+not required. Each change includes its own caller adaptations and tests; no later
+change should be needed to make an earlier one work.
+
+Use `to_arel` for expressions and `to_sql` for rendered SQL strings. Keep behavior
+unchanged, including trusted SQL expressions and custom ordering. Preserve the
+existing rank-join alias handling. Prefer named immutable values (`Data.define`)
+for structured records, while retaining arrays for genuine expression lists.
+
+## Review and test each layer
+
+Before changing code, assess existing coverage and characterize the relevant
+behavior. Demonstrate failing coverage for new contracts or missing regressions,
+then implement the narrow change. Test SQL execution against PostgreSQL, not just
+rendered strings. Run focused examples, the full suite, and Standard for every
+layer. Review correctness, coverage quality, and unnecessary complexity before
+publishing it.
+
+Exercise expression behavior through `to_arel`. Keep `to_sql` coverage focused on
+its rendering-adapter contract, so eventually removing it does not discard the
+behavioral coverage or require duplicating that coverage across both interfaces.
+
+- [x] **Column expressions:** add explicit Arel conversions for normal and foreign
+  columns, preserving string conversions. Cover NULLs, casts, quoted identifiers,
+  and trusted JSON expressions.
+- [x] **Association queries:** build aggregated projections and joins with Arel.
+  Cover association types, missing associations, aggregation, and alias collisions.
+- [x] **Rank selection and ordering:** convert projections and ordering without
+  replacing the existing rank-join fix. Cover selected ranks, tie-breaking,
+  custom ordering, associations, and chained scopes.
+- [x] **Feature expressions and normalization:** compose search expressions as
+  nodes while preserving sanitization. Cover blank queries, quotes and accents,
+  prefix/negation, weighted and stored vectors, highlighting, and other features.
+- [x] **Multisearch rebuilds:** convert useful statement components without forcing
+  every fixed SQL fragment into Arel. Cover actual rebuilds, STI, NULL content,
+  multiple columns, and custom identifiers.
+
+Record remaining interpolation after the stack as deferred work, not a release
+gate. Keep unrelated cleanup, historical planning artifacts, and obsolete
+compatibility code out of these changes.

data/doc/plans/2026-09-06-arel-remaining-expressions.md

@@ -0,0 +1,48 @@
+# Remaining Arel expression construction
+
+Continuation of the approved [Arel stack](2026-09-05-arel-stack.md), authorized
+for autonomous follow-through while the earlier PRs are reviewed. Preserve
+those PR heads; publish new independently green layers above #587.
+
+## Contract
+
+Replace remaining SQL-construction interpolation and avoidable raw SQL fragments
+with composable expressions, without changing query behavior or existing
+String-returning adapter contracts.
+Do not rewrite ordinary messages, generated names, or PostgreSQL headline-option
+data merely to eliminate Ruby interpolation. No new database functions/migrations.
+
+- [x] **Query projections and vectors:** convert ScopeOptions star/highlight/rank
+  projections and qualified primary-key rendering, plus TSearch's stored-vector
+  references. Preserve explicit select behavior, trusted custom SQL, chained
+  aliases, quoted identifiers, and synthetic rank references without accidentally
+  applying model attribute aliases.
+- [x] **Column source references:** replace full_name interpolation and the
+  aggregate's String-to-Arel round trip with a coherent source-attribute
+  expression. Preserve the distinction between a foreign column's original
+  association source and its derived search-document alias, non-coalesced
+  aggregation, and the existing full_name/to_sql String interfaces.
+- [x] **Quoted values:** replace hand-quoted data and quote/render/wrap patterns
+  with quoted-value nodes: separators, empty strings, regex arguments, model
+  names, and timestamps. Preserve actual data, escaping, NULL behavior, and the
+  shared timestamp. Do not confuse a SQL type token or empty SQL fragment with
+  a string value.
+- [x] **Expression boundaries:** preserve Arel attributes through normalization
+  instead of coercing their Ruby inspection into SQL; remove avoidable internal
+  render-and-wrap cycles for primary keys and default ranking. Preserve the
+  documented custom SQL inputs and legacy String adapters at their boundaries.
+  Investigate empty-expression fragments before changing their semantics.
+- [x] **Final audit:** verify remaining interpolation/raw SQL is intentional
+  syntax, data serialization, or trusted escape-hatch input; report residue
+  rather than hiding it.
+
+## Verification and delivery
+
+Characterize meaningful missing behavior before refactoring; no private-helper
+specs or test-only visibility subclasses. Simplify touched fixture setup using
+normal schema names and Rails conventions. Prefer public database behavior over
+additional SQL golden matrices. Run relevant specs and bin/rake independently
+for each layer, including the existing pinned Rails-main environment; require
+one focused independent review per layer and green hosted CI.
+
+Check each item with its owning code.

data/lib/pg_search/configuration/association.rb

@@ -19,8 +19,21 @@ module PgSearch
         @model.reflect_on_association(@name).table_name
       end
 
-      def join(primary_key)
-        "LEFT OUTER JOIN (#{relation(primary_key).to_sql}) #{subselect_alias} ON #{subselect_alias}.id = #{primary_key}"
+      def arel_table = @model.reflect_on_association(@name).klass.arel_table
+
+      # Builds an outer join retaining association-scope binds.
+      #
+      # Arguments
+      #
+      # +primary_key+:: An Arel expression or trusted SQL String identifying the
+      #                 model's primary-key column, not a record's key value.
+      #
+      # Returns a composable outer join to the search subquery.
+      def to_arel(primary_key)
+        primary_key = Arel.sql(primary_key) if primary_key.is_a?(String)
+        subquery = relation(primary_key).arel.as(subselect_alias)
+        on_condition = Arel::Nodes::On.new(subquery[:id].eq(primary_key))
+        Arel::Nodes::OuterJoin.new(subquery, on_condition)
       end
 
       def subselect_alias
@@ -29,32 +42,33 @@ module PgSearch
 
       private
 
-      def selects
-        if singular_association?
-          selects_for_singular_association
-        else
-          selects_for_multiple_association
-        end
-      end
-
-      def selects_for_singular_association
-        columns.map do |column|
-          "#{column.full_name}::text AS #{column.alias}"
-        end.join(", ")
-      end
-
-      def selects_for_multiple_association
-        columns.map do |column|
-          "string_agg(#{column.full_name}::text, ' ') AS #{column.alias}"
-        end.join(", ")
-      end
-
       def relation(primary_key)
-        result = @model.unscoped.joins(@name).select("#{primary_key} AS id, #{selects}")
+        result = @model.unscoped.joins(@name).select(
+          primary_key.as("id"),
+          *selects
+        )
         result = result.group(primary_key) unless singular_association?
         result
       end
 
+      def selects
+        columns.map do |column|
+          cast_node = Arel::Nodes::NamedFunction.new(
+            "cast",
+            [column.source_attribute.as(Arel.sql("text"))]
+          )
+          projection = if singular_association?
+            cast_node
+          else
+            Arel::Nodes::NamedFunction.new(
+              "string_agg",
+              [cast_node, Arel::Nodes.build_quoted(" ")]
+            )
+          end
+          projection.as(column.alias)
+        end
+      end
+
       def singular_association?
         %i[has_one belongs_to].include?(@model.reflect_on_association(@name).macro)
       end

data/lib/pg_search/configuration/column.rb

@@ -12,32 +12,37 @@ module PgSearch
         @column_name = column_name
         @weight = weight
         @model = model
-        @connection = model.connection
       end
 
-      def full_name
+      # Physical source-column attribute, or the supplied trusted SQL literal.
+      # Foreign columns refer to the association table, not the search alias.
+      def source_attribute
         return @column_name if @column_name.is_a?(Arel::Nodes::SqlLiteral)
 
-        "#{table_name}.#{column_name}"
+        Arel::Attributes::Attribute.new(source_table, @name)
       end
 
-      def to_sql
-        "coalesce((#{expression})::text, '')"
-      end
+      # Composable search expression cast to text, with NULL mapped to "".
+      # Foreign columns use their derived search alias rather than the source.
+      def to_arel = coalesce_to_blank_string(cast_to_text(attribute))
 
       private
 
-      def table_name
-        @model.quoted_table_name
+      def attribute
+        return @column_name if @column_name.is_a?(Arel::Nodes::SqlLiteral)
+
+        @model.arel_table[@name]
       end
 
-      def column_name
-        @connection.quote_column_name(@name)
+      def cast_to_text(node)
+        Arel::Nodes::NamedFunction.new("cast", [node.as(Arel.sql("text"))])
       end
 
-      def expression
-        full_name
+      def coalesce_to_blank_string(node)
+        Arel::Nodes::NamedFunction.new("coalesce", [node, Arel::Nodes.build_quoted("")])
       end
+
+      def source_table = @model.arel_table
     end
   end
 end

data/lib/pg_search/configuration/foreign_column.rb

@@ -18,13 +18,11 @@ module PgSearch
 
       private
 
-      def expression
-        "#{@association.subselect_alias}.#{self.alias}"
+      def attribute
+        @model.arel_table.alias(@association.subselect_alias)[self.alias]
       end
 
-      def table_name
-        @connection.quote_table_name(@association.table_name)
-      end
+      def source_table = @association.arel_table
     end
   end
 end

data/lib/pg_search/configuration.rb

@@ -23,9 +23,7 @@ module PgSearch
       end
     end
 
-    def columns
-      regular_columns + associated_columns
-    end
+    def columns = regular_columns + associated_columns
 
     def regular_columns
       return [] unless options[:against]
@@ -43,37 +41,21 @@ module PgSearch
       end.flatten
     end
 
-    def associated_columns
-      associations.map(&:columns).flatten
-    end
+    def associated_columns = associations.map(&:columns).flatten
 
-    def query
-      options[:query].to_s
-    end
+    def query = options[:query].to_s
 
-    def ignore
-      Array(options[:ignoring])
-    end
+    def ignore = Array(options[:ignoring])
 
-    def ranking_sql
-      options[:ranked_by]
-    end
+    def ranking_sql = options[:ranked_by]
 
-    def features
-      Array(options[:using])
-    end
+    def features = Array(options[:using])
 
     def feature_options
-      @feature_options ||= {}.tap do |hash|
-        features.map do |feature_name, feature_options|
-          hash[feature_name] = feature_options
-        end
-      end
+      @feature_options ||= features.to_h { |name, opts| [name, opts] }
     end
 
-    def order_within_rank
-      options[:order_within_rank]
-    end
+    def order_within_rank = options[:order_within_rank]
 
     private
 
@@ -83,6 +65,7 @@ module PgSearch
       {using: :tsearch}
     end
 
+    # standard:disable Lint/UselessConstantScoping
     VALID_KEYS = %w[
       against ranked_by ignoring using query associated_against order_within_rank
     ].map(&:to_sym)
@@ -90,6 +73,7 @@ module PgSearch
     VALID_VALUES = {
       ignoring: [:accents]
     }.freeze
+    # standard:enable Lint/UselessConstantScoping
 
     def assert_valid_options(options)
       unless options[:against] || options[:associated_against] || using_tsvector_column?(options[:using])

data/lib/pg_search/features/dmetaphone.rb

@@ -25,15 +25,11 @@ module PgSearch
           @normalizer_to_wrap = normalizer_to_wrap
         end
 
-        def add_normalization(original_sql)
-          otherwise_normalized_sql = Arel.sql(
-            normalizer_to_wrap.add_normalization(original_sql)
-          )
-
+        def add_normalization(expression)
           Arel::Nodes::NamedFunction.new(
             "pg_search_dmetaphone",
-            [otherwise_normalized_sql]
-          ).to_sql
+            [normalizer_to_wrap.add_normalization(expression)]
+          )
         end
 
         private

data/lib/pg_search/features/feature.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/module/delegation"
 require "active_support/core_ext/hash/keys"
 
 module PgSearch
@@ -10,8 +9,6 @@ module PgSearch
         %i[only sort_only]
       end
 
-      delegate :connection, :quoted_table_name, to: :@model
-
       def initialize(query, options, all_columns, model, normalizer)
         @query = query
         @options = (options || {}).assert_valid_keys(self.class.valid_options)
@@ -25,7 +22,14 @@ module PgSearch
       attr_reader :query, :options, :all_columns, :model, :normalizer
 
       def document
-        columns.map(&:to_sql).join(" || ' ' || ")
+        space = Arel::Nodes.build_quoted(" ")
+        columns.map(&:to_arel).inject do |memo, col|
+          Arel::Nodes::InfixOperation.new(
+            "||",
+            Arel::Nodes::InfixOperation.new("||", memo, space),
+            col
+          )
+        end
       end
 
       def columns