Merge branch 'fix-bug-with-join-query' into 'join-bug-fix-with-multiple-default-columns'

Fix bug with join query

See merge request saburly/senadibilal/reklamice/gem!3

lib/pg_searchable_regex.rb

@@ -26,7 +26,7 @@ module PgSearchable
       wildcard: true,
       external_cache_data: nil,
       joins: [],
-      default_field: ""
+      default_fields: []
     )
       @ts_search_fields = fields
       @ts_search_fields_mappings = fields_mappings
@@ -36,7 +36,11 @@ module PgSearchable
       @ts_skip_cache_update = skip_callback
       @ts_wildcard = wildcard
       @ts_joins = joins
-      @default_field = default_field.to_s.empty? ? fields.first : default_field.to_sym
+      @default_fields = if default_fields.is_a? Array
+                          default_fields.empty? ? [fields.first] : default_fields
+                        else
+                          default_fields.to_s.empty? ? [fields.first] : [default_fields.to_sym]
+                        end
       ts_add_scope
     end
 
@@ -51,8 +55,16 @@ module PgSearchable
 
     def ts_search(value)
       return if @ts_search_fields.blank? || value.blank?
-      includes(@ts_joins).references(:all).where(
+      model = ancestors.first
-        TextToSqlQuery.new(value, @ts_search_fields, @default_field, @ts_search_fields_mappings).where_clause).distinct
+      sql_query_object = TextToSqlQuery.new(
+        value,
+        @ts_search_fields,
+        @default_fields,
+        @ts_search_fields_mappings,
+        @ts_joins,
+        model
+      )
+      joins(sql_query_object.join_clause).where(sql_query_object.where_clause).distinct
     end
 
     def should_update_cache_field?

lib/text_to_sql_query.rb

@@ -1,10 +1,17 @@
 require_relative 'parser'
 
 class TextToSqlQuery
-  def initialize(text, fields, default_field, fields_mappings = {})
+  def initialize(text, fields, default_fields, fields_mappings = {}, joins = [], model = nil)
     @text = text.to_s.strip
     @fields = fields.map(&:to_sym)
