pg_search 2.3.8 → 2.4.0

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/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

data/lib/pg_search/features/trigram.rb

@@ -29,43 +29,29 @@ module PgSearch
 
       private
 
-      def word_similarity?
-        options[:word_similarity]
-      end
+      def word_similarity? = options[:word_similarity]
 
       def similarity_function
-        if word_similarity?
-          "word_similarity"
-        else
-          "similarity"
-        end
+        word_similarity? ? "word_similarity" : "similarity"
       end
 
       def infix_operator
-        if word_similarity?
-          "<%"
-        else
-          "%"
-        end
+        word_similarity? ? "<%" : "%"
       end
 
       def similarity
         Arel::Nodes::NamedFunction.new(
           similarity_function,
-          [
-            normalized_query,
-            normalized_document
-          ]
+          [normalized_query, normalized_document]
         )
       end
 
       def normalized_document
-        Arel::Nodes::Grouping.new(Arel.sql(normalize(document)))
+        Arel::Nodes::Grouping.new(normalize(document))
       end
 
       def normalized_query
-        sanitized_query = connection.quote(query)
-        Arel.sql(normalize(sanitized_query))
+        normalize(Arel::Nodes.build_quoted(query))
       end
     end
   end

data/lib/pg_search/features/tsearch.rb

@@ -12,16 +12,16 @@ module PgSearch
 
       def conditions
         Arel::Nodes::Grouping.new(
-          Arel::Nodes::InfixOperation.new("@@", arel_wrap(tsdocument), arel_wrap(tsquery))
+          Arel::Nodes::InfixOperation.new("@@", Arel::Nodes::Grouping.new(tsdocument), Arel::Nodes::Grouping.new(tsquery))
         )
       end
 
       def rank
-        arel_wrap(tsearch_rank)
+        Arel::Nodes::Grouping.new(tsearch_rank)
       end
 
       def highlight
-        arel_wrap(ts_headline)
+        Arel::Nodes::Grouping.new(ts_headline)
       end
 
       private
@@ -29,10 +29,10 @@ module PgSearch
       def ts_headline
         Arel::Nodes::NamedFunction.new("ts_headline", [
           dictionary,
-          arel_wrap(document),
-          arel_wrap(tsquery),
+          Arel::Nodes::Grouping.new(document),
+          Arel::Nodes::Grouping.new(tsquery),
           Arel::Nodes.build_quoted(ts_headline_options)
-        ]).to_sql
+        ])
       end
 
       def ts_headline_options
@@ -97,22 +97,20 @@ module PgSearch
         end
 
         sanitized_term = unsanitized_term.gsub(DISALLOWED_TSQUERY_CHARACTERS, " ")
+        term_node = normalize(Arel::Nodes.build_quoted(sanitized_term))
+        tsquery_expr = tsquery_expression(term_node, negated: negated, prefix: options[:prefix])
 
-        term_sql = Arel.sql(normalize(connection.quote(sanitized_term)))
-
-        tsquery = tsquery_expression(term_sql, negated: negated, prefix: options[:prefix])
-
-        Arel::Nodes::NamedFunction.new("to_tsquery", [dictionary, tsquery]).to_sql
+        Arel::Nodes::NamedFunction.new("to_tsquery", [dictionary, tsquery_expr])
       end
 
       # After this, the SQL expression evaluates to a string containing the term surrounded by single-quotes.
       # If :prefix is true, then the term will have :* appended to the end.
       # If :negated is true, then the term will have ! prepended to the front.
-      def tsquery_expression(term_sql, negated:, prefix:)
+      def tsquery_expression(term_node, negated:, prefix:)
         terms = [
           (Arel::Nodes.build_quoted("!") if negated),
           Arel::Nodes.build_quoted("' "),
-          term_sql,
+          term_node,
           Arel::Nodes.build_quoted(" '"),
           (Arel::Nodes.build_quoted(":*") if prefix)
         ].compact
@@ -123,29 +121,26 @@ module PgSearch
       end
 
       def tsquery
-        return "''" if query.blank?
+        return Arel::Nodes.build_quoted("") if query.blank?
 
         query_terms = query.split.compact
-        tsquery_terms = query_terms.map { |term| tsquery_for_term(term) }
-        tsquery_terms.join(options[:any_word] ? " || " : " && ")
+        query_terms.map { |term| tsquery_for_term(term) }
+          .inject { |memo, t| Arel::Nodes::InfixOperation.new(options[:any_word] ? "||" : "&&", memo, t) }
       end
 
       def tsdocument
-        tsdocument_terms = (columns_to_use || []).map do |search_column|
-          column_to_tsvector(search_column)
-        end
+        terms = (columns_to_use || []).map { |col| column_to_tsvector(col) }
 
         if options[:tsvector_column]
-          tsvector_columns = Array.wrap(options[:tsvector_column])
-
-          tsdocument_terms << tsvector_columns.map do |tsvector_column|
-            column_name = connection.quote_column_name(tsvector_column)
-
-            "#{quoted_table_name}.#{column_name}"
+          Array.wrap(options[:tsvector_column]).each do |tsvector_column|
+            terms << Arel::Attributes::Attribute.new(
+              model.arel_table,
+              tsvector_column.to_s
+            )
           end
         end
 
