pg_search 2.3.7 → 2.4.0

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

@@ -19,7 +19,8 @@ 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}
@@ -34,7 +35,8 @@ 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
@@ -48,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
@@ -79,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
@@ -111,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 "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!
 
-      it "returns the correct SQL join" do
-        expect(association.join("model_id")).to eq(expected_sql)
+        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

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

@@ -3,36 +3,69 @@
 require "spec_helper"
 
 describe PgSearch::Configuration::ForeignColumn do
-  describe "#alias" do
-    with_model :AssociatedModel do
-      table do |t|
-        t.string "title"
-      end
+  with_model :AssociatedModel do
+    table do |t|
+      t.string :title
+    end
+  end
+
+  with_model :Model do
+    table do |t|
+      t.string :name
+      t.belongs_to :associated_model, index: false, null: true
     end
 
-    with_model :Model do
-      table do |t|
-        t.string "title"
-        t.belongs_to :another_model, index: false
-      end
+    model do
+      include PgSearch::Model
 
-      model do
-        include PgSearch::Model
-        belongs_to :another_model, class_name: "AssociatedModel"
+      belongs_to :associated_model, class_name: "AssociatedModel", optional: true
 
-        pg_search_scope :with_another, associated_against: {another_model: :title}
-      end
+      pg_search_scope :with_title, associated_against: {associated_model: :title}
     end
+  end
 
-    it "returns a consistent string" do
-      association = PgSearch::Configuration::Association.new(Model,
-        :another_model,
-        :title)
-      foreign_column = described_class.new("title", nil, Model, association)
+  let(:association) do
+    PgSearch::Configuration::Association.new(Model, :associated_model, :title)
+  end
+  let(:foreign_column) { described_class.new("title", nil, Model, association) }
 
+  describe "#alias" do
+    it "returns a consistent string" do
       column_alias = foreign_column.alias
       expect(column_alias).to be_a String
       expect(foreign_column.alias).to eq column_alias
     end
   end
+
+  describe "#to_arel" do
+    def selected_value(model)
+      relation = Model
+        .joins(association.to_arel(Model.arel_table[:id]))
+        .where(Model.arel_table[:id].eq(model.id))
+        .select(foreign_column.to_arel.as("value"))
+      sql = Model.connection.visitor.compile(relation.arel.ast)
+
+      Model.connection.select_value(sql)
+    end
+
+    it "evaluates the associated value through the association join alias" do
+      associated = AssociatedModel.create!(title: "hello world")
+      model = Model.create!(name: "example", associated_model: associated)
+
+      expect(selected_value(model)).to eq("hello world")
+    end
+
+    it "coalesces a NULL associated value through the association join alias" do
+      associated = AssociatedModel.create!(title: nil)
+      model = Model.create!(name: "example", associated_model: associated)
+
+      expect(selected_value(model)).to eq("")
+    end
+
+    it "coalesces a missing association through the outer join alias" do
+      model = Model.create!(name: "example", associated_model: nil)
+
+      expect(selected_value(model)).to eq("")
+    end
+  end
 end

data/spec/lib/pg_search/features/dmetaphone_spec.rb