-    @default_field = default_field.to_sym
+
+    # Keep compatibility with previous version where default_field(s) was string/symbol
+    @default_fields = if default_fields.is_a? Array
+                        default_fields.map(&:to_sym)
+                      else
+                        [default_fields.to_sym]
+                      end
+
     @fields_mappings = fields_mappings.merge(@fields.reduce({}) do |mappings, field|
       _table_name, field_name = field.to_s.split('.')
       mappings[field_name.to_sym] = field
@@ -13,6 +20,8 @@ class TextToSqlQuery
     fields_mappings.each do |field, value|
       @fields_mappings[field] = value if @fields_mappings[field]
     end
+    @joins = joins
+    @model = model
   end
 
   def where_clause
@@ -21,6 +30,20 @@ class TextToSqlQuery
     generate_sql @parsed_tree
   end
 
+  def join_clause
+    return if @joins.empty?
+
+    table_column_mappings
+    model_association_mappings
+
+    join_clause_part = ''
+    @joins.each do |join|
+      join_sql_part = generate_join_sql_part_for join
+      join_clause_part += join_sql_part
+    end
+    join_clause_part
+  end
+
   private
 
   def generate_sql(tree)
@@ -29,7 +52,14 @@ class TextToSqlQuery
     case first_key
     when :DEFAULT_COLUMN
       escaped_node_value = handle_special_chars node_value
-      ["CAST(#{@default_field.to_s} AS TEXT) ILIKE ?", "%#{escaped_node_value}%"]
+      query_part = '('
+      params_part = []
+      @default_fields.each do |default_field|
+        query_part += "CAST(#{default_field.to_s} AS TEXT) ILIKE ? OR "
+        params_part << "%#{escaped_node_value}%"
+      end
+      query_part = query_part[0...-4] + ')'
+      [query_part, *params_part]
     when :OPERATOR_OR
       generate_expression_for_logical_operator(:OR, node_value)
     when :OPERATOR_AND
@@ -90,4 +120,50 @@ class TextToSqlQuery
     result.gsub!(/%/, '\%')
     result
   end
+
+  def table_column_mappings
+    @table_column_mappings = {}
+    @fields_mappings.each_value do |table_with_column|
+      split_names = table_with_column.to_s.split '.'
+      table_name = split_names.first
+      column_name = split_names.second
+      @table_column_mappings[table_name] = [] if @table_column_mappings[table_name].nil?
+      @table_column_mappings[table_name] << column_name
+    end
+    @table_column_mappings
+  end
+
+  def model_association_mappings
+    @model_associations = {}
+    @model.reflect_on_all_associations.each do |association|
+      name = association.name
+
+      @model_associations[name] = {
+        option_as: association.options[:as] || name,
+        type: association.type
+      }
+    end
+    @model_associations
+  end
+
+  def generate_join_sql_part_for(join)
+    association_data = @model_associations[join]
+    join_table_name = join.to_s
+    raise "Join table #{join_table_name} has no association data" if association_data.nil?
+
+    select_sql_part = ''
+    columns_for_table = @table_column_mappings[join_table_name] || []
+
+    # TODO: Can be optimized - do not include columns that are not referenced in user query
+    columns_for_table.each do |column_name|
+      select_sql_part += "string_agg(#{column_name}, '') AS #{column_name}, "
+    end
+
+    option_as = association_data[:option_as]
+    type = association_data[:type]
+    model_name = @model.to_s
+    table_name = @model.table_name
+
+    "LEFT JOIN (SELECT #{option_as}_id, #{select_sql_part} #{type} FROM #{join_table_name} GROUP BY #{option_as}_id, #{type}) #{join_table_name} on #{join_table_name}.#{option_as}_id = #{table_name}.id AND #{join_table_name}.#{type} = '#{model_name}'"
+  end
 end

spec/lib/pg_searchable_new_spec.rb

@@ -47,6 +47,20 @@ describe PgSearchable do
         expect(VectorModel.scope_search("#{record2.id}")).to contain_exactly(record2)
       end
 
+      it 'can search multiple default columns if no column name is used with single search term' do
+        records = VectorModelWithTwoDefaultColumns.create [{ name: 'hamo', value: '5' }, { name: 'meho', value: '20 hamo' }, { name: 'munja-5', value: '300' }]
+
+        expect(VectorModelWithTwoDefaultColumns.scope_search('name:hamo')).to contain_exactly(records[0])
+        expect(VectorModelWithTwoDefaultColumns.scope_search('hamo')).to contain_exactly(records[0], records[1])
+        expect(VectorModelWithTwoDefaultColumns.scope_search('5')).to contain_exactly(records[0], records[2])
+      end
+
+      it 'can search multiple default columns if no column name is used in query containing multiple search terms' do
+        records = VectorModelWithTwoDefaultColumns.create [{ name: 'hamo', value: '9' }, { name: 'meho', value: '5' }, { name: 'oko-9', value: '100' }]
+
+        expect(VectorModelWithTwoDefaultColumns.scope_search('(9 and not name:hamo) or meho')).to contain_exactly(records[2], records[1])
+      end
+
       it 'searches column declared in search term' do
         record1 = VectorModel.create name: 'hamo', value: '-45'
         record2 = VectorModel.create name: 'meho', value: '120'
@@ -144,37 +158,132 @@ describe PgSearchable do
         expect(DynamicModelWithTagValues.scope_search('tag:green or value:"not"')).to contain_exactly(record1, record2)
       end
 
+      describe 'searching in model with has_many association' do
+        before do
+          records = DynamicModelWithTagValues.create [{ name: 'something', value: 'amazing' },
+                                                                        { name: 'new record', value: 'not so amazing' },
+                                                                        { name: 'last one', value: 'no value' },
+                                                                        { name: 'really last one', value: 'no value' }]
 
+          Tag.create [{ taggable: records[0], value: 'red', custom_attribute: 'rose' },
+                      { taggable: records[0], value: 'green', custom_attribute: 'garden' },
+                      { taggable: records[1], value: 'black', custom_attribute: 'sky' },
+                      { taggable: records[2], value: '-1/12', custom_attribute: 'gold nugget' },
+                      { taggable: records[3], value: '-', custom_attribute: 'unknown' },
+                      { taggable: records[3], value: 'red-green', custom_attribute: 'unicorn' }]
+        end
 
-      it 'can search in referenced column and in model columns with multiple search terms connected with logical operators' do
+        it 'can search with multiple search terms connected with OR operator' do
-        record1 = DynamicModelWithTagValues.create name: 'something', value: 'amazing'
+          records = DynamicModelWithTagValues.all
-        record2 = DynamicModelWithTagValues.create name: 'new record', value: 'not so amazing'
+
-        record3 = DynamicModelWithTagValues.create name: 'last one', value: 'no value'
+          expect(DynamicModelWithTagValues.scope_search('tag:red or tag:black')).to contain_exactly(records[0], records[1], records[3])
-        record4 = DynamicModelWithTagValues.create name: 'really last one', value: 'no value'
+          expect(DynamicModelWithTagValues.scope_search('tag:red or tag:green')).to contain_exactly(records[0], records[3])
-        Tag.create(taggable: record1, value: 'red')
+        end
-        Tag.create(taggable: record1, value: 'green')
+
-        Tag.create(taggable: record2, value: 'black')
+        it 'can search with multiple search terms connected with AND operator' do
-        Tag.create(taggable: record3, value: '-12')
+          records = DynamicModelWithTagValues.all
-        Tag.create(taggable: record4, value: '-')
 
-        expect(DynamicModelWithTagValues.scope_search('tag:red or tag:black')).to contain_exactly(record1, record2)
           expect(DynamicModelWithTagValues.scope_search('tag:red and tag:black')).to be_empty
-        expect(DynamicModelWithTagValues.scope_search('tag:red or tag:green')).to contain_exactly(record1)
+          expect(DynamicModelWithTagValues.scope_search('tag:red and tag:green')).to contain_exactly(records[0], records[3])
-        expect(DynamicModelWithTagValues.scope_search('not tag:-12 and not value:amazing')).to contain_exactly(record4)
+        end
+
+        it 'can search with multiple search terms and containing NOT' do
+          records = DynamicModelWithTagValues.all
+
+          expect(DynamicModelWithTagValues.scope_search('not tag:"-1/12" and not value:amazing')).to contain_exactly(records[3])
         end
 
         it 'can search in referenced column and in model columns with multiple search terms connected with logical operators and with brackets' do
-        record1 = DynamicModelWithTagValues.create name: 'something', value: 'amazing'
+          records = DynamicModelWithTagValues.all
-        record2 = DynamicModelWithTagValues.create name: 'new record', value: 'not so amazing'
-        record3 = DynamicModelWithTagValues.create name: 'last one', value: 'no value'
-        record4 = DynamicModelWithTagValues.create name: 'really last one', value: 'no value'
-        Tag.create(taggable: record1, value: 'red')
-        Tag.create(taggable: record1, value: 'green')
-        Tag.create(taggable: record2, value: 'black')
-        Tag.create(taggable: record3, value: '-12')
-        Tag.create(taggable: record4, value: '-')
 
-        expect(DynamicModelWithTagValues.scope_search('(tag:- and not tag:12) or (value:"amazing" and not value:"not")')).to contain_exactly(record1, record4)
+          expect(DynamicModelWithTagValues.scope_search('(tag:- and not tag:12) or (value:"amazing" and not value:"not")')).to contain_exactly(records[0], records[3])
+        end
+      end
+
+      describe 'searching through multiple referenced columns in model with has_many association' do
+        before do
+          records = DynamicModelWithTagValuesAndCustomAttribute.create [{ name: 'something', value: 'amazing' },
+                                                                        { name: 'new record', value: 'not so amazing' },
+                                                                        { name: 'last one', value: 'no value' },
+                                                                        { name: 'really last one', value: 'no value' }]
+
+          Tag.create [{ taggable: records[0], value: 'red', custom_attribute: 'rose' },
+                      { taggable: records[0], value: 'green', custom_attribute: 'garden' },
+                      { taggable: records[1], value: 'black', custom_attribute: 'sky' },
+                      { taggable: records[2], value: '-1/12', custom_attribute: 'gold nugget' },
+                      { taggable: records[3], value: '-', custom_attribute: 'unknown' },
+                      { taggable: records[3], value: 'red-green', custom_attribute: 'unicorn' }]
+        end
+
+        it 'can search with multiple search terms connected with OR operator' do
+          records = DynamicModelWithTagValuesAndCustomAttribute.all
+
+          expect(DynamicModelWithTagValuesAndCustomAttribute.scope_search('tag:red or custom:sky')).to contain_exactly(records[0], records[1], records[3])
+        end
+
+        it 'can search with multiple search terms connected with AND operator' do
+          records = DynamicModelWithTagValuesAndCustomAttribute.all
+
+          expect(DynamicModelWithTagValuesAndCustomAttribute.scope_search('custom:unicorn and tag:black')).to be_empty
+          expect(DynamicModelWithTagValuesAndCustomAttribute.scope_search('tag:"-1/12" and custom:gold')).to contain_exactly(records[2])
+        end
+
+        it 'can search with multiple search terms and containing NOT' do
+          expect(DynamicModelWithTagValuesAndCustomAttribute.scope_search('not tag:"-1/12" and not value:amazing and not custom:unknown')).to be_empty
+        end
+
+        it 'can search with multiple search terms connected with logical operators and with brackets' do
+          records = DynamicModelWithTagValuesAndCustomAttribute.all
+
+          expect(DynamicModelWithTagValuesAndCustomAttribute.scope_search('(tag:- and not tag:12) or (value:"amazing" and not value:"not") or (custom:unknown or custom:rose)')).to contain_exactly(records[0], records[3])
+        end
+      end
+
+      describe 'searching in model with multiple has_many associations' do
+        before do
+          records = DynamicModelWithTagAndCategories.create [{ name: 'something', value: 'amazing' },
+                                                                        { name: 'new record', value: 'not so amazing' },
+                                                                        { name: 'last one', value: 'no value' },
+                                                                        { name: 'really last one', value: 'no value' }]
+
+          Tag.create [{ taggable: records[0], value: 'red', custom_attribute: 'rose' },
+                      { taggable: records[0], value: 'green', custom_attribute: 'garden' },
+                      { taggable: records[1], value: 'black', custom_attribute: 'sky' },
+                      { taggable: records[2], value: '-1/12', custom_attribute: 'gold nugget' },
+                      { taggable: records[3], value: '-', custom_attribute: 'unknown' },
+                      { taggable: records[3], value: 'red-green', custom_attribute: 'unicorn' }]
+
+          Category.create [{ categoriable: records[0], name: 'home' },
+                           { categoriable: records[0], name: 'home' },
+                           { categoriable: records[1], name: 'world' },
+                           { categoriable: records[2], name: 'math' },
+                           { categoriable: records[3], name: 'unknown' },
+                           { categoriable: records[3], name: 'myth' }]
+
+        end
+
+        it 'can search with multiple search terms connected with OR operator' do
+          records = DynamicModelWithTagAndCategories.all
+
+          expect(DynamicModelWithTagAndCategories.scope_search('tag:red or category:math')).to contain_exactly(records[0], records[2], records[3])
+        end
+
+        it 'can search with multiple search terms connected with AND operator' do
+          records = DynamicModelWithTagAndCategories.all
+
+          expect(DynamicModelWithTagAndCategories.scope_search('category:home and tag:-')).to be_empty
+          expect(DynamicModelWithTagAndCategories.scope_search('tag:"-1/12" and category:math')).to contain_exactly(records[2])
+        end
+
+        it 'can search with multiple search terms and containing NOT' do
+          expect(DynamicModelWithTagAndCategories.scope_search('not tag:"-1/12" and not value:amazing and not category:unknown')).to be_empty
+        end
+
+        it 'can search with multiple search terms connected with logical operators and with brackets' do
+          records = DynamicModelWithTagAndCategories.all
+
+          expect(DynamicModelWithTagAndCategories.scope_search('(tag:- and not tag:12) or (value:"amazing" and not value:"not") or (category:unknown or category:math)')).to contain_exactly(records[0], records[2], records[3])
+        end
       end
     end
   end

spec/lib/text_to_sql_query_spec.rb

@@ -4,7 +4,16 @@ require_relative '../../lib/text_to_sql_query'
 describe TextToSqlQuery do
   describe '.new' do
     # tests simple search term without column name and without quotes
-    it { expect(described_class.new('some-default-value', [:"players.name"], :"players.name").where_clause).to eq(['CAST(players.name AS TEXT) ILIKE ?', '%some-default-value%']) }
+    it { expect(described_class.new('some-default-value', [:"players.name"], :"players.name").where_clause).to eq(['(CAST(players.name AS TEXT) ILIKE ?)', '%some-default-value%']) }
+
+    # tests simple search with two default columns without quotes
+    it { expect(described_class.new('search-term', [:'players.name', :'players.tags', 'players.id'], [:'players.name', :'players.tags']).where_clause).to eq(['(CAST(players.name AS TEXT) ILIKE ? OR CAST(players.tags AS TEXT) ILIKE ?)', '%search-term%', '%search-term%']) }
+
+    # tests simple search with two default columns with quotes
+    it { expect(described_class.new('"search-term"', [:'players.name', :'players.tags', 'players.id'], [:'players.name', :'players.tags']).where_clause).to eq(['(CAST(players.name AS TEXT) ILIKE ? OR CAST(players.tags AS TEXT) ILIKE ?)', '%search-term%', '%search-term%']) }
+
+    # tests simple search with three default columns without quotes
+    it { expect(described_class.new('search-term', [:'players.name', :'players.tags', 'players.id'], [:'players.name', :'players.tags', :'players.id']).where_clause).to eq(['(CAST(players.name AS TEXT) ILIKE ? OR CAST(players.tags AS TEXT) ILIKE ? OR CAST(players.id AS TEXT) ILIKE ?)', '%search-term%', '%search-term%', '%search-term%']) }
 
     # tests simple search term with column name and without quotes
     it { expect(described_class.new('name:ab', [:"players.name"], :"players.name").where_clause).to eq(['CAST(players.name AS TEXT) ILIKE ?', '%ab%']) }
@@ -13,22 +22,22 @@ describe TextToSqlQuery do
     it { expect{described_class.new('unknown:ab', [:"players.name"], :"players.name").where_clause}.to raise_error(RuntimeError, "Unknown field 'unknown'") }
 
     # tests simple search term without column name and with quotes
-    it { expect(described_class.new('"ab"', [:"players.name", :"players.device_id"],  :"players.device_id").where_clause).to eq(["CAST(players.device_id AS TEXT) ILIKE ?", "%ab%"]) }
+    it { expect(described_class.new('"ab"', [:"players.name", :"players.device_id"],  :"players.device_id").where_clause).to eq(["(CAST(players.device_id AS TEXT) ILIKE ?)", "%ab%"]) }
 
     # tests simple search term with column name and with quotes
     it { expect(described_class.new('tags:"ab"', [:"players.name", :"players.tags"],  :"players.device_id").where_clause).to eq(["CAST(players.tags AS TEXT) ILIKE ?", "%ab%"]) }
 
     # tests search without operators
-    it { expect(described_class.new('123 456', [:"players.name", :"players.device_id"],  :"players.device_id").where_clause).to eq(["(CAST(players.device_id AS TEXT) ILIKE ? OR CAST(players.device_id AS TEXT) ILIKE ?)", "%123%", "%456%"]) }
+    it { expect(described_class.new('123 456', [:"players.name", :"players.device_id"],  :"players.device_id").where_clause).to eq(["((CAST(players.device_id AS TEXT) ILIKE ?) OR (CAST(players.device_id AS TEXT) ILIKE ?))", "%123%", "%456%"]) }
 
     # tests search with OR operator
-    it { expect(described_class.new('123 or 456', [:"players.name", :"players.device_id"],  :"players.device_id").where_clause).to eq(["(CAST(players.device_id AS TEXT) ILIKE ? OR CAST(players.device_id AS TEXT) ILIKE ?)", "%123%", "%456%"]) }
+    it { expect(described_class.new('123 or 456', [:"players.name", :"players.device_id"],  :"players.device_id").where_clause).to eq(["((CAST(players.device_id AS TEXT) ILIKE ?) OR (CAST(players.device_id AS TEXT) ILIKE ?))", "%123%", "%456%"]) }
 
     # tests search with AND operator
-    it { expect(described_class.new('123 and 456', [:"players.name", :"players.device_id"],  :"players.device_id").where_clause).to eq(["(CAST(players.device_id AS TEXT) ILIKE ? AND CAST(players.device_id AS TEXT) ILIKE ?)", "%123%", "%456%"]) }
+    it { expect(described_class.new('123 and 456', [:"players.name", :"players.device_id"],  :"players.device_id").where_clause).to eq(["((CAST(players.device_id AS TEXT) ILIKE ?) AND (CAST(players.device_id AS TEXT) ILIKE ?))", "%123%", "%456%"]) }
 
     # tests search with NOT operator on default column
-    it { expect(described_class.new('not 23', [:"players.name", :"players.device_id"],  :"players.device_id").where_clause).to eq(["NOT CAST(players.device_id AS TEXT) ILIKE ?", "%23%"]) }
+    it { expect(described_class.new('not 23', [:"players.name", :"players.device_id"],  :"players.device_id").where_clause).to eq(["NOT (CAST(players.device_id AS TEXT) ILIKE ?)", "%23%"]) }
 
     # tests search with NOT operator on non-default column
     it { expect(described_class.new('not value:23', [:"players.name", :"players.value"],  :"players.device_id").where_clause).to eq(["NOT CAST(players.value AS TEXT) ILIKE ?", "%23%"]) }
@@ -55,12 +64,15 @@ describe TextToSqlQuery do
     it { expect(described_class.new('tags:h1-r', [:'players.name', :'players.tags', :'players.device_id'],  :"players.device_id", { tags: "tags.value" }).where_clause).to eq(["CAST(tags.value AS TEXT) ILIKE ?", "%h1-r%"]) }
 
     # tests complex query
-    it { expect(described_class.new('(device_id:"with space" tags:mta no-quotes-id-123) or "id with quotes-5"  and   ( ("id with q 10" or "id with q 20") and ("id with Q 30" "id with Q 40") and not id-without-Q-50)', [:'players.name', :'players.value', :'players.device_id'],  :"players.device_id", { tags: 'tags.name' }).where_clause).to eq(['((CAST(players.device_id AS TEXT) ILIKE ? OR (CAST(tags.name AS TEXT) ILIKE ? OR CAST(players.device_id AS TEXT) ILIKE ?)) OR (CAST(players.device_id AS TEXT) ILIKE ? AND (((CAST(players.device_id AS TEXT) ILIKE ? OR CAST(players.device_id AS TEXT) ILIKE ?) AND (CAST(players.device_id AS TEXT) ILIKE ? OR CAST(players.device_id AS TEXT) ILIKE ?)) AND NOT CAST(players.device_id AS TEXT) ILIKE ?)))', '%with space%', '%mta%', '%no-quotes-id-123%', '%id with quotes-5%', '%id with q 10%', '%id with q 20%', '%id with Q 30%', '%id with Q 40%', '%id-without-Q-50%']) }
+    it { expect(described_class.new('(device_id:"with space" tags:mta no-quotes-id-123) or "id with quotes-5"  and   ( ("id with q 10" or "id with q 20") and ("id with Q 30" "id with Q 40") and not id-without-Q-50)', [:'players.name', :'players.value', :'players.device_id'],  :"players.device_id", { tags: 'tags.name' }).where_clause).to eq(['((CAST(players.device_id AS TEXT) ILIKE ? OR (CAST(tags.name AS TEXT) ILIKE ? OR (CAST(players.device_id AS TEXT) ILIKE ?))) OR ((CAST(players.device_id AS TEXT) ILIKE ?) AND ((((CAST(players.device_id AS TEXT) ILIKE ?) OR (CAST(players.device_id AS TEXT) ILIKE ?)) AND ((CAST(players.device_id AS TEXT) ILIKE ?) OR (CAST(players.device_id AS TEXT) ILIKE ?))) AND NOT (CAST(players.device_id AS TEXT) ILIKE ?))))', '%with space%', '%mta%', '%no-quotes-id-123%', '%id with quotes-5%', '%id with q 10%', '%id with q 20%', '%id with Q 30%', '%id with Q 40%', '%id-without-Q-50%']) }
+
+    # tests mixed query with and without column names and with multiple default columns
+    it { expect(described_class.new('("green hunter" and device_id:100) or ("blue bird" and not device_id:200)', [:'players.name', :'players.value', :'players.device_id'],  [:"players.name", :"players.tags"]).where_clause).to eq(['(((CAST(players.name AS TEXT) ILIKE ? OR CAST(players.tags AS TEXT) ILIKE ?) AND CAST(players.device_id AS TEXT) ILIKE ?) OR ((CAST(players.name AS TEXT) ILIKE ? OR CAST(players.tags AS TEXT) ILIKE ?) AND NOT CAST(players.device_id AS TEXT) ILIKE ?))', '%green hunter%', '%green hunter%', '%100%', '%blue bird%', '%blue bird%', '%200%']) }
 
     # tests query with multiple search terms with mixed and-or-not after dash and underscore
-    it { expect(described_class.new('123-and-456 -or-2 -not_not_1', [:'players.title', :'players.tag', :'players.device_id'], :'players.device_id').where_clause).to eq(['(CAST(players.device_id AS TEXT) ILIKE ? OR (CAST(players.device_id AS TEXT) ILIKE ? OR CAST(players.device_id AS TEXT) ILIKE ?))', '%123-and-456%', '%-or-2%', '%-not\_not\_1%'])}
+    it { expect(described_class.new('123-and-456 -or-2 -not_not_1', [:'players.title', :'players.tag', :'players.device_id'], :'players.device_id').where_clause).to eq(['((CAST(players.device_id AS TEXT) ILIKE ?) OR ((CAST(players.device_id AS TEXT) ILIKE ?) OR (CAST(players.device_id AS TEXT) ILIKE ?)))', '%123-and-456%', '%-or-2%', '%-not\_not\_1%'])}
 
     # tests query with multiple search terms with mixed and-or-not after dash and underscore
-    it { expect(described_class.new('andrew or ornela', [:'players.title', :'players.tag', :'players.device_id'], :'players.device_id').where_clause).to eq(['(CAST(players.device_id AS TEXT) ILIKE ? OR CAST(players.device_id AS TEXT) ILIKE ?)', '%andrew%', '%ornela%'])}
+    it { expect(described_class.new('andrew or ornela', [:'players.title', :'players.tag', :'players.device_id'], :'players.device_id').where_clause).to eq(['((CAST(players.device_id AS TEXT) ILIKE ?) OR (CAST(players.device_id AS TEXT) ILIKE ?))', '%andrew%', '%ornela%'])}
   end
 end

spec/schema.rb

@@ -27,6 +27,7 @@ ActiveRecord::Schema.define do
 
   create_table :tags, force: true do |t|
     t.string :value
+    t.string :custom_attribute
     t.references :category, index: true
     t.references :taggable, polymorphic: true, index: true
     t.timestamps null: false
@@ -34,6 +35,7 @@ ActiveRecord::Schema.define do
 
   create_table :categories, force: true do |t|
     t.string :name
+    t.references :categoriable, polymorphic: true, index: true
     t.timestamps null: false
   end
 

spec/support/models.rb

@@ -5,6 +5,12 @@ class VectorModel < ActiveRecord::Base
   pg_search fields: %i[vector_models.id vector_models.name vector_models.value], cache: :search_cache
 end
 
+class VectorModelWithTwoDefaultColumns < ActiveRecord::Base
+  self.table_name = :vector_models
+  include PgSearchable
+  pg_search fields: %i[vector_models.id vector_models.name vector_models.value], default_fields: %i[vector_models.name vector_models.value], cache: :search_cache
+end
+
 class VectorModelWithMappings < ActiveRecord::Base
   self.table_name = :vector_models
   include PgSearchable
@@ -76,6 +82,21 @@ class DynamicModelWithTagValues < ActiveRecord::Base
   has_many :tags, as: :taggable
 end
 
+class DynamicModelWithTagAndCategories < ActiveRecord::Base
+  self.table_name = :dynamic_models
+  include PgSearchable
+  pg_search fields: %i[dynamic_models.id dynamic_models.name dynamic_models.value], fields_mappings: {tag: 'tags.value', category: 'categories.name'}, joins: [:tags, :categories]
+  has_many :tags, as: :taggable
+  has_many :categories, as: :categoriable
+end
+
+class DynamicModelWithTagValuesAndCustomAttribute < ActiveRecord::Base
+  self.table_name = :dynamic_models
+  include PgSearchable
+  pg_search fields: %i[dynamic_models.id dynamic_models.name dynamic_models.value], fields_mappings: {tag: 'tags.value', custom: 'tags.custom_attribute'}, joins: [:tags]
+  has_many :tags, as: :taggable
+end
+
 class DynamicModelWithCategory < ActiveRecord::Base
   self.table_name = :dynamic_models
   include PgSearchable
@@ -106,4 +127,5 @@ end
 
 class Category < ActiveRecord::Base
   has_many :tags
+  belongs_to :categoriable, polymorphic: true
 end