-        tsdocument_terms.join(" || ")
+        terms.inject { |memo, t| Arel::Nodes::InfixOperation.new("||", memo, t) } || Arel.sql("")
       end
 
       # From http://www.postgresql.org/docs/8.3/static/textsearch-controls.html
@@ -163,20 +158,16 @@ module PgSearch
 
       def tsearch_rank
         Arel::Nodes::NamedFunction.new("ts_rank", [
-          arel_wrap(tsdocument),
-          arel_wrap(tsquery),
+          Arel::Nodes::Grouping.new(tsdocument),
+          Arel::Nodes::Grouping.new(tsquery),
           normalization
-        ]).to_sql
+        ])
       end
 
       def dictionary
         Arel::Nodes.build_quoted(options[:dictionary] || :simple)
       end
 
-      def arel_wrap(sql_string)
-        Arel::Nodes::Grouping.new(Arel.sql(sql_string))
-      end
-
       def columns_to_use
         if options[:tsvector_column]
           columns.select { |c| c.is_a?(PgSearch::Configuration::ForeignColumn) }
@@ -188,13 +179,16 @@ module PgSearch
       def column_to_tsvector(search_column)
         tsvector = Arel::Nodes::NamedFunction.new(
           "to_tsvector",
-          [dictionary, Arel.sql(normalize(search_column.to_sql))]
-        ).to_sql
+          [dictionary, normalize(search_column.to_arel)]
+        )
 
         if search_column.weight.nil?
           tsvector
         else
-          "setweight(#{tsvector}, #{connection.quote(search_column.weight)})"
+          Arel::Nodes::NamedFunction.new(
+            "setweight",
+            [tsvector, Arel::Nodes.build_quoted(search_column.weight)]
+          )
         end
       end
     end

data/lib/pg_search/features.rb

@@ -7,6 +7,8 @@ require "pg_search/features/trigram"
 require "pg_search/features/tsearch"
 
 module PgSearch
+  # Search features provide conditions and rank as composable Arel expressions,
+  # not SQL Strings. TSearch also provides a highlight expression for selection.
   module Features
   end
 end

data/lib/pg_search/migration/generator.rb

@@ -28,11 +28,7 @@ module PgSearch
       end
 
       def migration_version
-        if ActiveRecord::VERSION::MAJOR >= 5
-          "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
-        else
-          ""
-        end
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
       end
     end
   end

data/lib/pg_search/multisearch/rebuilder.rb

@@ -3,6 +3,16 @@
 module PgSearch
   module Multisearch
     class Rebuilder
+      # Arguments
+      #
+      # +model+:: Active Record model configured for multisearch.
+      # +time_source+:: Clock returning a timestamp for bulk inserts. Defaults to
+      #                 +Time.method(:now)+ and is called once per bulk rebuild so
+      #                 +created_at+ and +updated_at+ share a timestamp.
+      #
+      # Raises
+      #
+      # ModelNotMultisearchable:: If +model+ is not configured for multisearch.
       def initialize(model, time_source = Time.method(:now))
         raise ModelNotMultisearchable, model unless model.respond_to?(:pg_search_multisearchable_options)
 
@@ -10,6 +20,10 @@ module PgSearch
         @time_source = time_source
       end
 
+      # Populates search documents without first clearing existing documents.
+      # Uses the model's rebuild_pg_search_documents override when available;
+      # otherwise updates records individually for conditions, dynamic content,
+      # or additional attributes, and bulk-inserts for plain column content.
       def rebuild
         if model.respond_to?(:rebuild_pg_search_documents)
           model.rebuild_pg_search_documents
@@ -25,7 +39,8 @@ module PgSearch
       attr_reader :model
 
       def conditional?
-        model.pg_search_multisearchable_options.key?(:if) || model.pg_search_multisearchable_options.key?(:unless)
+        model.pg_search_multisearchable_options.key?(:if) ||
+          model.pg_search_multisearchable_options.key?(:unless)
       end
 
       def dynamic?
@@ -37,77 +52,66 @@ module PgSearch
         model.pg_search_multisearchable_options.key?(:additional_attributes)
       end
 
