pg_search 2.3.8 → 2.4.0

data/lib/pg_search/scope_options.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/module/delegation"
-
 module PgSearch
   class ScopeOptions
     attr_reader :config, :feature_options, :model
@@ -15,10 +13,12 @@ module PgSearch
     def apply(scope)
       scope = include_table_aliasing_for_rank(scope)
       rank_table_alias = scope.pg_search_rank_table_alias(include_counter: true)
+      rank_subquery = subquery.arel.as(rank_table_alias)
 
       scope
-        .joins(rank_join(rank_table_alias))
-        .order(Arel.sql("#{rank_table_alias}.rank DESC, #{order_within_rank}"))
+        .joins(rank_join(rank_subquery))
+        .order(rank_subquery[:rank].desc)
+        .order(order_within_rank)
         .extend(WithPgSearchRank)
         .extend(WithPgSearchHighlight[feature_for(:tsearch)])
     end
@@ -38,20 +38,18 @@ module PgSearch
 
       def with_pg_search_highlight
         scope = self
-        scope = scope.select("#{table_name}.*") unless scope.select_values.any?
-        scope.select("(#{highlight}) AS pg_search_highlight")
-      end
-
-      def highlight
-        tsearch.highlight.to_sql
+        scope = scope.select(arel_table[Arel.star]) if scope.select_values.empty?
+        scope.select(tsearch.highlight.as("pg_search_highlight"))
       end
     end
 
     module WithPgSearchRank
       def with_pg_search_rank
         scope = self
-        scope = scope.select("#{table_name}.*") unless scope.select_values.any?
-        scope.select("#{pg_search_rank_table_alias}.rank AS pg_search_rank")
+        scope = scope.select(arel_table[Arel.star]) if scope.select_values.empty?
+        rank_table = arel_table.alias(pg_search_rank_table_alias)
+        rank_column = Arel::Attributes::Attribute.new(rank_table, "rank")
+        scope.select(rank_column.as("pg_search_rank"))
       end
     end
 
@@ -77,13 +75,11 @@ module PgSearch
 
     private
 
-    delegate :connection, :quoted_table_name, to: :model
-
     def subquery
       model
         .unscoped
-        .select("#{primary_key} AS pg_search_id")
-        .select("#{rank} AS rank")
+        .select(model.arel_table[model.primary_key].as("pg_search_id"))
+        .select(rank.as("rank"))
         .joins(subquery_join)
         .where(conditions)
         .limit(nil)
@@ -96,42 +92,23 @@ module PgSearch
           .reject { |_feature_name, feature_options| feature_options && feature_options[:sort_only] }
           .map { |feature_name, _feature_options| feature_for(feature_name).conditions }
 
-      or_node(expressions)
+      Arel::Nodes::Or.new(expressions)
     end
 
-    # https://github.com/rails/rails/pull/51492
-    # :nocov:
-    # standard:disable Lint/DuplicateMethods
-    or_arity = Arel::Nodes::Or.instance_method(:initialize).arity
-    case or_arity
-    when 1
-      def or_node(expressions)
-        Arel::Nodes::Or.new(expressions)
-      end
-    when 2
-      def or_node(expressions)
-        expressions.inject { |accumulator, expression| Arel::Nodes::Or.new(accumulator, expression) }
-      end
-    else
-      raise "Unsupported arity #{or_arity} for Arel::Nodes::Or#initialize"
-    end
-    # :nocov:
-    # standard:enable Lint/DuplicateMethods
-
     def order_within_rank
-      config.order_within_rank || "#{primary_key} ASC"
+      if config.order_within_rank
+        Arel.sql(config.order_within_rank)
+      else
+        model.arel_table[model.primary_key].asc
+      end
     end
 
     def primary_key
-      "#{quoted_table_name}.#{connection.quote_column_name(model.primary_key)}"
+      Arel::Attributes::Attribute.new(model.arel_table, model.primary_key)
     end
 
     def subquery_join