@@ -23,7 +23,7 @@ describe PgSearch::Features::DMetaphone do
 
       feature = described_class.new(query, options, columns, Model, normalizer)
       expect(feature.rank.to_sql).to eq(
-        %{(ts_rank((to_tsvector('simple', pg_search_dmetaphone(coalesce((#{Model.quoted_table_name}."name")::text, ''))) || to_tsvector('simple', pg_search_dmetaphone(coalesce((#{Model.quoted_table_name}."content")::text, '')))), (to_tsquery('simple', ''' ' || pg_search_dmetaphone('query') || ' ''')), 0))}
+        %{(ts_rank((to_tsvector('simple', pg_search_dmetaphone(coalesce(cast(#{Model.quoted_table_name}."name" AS text), ''))) || to_tsvector('simple', pg_search_dmetaphone(coalesce(cast(#{Model.quoted_table_name}."content" AS text), '')))), (to_tsquery('simple', ''' ' || pg_search_dmetaphone('query') || ' ''')), 0))}
       )
     end
   end
@@ -48,7 +48,7 @@ describe PgSearch::Features::DMetaphone do
 
       feature = described_class.new(query, options, columns, Model, normalizer)
       expect(feature.conditions.to_sql).to eq(
-        %{((to_tsvector('simple', pg_search_dmetaphone(coalesce((#{Model.quoted_table_name}."name")::text, ''))) || to_tsvector('simple', pg_search_dmetaphone(coalesce((#{Model.quoted_table_name}."content")::text, '')))) @@ (to_tsquery('simple', ''' ' || pg_search_dmetaphone('query') || ' ''')))}
+        %{((to_tsvector('simple', pg_search_dmetaphone(coalesce(cast(#{Model.quoted_table_name}."name" AS text), ''))) || to_tsvector('simple', pg_search_dmetaphone(coalesce(cast(#{Model.quoted_table_name}."content" AS text), '')))) @@ (to_tsquery('simple', ''' ' || pg_search_dmetaphone('query') || ' ''')))}
       )
     end
   end

data/spec/lib/pg_search/features/trigram_spec.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "spec_helper"
-require "ostruct"
 
 # standard:disable RSpec/MultipleMemoizedHelpers, RSpec/NestedGroups
 describe PgSearch::Features::Trigram do
@@ -16,13 +15,14 @@ describe PgSearch::Features::Trigram do
     ]
   }
   let(:normalizer) { PgSearch::Normalizer.new(config) }
-  let(:config) { OpenStruct.new(ignore: []) }
+  let(:config) { instance_double(PgSearch::Configuration, ignore: ignore) }
+  let(:ignore) { [] }
 
   let(:coalesced_columns) do
     <<~SQL.squish
-      coalesce((#{Model.quoted_table_name}."name")::text, '')
+      coalesce(cast(#{Model.quoted_table_name}."name" AS text), '')
         || ' '
-        || coalesce((#{Model.quoted_table_name}."content")::text, '')
+        || coalesce(cast(#{Model.quoted_table_name}."content" AS text), '')
     SQL
   end
 
@@ -35,7 +35,6 @@ describe PgSearch::Features::Trigram do
 
   describe "conditions" do
     it "escapes the search document and query" do
-      config.ignore = []
       expect(feature.conditions.to_sql).to eq("('#{query}' % (#{coalesced_columns}))")
     end
 
@@ -45,15 +44,15 @@ describe PgSearch::Features::Trigram do
       end
 
       it 'uses the "<%" operator when searching by word_similarity' do
-        config.ignore = []
         expect(feature.conditions.to_sql).to eq("('#{query}' <% (#{coalesced_columns}))")
       end
     end
 
     context "when ignoring accents" do
+      let(:ignore) { [:accents] }
+
       it "escapes the search document and query, but not the accent function" do
-        config.ignore = [:accents]
-        expect(feature.conditions.to_sql).to eq("(unaccent('#{query}') % (unaccent(#{coalesced_columns})))")
+        expect(feature.conditions.to_sql).to eq("(regexp_replace(unaccent('#{query}'), '[''?\\:]', '', 'g') % (regexp_replace(unaccent(#{coalesced_columns}), '[''?\\:]', '', 'g')))")
       end
     end
 
@@ -88,7 +87,7 @@ describe PgSearch::Features::Trigram do
         let(:options) { {only: :name} }
 
         it "only searches against the select column" do
-          coalesced_column = "coalesce((#{Model.quoted_table_name}.\"name\")::text, '')"
+          coalesced_column = "coalesce(cast(#{Model.quoted_table_name}.\"name\" AS text), '')"
           expect(feature.conditions.to_sql).to eq("('#{query}' % (#{coalesced_column}))")
         end
       end

data/spec/lib/pg_search/features/tsearch_spec.rb

@@ -24,7 +24,7 @@ describe PgSearch::Features::TSearch do
 
       feature = described_class.new(query, options, columns, Model, normalizer)
       expect(feature.rank.to_sql).to eq(
-        %{(ts_rank((to_tsvector('simple', coalesce((#{Model.quoted_table_name}."name")::text, '')) || to_tsvector('simple', coalesce((#{Model.quoted_table_name}."content")::text, ''))), (to_tsquery('simple', ''' ' || 'query' || ' ''')), 0))}
+        %{(ts_rank((to_tsvector('simple', coalesce(cast(#{Model.quoted_table_name}."name" AS text), '')) || to_tsvector('simple', coalesce(cast(#{Model.quoted_table_name}."content" AS text), ''))), (to_tsquery('simple', ''' ' || 'query' || ' ''')), 0))}
       )
     end
 
@@ -67,7 +67,7 @@ describe PgSearch::Features::TSearch do
 
       feature = described_class.new(query, options, columns, Model, normalizer)
       expect(feature.conditions.to_sql).to eq(
-        %{((to_tsvector('simple', coalesce((#{Model.quoted_table_name}."name")::text, '')) || to_tsvector('simple', coalesce((#{Model.quoted_table_name}."content")::text, ''))) @@ (to_tsquery('simple', ''' ' || 'query' || ' ''')))}
+        %{((to_tsvector('simple', coalesce(cast(#{Model.quoted_table_name}."name" AS text), '')) || to_tsvector('simple', coalesce(cast(#{Model.quoted_table_name}."content" AS text), ''))) @@ (to_tsquery('simple', ''' ' || 'query' || ' ''')))}
       )
     end
 
@@ -84,7 +84,7 @@ describe PgSearch::Features::TSearch do
 
         feature = described_class.new(query, options, columns, Model, normalizer)
         expect(feature.conditions.to_sql).to eq(
-          %{((to_tsvector('simple', coalesce((#{Model.quoted_table_name}."name")::text, '')) || to_tsvector('simple', coalesce((#{Model.quoted_table_name}."content")::text, ''))) @@ (to_tsquery('simple', '!' || ''' ' || 'query' || ' ''')))}
+          %{((to_tsvector('simple', coalesce(cast(#{Model.quoted_table_name}."name" AS text), '')) || to_tsvector('simple', coalesce(cast(#{Model.quoted_table_name}."content" AS text), ''))) @@ (to_tsquery('simple', '!' || ''' ' || 'query' || ' ''')))}
         )
       end
     end
@@ -102,7 +102,7 @@ describe PgSearch::Features::TSearch do
 
         feature = described_class.new(query, options, columns, Model, normalizer)
         expect(feature.conditions.to_sql).to eq(
-          %{((to_tsvector('simple', coalesce((#{Model.quoted_table_name}."name")::text, '')) || to_tsvector('simple', coalesce((#{Model.quoted_table_name}."content")::text, ''))) @@ (to_tsquery('simple', ''' ' || '!query' || ' ''')))}
+          %{((to_tsvector('simple', coalesce(cast(#{Model.quoted_table_name}."name" AS text), '')) || to_tsvector('simple', coalesce(cast(#{Model.quoted_table_name}."content" AS text), ''))) @@ (to_tsquery('simple', ''' ' || '!query' || ' ''')))}
         )
       end
     end
@@ -164,7 +164,7 @@ describe PgSearch::Features::TSearch do
 
       feature = described_class.new(query, options, columns, Model, normalizer)
       expect(feature.highlight.to_sql).to eq(
-        "(ts_headline('simple', (coalesce((#{Model.quoted_table_name}.\"name\")::text, '')), (to_tsquery('simple', ''' ' || 'query' || ' ''')), ''))"
+        "(ts_headline('simple', (coalesce(cast(#{Model.quoted_table_name}.\"name\" AS text), '')), (to_tsquery('simple', ''' ' || 'query' || ' ''')), ''))"
       )
     end
 
@@ -189,7 +189,7 @@ describe PgSearch::Features::TSearch do
 
         feature = described_class.new(query, options, columns, Model, normalizer)
 
-        expected_sql = %{(ts_headline('spanish', (coalesce((#{Model.quoted_table_name}."name")::text, '') || ' ' || coalesce((#{Model.quoted_table_name}."content")::text, '')), (to_tsquery('spanish', ''' ' || 'query' || ' ''')), 'StartSel = "<b>", StopSel = "</b>"'))}
+        expected_sql = %{(ts_headline('spanish', (coalesce(cast(#{Model.quoted_table_name}."name" AS text), '') || ' ' || coalesce(cast(#{Model.quoted_table_name}."content" AS text), '')), (to_tsquery('spanish', ''' ' || 'query' || ' ''')), 'StartSel = "<b>", StopSel = "</b>"'))}
 
         expect(feature.highlight.to_sql).to eq(expected_sql)
       end
@@ -221,7 +221,7 @@ describe PgSearch::Features::TSearch do
 
         feature = described_class.new(query, options, columns, Model, normalizer)
 
-        expected_sql = %{(ts_headline('simple', (coalesce((#{Model.quoted_table_name}."name")::text, '')), (to_tsquery('simple', ''' ' || 'query' || ' ''')), 'StartSel = "<start class=""search"">", StopSel = "<stop>", MaxFragments = 3, MaxWords = 123, MinWords = 456, ShortWord = 4, FragmentDelimiter = "&hellip;", HighlightAll = TRUE'))}
+        expected_sql = %{(ts_headline('simple', (coalesce(cast(#{Model.quoted_table_name}."name" AS text), '')), (to_tsquery('simple', ''' ' || 'query' || ' ''')), 'StartSel = "<start class=""search"">", StopSel = "<stop>", MaxFragments = 3, MaxWords = 123, MinWords = 456, ShortWord = 4, FragmentDelimiter = "&hellip;", HighlightAll = TRUE'))}
 
         expect(feature.highlight.to_sql).to eq(expected_sql)
       end
@@ -252,7 +252,7 @@ describe PgSearch::Features::TSearch do
         feature = described_class.new(query, options, columns, Model, normalizer)
 
         highlight_sql = silence_warnings { feature.highlight.to_sql }
-        expected_sql = %{(ts_headline('simple', (coalesce((#{Model.quoted_table_name}."name")::text, '')), (to_tsquery('simple', ''' ' || 'query' || ' ''')), 'StartSel = "<start class=""search"">", StopSel = "<stop>", MaxFragments = 3, MaxWords = 123, MinWords = 456, ShortWord = 4, FragmentDelimiter = "&hellip;", HighlightAll = FALSE'))}
+        expected_sql = %{(ts_headline('simple', (coalesce(cast(#{Model.quoted_table_name}."name" AS text), '')), (to_tsquery('simple', ''' ' || 'query' || ' ''')), 'StartSel = "<start class=""search"">", StopSel = "<stop>", MaxFragments = 3, MaxWords = 123, MinWords = 456, ShortWord = 4, FragmentDelimiter = "&hellip;", HighlightAll = FALSE'))}
 
         expect(highlight_sql).to eq(expected_sql)
       end