-      def connection
-        model.connection
-      end
-
-      def primary_key
-        connection.quote_column_name(model.primary_key)
-      end
-
-      def rebuild_sql_template
-        <<~SQL.squish
-          INSERT INTO :documents_table (searchable_type, searchable_id, content, created_at, updated_at)
-            SELECT :base_model_name AS searchable_type,
-                   :model_table.#{primary_key} AS searchable_id,
-                   (
-                     :content_expressions
-                   ) AS content,
-                   :current_time AS created_at,
-                   :current_time AS updated_at
-            FROM :model_table :sti_clause
-        SQL
-      end
-
-      def rebuild_sql
-        replacements.inject(rebuild_sql_template) do |sql, key|
-          sql.gsub ":#{key}", send(key)
+      def connection = model.connection
+
+      def rebuild_sql = connection.to_sql(insert_manager.ast)
+
+      def insert_manager
+        time = @time_source.call
+        quoted_time = Arel::Nodes.build_quoted(time)
+        src = model.arel_table
+        doc = PgSearch::Document.arel_table
+
+        sel = Arel::SelectManager.new(src)
+        sel.project(
+          Arel::Nodes.build_quoted(model.base_class.name).as("searchable_type"),
+          src[model.primary_key].as("searchable_id"),
+          content_expression.as("content"),
+          quoted_time.as("created_at"),
+          quoted_time.as("updated_at")
+        )
+
+        apply_sti_condition(sel, src)
+
+        mgr = Arel::InsertManager.new
+        mgr.into(doc)
+        mgr.columns.concat([
+          doc[:searchable_type],
+          doc[:searchable_id],
+          doc[:content],
+          doc[:created_at],
+          doc[:updated_at]
+        ])
+        mgr.select(sel.ast)
+        mgr
+      end
+
+      def content_expression
+        expressions = columns.map { |column| Configuration::Column.new(column, nil, model).to_arel }
+        expressions.inject do |document, expression|
+          Arel::Nodes::InfixOperation.new(
+            "||",
+            Arel::Nodes::InfixOperation.new("||", document, Arel::Nodes.build_quoted(" ")),
+            expression
+          )
         end
       end
 
-      def sti_clause
-        clause = ""
-        if model.column_names.include? model.inheritance_column
-          quoted_inheritance_column = connection.quote_column_name(model.inheritance_column)
-          clause = "WHERE"
-          clause = "#{clause} #{quoted_inheritance_column} IS NULL OR" if model.base_class == model
-          clause = "#{clause} #{quoted_inheritance_column} = #{model_name}"
-        end
-        clause
-      end
+      def columns = Array(model.pg_search_multisearchable_options[:against])
 
-      def replacements
-        %w[content_expressions base_model_name model_name model_table documents_table current_time sti_clause]
-      end
+      def apply_sti_condition(select_manager, src_table)
+        return unless model.column_names.include?(model.inheritance_column)
 
-      def content_expressions
-        columns.map do |column|
-          %{coalesce(:model_table.#{connection.quote_column_name(column)}::text, '')}
-        end.join(" || ' ' || ")
-      end
+        inheritance_col = src_table[model.inheritance_column]
+        type_match = inheritance_col.eq(model.name)
 
-      def columns
-        Array(model.pg_search_multisearchable_options[:against])
-      end
-
-      def model_name
-        connection.quote(model.name)
-      end
-
-      def base_model_name
-        connection.quote(model.base_class.name)
-      end
-
-      def model_table
-        model.quoted_table_name
-      end
-
-      def documents_table
-        PgSearch::Document.quoted_table_name
-      end
+        condition = if model.base_class == model
+          inheritance_col.eq(nil).or(type_match)
+        else
+          type_match
+        end
 
-      def current_time
-        connection.quote(connection.quoted_date(@time_source.call))
+        select_manager.where(condition)
       end
     end
   end

data/lib/pg_search/normalizer.rb

@@ -2,38 +2,57 @@
 
 module PgSearch
   class Normalizer
+    # Arguments
+    #
+    # +config+:: Search configuration whose ignore list controls accent
+    #            normalization.
     def initialize(config)
       @config = config
     end
 
-    DISALLOWED_CHARACTERS = "'[''?\\:]'"
+    DISALLOWED_CHARACTERS = "['?\\:]"
 
-    def add_normalization(sql_expression)
-      return sql_expression unless config.ignore.include?(:accents)
-
-      sql_node = case sql_expression
-      when Arel::Nodes::Node
-        sql_expression
-      else
-        Arel.sql(sql_expression)
-      end
+    # Applies configured accent normalization, preserving the input expression
+    # without an unaccent wrapper when accents are not ignored.
+    #
+    # Arguments
+    #
+    # +expression+:: An Arel node, attribute, or trusted SQL String. A String is
+    #                an SQL expression, not a value to quote.
+    #
+    # Returns a composable Arel expression.
+    #
+    # Raises
+    #
+    # TypeError:: If +expression+ is not an Arel node, attribute, or String.
+    def add_normalization(expression)
+      node = to_node(expression)
+      return node unless config.ignore.include?(:accents)
 
       Arel::Nodes::NamedFunction.new(
         "regexp_replace",
         [
-          Arel::Nodes::NamedFunction.new(
-            PgSearch.unaccent_function,
-            [sql_node]
-          ),
-          Arel.sql(DISALLOWED_CHARACTERS),
-          Arel.sql("''"),
-          Arel.sql("'g'")
+          Arel::Nodes::NamedFunction.new(PgSearch.unaccent_function, [node]),
+          Arel::Nodes.build_quoted(DISALLOWED_CHARACTERS),
+          Arel::Nodes.build_quoted(""),
+          Arel::Nodes.build_quoted("g")
         ]
-      ).to_sql
+      )
     end
 
     private
 
     attr_reader :config
+
+    def to_node(expression)
+      case expression
+      when Arel::Nodes::Node, Arel::Attributes::Attribute
+        expression
+      when String
+        Arel.sql(expression)
+      else
+        raise TypeError
+      end
+    end
   end
 end