-      if config.associations.any?
-        config.associations.map do |association|
-          association.join(primary_key)
-        end.join(" ")
-      end
+      config.associations.map { |association| association.to_arel(primary_key) }
     end
 
     FEATURE_CLASSES = { # standard:disable Lint/UselessConstantScoping
@@ -158,18 +135,17 @@ module PgSearch
     end
 
     def rank
-      (config.ranking_sql || ":tsearch").gsub(/:(\w*)/) do
+      return feature_for(:tsearch).rank unless config.ranking_sql
+
+      Arel.sql(config.ranking_sql.gsub(/:(\w*)/) do
         feature_for(Regexp.last_match(1)).rank.to_sql
-      end
+      end)
     end
 
-    def rank_join(rank_table_alias)
-      arel_table = model.arel_table
-      subquery_arel = subquery.arel.as(rank_table_alias)
-
-      arel_table
-        .join(subquery_arel)
-        .on(arel_table[model.primary_key].eq(subquery_arel[:pg_search_id]))
+    def rank_join(rank_subquery)
+      model.arel_table
+        .join(rank_subquery)
+        .on(model.arel_table[model.primary_key].eq(rank_subquery[:pg_search_id]))
         .join_sources
     end
 

data/lib/pg_search/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgSearch
-  VERSION = "2.3.8"
+  VERSION = "2.4.0"
 end

data/pg_search.gemspec

@@ -7,8 +7,8 @@ Gem::Specification.new do |s|
   s.name = "pg_search"
   s.version = PgSearch::VERSION
   s.platform = Gem::Platform::RUBY
-  s.authors = ["Grant Hutchins", "Case Commons, LLC"]
-  s.email = %w[gems@nertzy.com casecommons-dev@googlegroups.com]
+  s.authors = ["Grant Hutchins"]
+  s.email = ["gems@nertzy.com"]
   s.homepage = "https://github.com/Casecommons/pg_search"
   s.summary = "PgSearch builds Active Record named scopes that take advantage of PostgreSQL's full text search"
   s.description = "PgSearch builds Active Record named scopes that take advantage of PostgreSQL's full text search"
@@ -18,8 +18,8 @@ Gem::Specification.new do |s|
   s.files = `git ls-files -z`.split("\x0")
   s.require_paths = ["lib"]
 
-  s.add_dependency "activerecord", ">= 7.2"
-  s.add_dependency "activesupport", ">= 7.2"
+  s.add_dependency "activerecord", ">= 8.0"
+  s.add_dependency "activesupport", ">= 8.0"
 
   s.required_ruby_version = ">= 3.3"
 end

data/spec/integration/associations_spec.rb

@@ -145,6 +145,127 @@ describe "a pg_search_scope" do
       end
     end
 
+    context "via a scoped has_many association with a quoted literal condition" do
+      with_model :Book do
+        table do |t|
+          t.string "title"
+          t.string "author"
+          t.belongs_to :shelf
+        end
+
+        model do
+          belongs_to :shelf
+        end
+      end
+
+      with_model :Shelf do
+        table do |t|
+          t.string "title"
+        end
+
+        model do
+          include PgSearch::Model
+
+          has_many :obrien_books,
+            -> { where(author: "O'Brien") },
+            class_name: "Book"
+
+          pg_search_scope :with_obrien_books,
+            associated_against: {obrien_books: :title}
+        end
+      end
+
+      it "preserves scoped values through searches" do
+        shelf_with_obrien = Shelf.create!(title: "Main Shelf")
+        shelf_without_obrien = Shelf.create!(title: "Other Shelf")
+
+        Book.create!(
+          title: "The Third Policeman",
+          author: "O'Brien",
+          shelf: shelf_with_obrien
+        )
+        Book.create!(
+          title: "The Third Policeman",
+          author: "Someone Else",
+          shelf: shelf_without_obrien
+        )
+
+        results = Shelf.with_obrien_books("Third Policeman")
+        expect(results).to include(shelf_with_obrien)
+        expect(results).not_to include(shelf_without_obrien)
+      end
+    end
+
+    context "with a physical source column shadowed by a model alias" do
+      with_model :Book do
+        table do |t|
+          t.string :title
+          t.string :name
+          t.belongs_to :shelf
+        end
+
+        model do
+          belongs_to :shelf
+        end
+      end
+
+      with_model :Shelf do
+        table
+
+        model do
+          include PgSearch::Model
+
+          has_many :books
+
+          pg_search_scope :search, associated_against: {books: :title}
+        end
+      end
+
+      it "searches the physical association source through the derived alias" do
+        shelf = Shelf.create!
+        shelf.books.create!(title: "physical", name: "alias")
+        Book.alias_attribute :title, :name
+
+        expect(Shelf.search("physical")).to eq [shelf]
+        expect(Shelf.search("alias")).to be_empty
+      end
+    end
+
+    context "with a trusted SQL expression as the association source" do
+      with_model :Book do
+        table do |t|
+          t.json :metadata
+          t.belongs_to :shelf
+        end
+
+        model do
+          belongs_to :shelf
+        end
+      end
+
+      with_model :Shelf do
+        table
+
+        model do
+          include PgSearch::Model
+
+          has_many :books
+
+          pg_search_scope :search,
+            associated_against: {books: Arel.sql("metadata->>'title'")}
+        end
+      end
+
+      it "evaluates the expression before aggregating the associated rows" do
+        shelf = Shelf.create!
+        shelf.books.create!(metadata: {title: "Hello"})
+        shelf.books.create!(metadata: {title: "world"})
+
+        expect(Shelf.search("Hello world")).to eq [shelf]
+        expect(Shelf.search("title")).to be_empty
+      end
+    end
+
     context "when across multiple associations" do
       context "when on different tables" do
         with_model :FirstAssociatedModel do

data/spec/integration/pg_search_spec.rb

@@ -1112,6 +1112,37 @@ describe "an Active Record model which includes PgSearch" do
       end
     end
 
+    context "with quoted identifiers and a rank attribute alias" do
+      with_model :Article do
+        table primary_key: "ArticleID" do |t|
+          t.text :content
+          t.tsvector "SearchVector"
+          t.integer :importance
+        end
+
+        model do
+          include PgSearch::Model
+
+          alias_attribute :rank, :importance
+          pg_search_scope :search_content,
+            using: {tsearch: {tsvector_column: "SearchVector"}}
+        end
+      end
+
+      it "searches the physical vector and selects the synthetic rank" do
+        article = Article.create!(content: "phooey", importance: 10)
+        Article.update_all(
+          %("SearchVector" = to_tsvector('simple', "content"))
+        )
+
+        result = Article.search_content("phooey").with_pg_search_rank.first
+
+        expect(result).to eq(article)
+        expect(result.pg_search_rank).to be_a(Float)
+        expect(result.pg_search_rank).not_to eq(result.importance)
+      end
+    end
+
     context "when using multiple tsvector columns" do
       with_model :ModelWithTsvector do
         table
@@ -1228,6 +1259,23 @@ describe "an Active Record model which includes PgSearch" do
       end
     end
 
+    context "when passed an :order_within_rank expression" do
+      before do
+        ModelWithPgSearch.pg_search_scope :search_content_ordered_by_importance,
+          against: :content,
+          order_within_rank: "importance DESC"
+      end
+
+      it "breaks ties in rank by the custom expression" do
+        # Both records match equally; importance determines order
+        low = ModelWithPgSearch.create!(content: "foo", importance: 1)
+        high = ModelWithPgSearch.create!(content: "foo", importance: 5)
+
+        results = ModelWithPgSearch.search_content_ordered_by_importance("foo")
+        expect(results).to eq([high, low])
+      end
+    end
+
     context "when passed a :ranked_by expression" do
       before do
         ModelWithPgSearch.pg_search_scope :search_content_with_default_rank,

data/spec/lib/pg_search/configuration/association_spec.rb

@@ -20,7 +20,7 @@ describe PgSearch::Configuration::Association do
     model do
       include PgSearch::Model
 
-      has_one :avatar, class_name: "Avatar"
+      has_one :avatar
       belongs_to :site
 
       pg_search_scope :with_avatar, associated_against: {avatar: :url}
@@ -36,7 +36,7 @@ describe PgSearch::Configuration::Association do
     model do
       include PgSearch::Model
 
-      has_many :users, class_name: "User"
+      has_many :users
 
       pg_search_scope :with_users, associated_against: {users: :name}
     end
@@ -50,27 +50,6 @@ describe PgSearch::Configuration::Association do
         expect(association.table_name).to eq Avatar.table_name
       end
     end
-
-    describe "#join" do
-      let(:expected_sql) do
-        <<~SQL.squish
-          LEFT OUTER JOIN
-            (SELECT model_id AS id,
-                    #{column_select} AS #{association.columns.first.alias}
-            FROM "#{User.table_name}"
-            INNER JOIN "#{association.table_name}"
-            ON "#{association.table_name}"."user_id" = "#{User.table_name}"."id") #{association.subselect_alias}
-          ON #{association.subselect_alias}.id = model_id
-        SQL
-      end
-      let(:column_select) do
-        "\"#{association.table_name}\".\"url\"::text"
-      end
-
-      it "returns the correct SQL join" do
-        expect(association.join("model_id")).to eq(expected_sql)
-      end
-    end
   end
 
   context "with belongs_to" do
@@ -81,27 +60,6 @@ describe PgSearch::Configuration::Association do
         expect(association.table_name).to eq Site.table_name
       end
     end
-
-    describe "#join" do
-      let(:expected_sql) do
-        <<~SQL.squish
-          LEFT OUTER JOIN
-            (SELECT model_id AS id,
-                    #{column_select} AS #{association.columns.first.alias}
-            FROM "#{User.table_name}"
-            INNER JOIN "#{association.table_name}"
-            ON "#{association.table_name}"."id" = "#{User.table_name}"."site_id") #{association.subselect_alias}
-          ON #{association.subselect_alias}.id = model_id
-        SQL
-      end
-      let(:column_select) do
-        "\"#{association.table_name}\".\"title\"::text"
-      end
-
-      it "returns the correct SQL join" do
-        expect(association.join("model_id")).to eq(expected_sql)
-      end
-    end
   end
 
   context "with has_many" do
@@ -113,22 +71,38 @@ describe PgSearch::Configuration::Association do
       end
     end
 
-    describe "#join" do
-      let(:expected_sql) do
-        <<~SQL.squish
-          LEFT OUTER JOIN
-            (SELECT model_id AS id,
-                    string_agg("#{association.table_name}"."name"::text, ' ') AS #{association.columns.first.alias}
-            FROM "#{Site.table_name}"
-            INNER JOIN "#{association.table_name}"
-            ON "#{association.table_name}"."site_id" = "#{Site.table_name}"."id"
-            GROUP BY model_id) #{association.subselect_alias}
-          ON #{association.subselect_alias}.id = model_id
-        SQL
+    describe "#to_arel" do
+      let(:projected_column) do
+        Site.arel_table.alias(association.subselect_alias)[
+          association.columns.first.alias
+        ].as("document")
+      end
+      let(:joined_sites) do
+        Site.joins(association.to_arel(Site.arel_table[:id]))
+      end
+
+      it "ignores NULL inputs without padding the aggregate" do
+        site = Site.create!
+        site.users.create!(name: nil)
+        site.users.create!(name: "visible")
+        site.users.create!(name: nil)
+
+        expect(joined_sites.pluck(projected_column)).to eq ["visible"]
       end
 
-      it "returns the correct SQL join" do
-        expect(association.join("model_id")).to eq(expected_sql)
+      it "preserves an all-NULL aggregate" do
+        site = Site.create!
+        site.users.create!(name: nil)
+        site.users.create!(name: nil)
+
+        expect(joined_sites.pluck(projected_column)).to eq [nil]
+      end
+
+      it "retains the parent when no associated rows exist" do
+        site = Site.create!
+
+        expect(joined_sites.pluck(Site.arel_table[:id])).to eq [site.id]
+        expect(joined_sites.pluck(projected_column)).to eq [nil]
       end
 
       describe "#subselect_alias" do

data/spec/lib/pg_search/configuration/column_spec.rb

@@ -3,41 +3,99 @@
 require "spec_helper"
 
 describe PgSearch::Configuration::Column do
-  describe "#full_name" do
+  describe "#to_arel" do
     with_model :Model do
       table do |t|
         t.string :name
+        t.integer :count
         t.json :object
       end
     end
 
-    it "returns the fully-qualified table and column name" do
+    it "coalesces NULL values to an empty string when composed into a query" do
+      model = Model.create!(name: nil)
       column = described_class.new("name", nil, Model)
-      expect(column.full_name).to eq(%(#{Model.quoted_table_name}."name"))
+      query = Model.arel_table
+        .project(column.to_arel.as("value"))
+        .where(Model.arel_table[:id].eq(model.id))
+
+      sql = Model.connection.visitor.compile(query.ast)
+      expect(Model.connection.select_value(sql)).to eq("")
     end
 
-    it "returns nested json attributes" do
+    it "casts a non-text column to text when composed into a query" do
+      model = Model.create!(count: 42)
+      column = described_class.new("count", nil, Model)
+      query = Model.arel_table
+        .project(column.to_arel.as("value"))
+        .where(Model.arel_table[:id].eq(model.id))
+
+      sql = Model.connection.visitor.compile(query.ast)
+      expect(Model.connection.select_value(sql)).to eq("42")
+    end
+
+    it "evaluates a trusted SQL literal JSON expression when composed into a query" do
+      model = Model.create!(object: {name: "hello world"})
       column = described_class.new(Arel.sql("object->>'name'"), nil, Model)
-      expect(column.full_name).to eq(%(object->>'name'))
+      query = Model.arel_table
+        .project(column.to_arel.as("value"))
+        .where(Model.arel_table[:id].eq(model.id))
+
+      sql = Model.connection.visitor.compile(query.ast)
+      expect(Model.connection.select_value(sql)).to eq("hello world")
+    end
+
+    context "with quoted identifiers" do
+      with_model :QuotedModel do
+        table do |t|
+          t.string "select"
+          t.string "order"
+        end
+      end
+
+      it "executes a reserved-word column through a projected Arel node" do
+        model = QuotedModel.create!(select: "value1")
+        column = described_class.new("select", nil, QuotedModel)
+        query = QuotedModel.arel_table
+          .project(column.to_arel.as("value"))
+          .where(QuotedModel.arel_table[:id].eq(model.id))
+
+        sql = QuotedModel.connection.visitor.compile(query.ast)
+        expect(QuotedModel.connection.select_value(sql)).to eq("value1")
+      end
+
+      it "composes multiple quoted column nodes before execution" do
+        model = QuotedModel.create!(select: "abc", order: "def")
+        select_column = described_class.new("select", nil, QuotedModel)
+        order_column = described_class.new("order", nil, QuotedModel)
+        combined = Arel::Nodes::NamedFunction.new(
+          "concat",
+          [select_column.to_arel, order_column.to_arel]
+        )
+        query = QuotedModel.arel_table
+          .project(combined.as("value"))
+          .where(QuotedModel.arel_table[:id].eq(model.id))
+
+        sql = QuotedModel.connection.visitor.compile(query.ast)
+        expect(QuotedModel.connection.select_value(sql)).to eq("abcdef")
+      end
     end
   end
 
-  describe "#to_sql" do
-    with_model :Model do
+  context "when a model alias shadows a physical column" do
+    with_model :Book do
       table do |t|
+        t.string :title
         t.string :name
-        t.json :object
       end
     end
 
-    it "returns an expression that casts the column to text and coalesces it with an empty string" do
-      column = described_class.new("name", nil, Model)
-      expect(column.to_sql).to eq(%{coalesce((#{Model.quoted_table_name}."name")::text, '')})
-    end
+    it "normalizes the aliased model attribute" do
+      Book.create!(title: "physical", name: "alias")
+      Book.alias_attribute :title, :name
+      column = described_class.new(:title, nil, Book)
 
-    it "returns an expression that casts the nested json attribute to text and coalesces it with an empty string" do
-      column = described_class.new(Arel.sql("object->>'name'"), nil, Model)
-      expect(column.to_sql).to eq(%{coalesce((object->>'name')::text, '')})
+      expect(Book.pluck(column.to_arel)).to eq ["alias"]
     end
   end
 end