torque-postgresql 3.4.1 → 4.0.0.rc1

data/spec/tests/enum_spec.rb

@@ -70,7 +70,6 @@ RSpec.describe 'Enum' do
   end
 
   context 'on value' do
-    subject { Enum::ContentStatus }
     let(:values) { %w(created draft published archived) }
     let(:error) { Torque::PostgreSQL::Attributes::Enum::EnumError }
     let(:mock_enum) do
@@ -79,6 +78,8 @@ RSpec.describe 'Enum' do
       klass
     end
 
+    subject { Enum::ContentStatus }
+
     it 'class exists' do
       namespace = Torque::PostgreSQL.config.enum.namespace
       expect(namespace.const_defined?('ContentStatus')).to be_truthy
@@ -341,10 +342,11 @@ RSpec.describe 'Enum' do
   end
 
   context 'on model' do
+    let(:instance) { FactoryBot.build(:user) }
+
     before(:each) { decorate(User, :role) }
 
     subject { User }
-    let(:instance) { FactoryBot.build(:user) }
 
     it 'has all enum methods' do
       expect(subject).to  respond_to(:roles)

data/spec/tests/full_text_seach_test.rb

@@ -0,0 +1,252 @@
+require 'spec_helper'
+
+RSpec.describe 'FullTextSearch' do
+  context 'on builder' do
+    let(:builder) { Torque::PostgreSQL::Attributes::Builder }
+
+    describe '.to_search_weights' do
+      it 'works with a single column' do
+        expect(builder.to_search_weights('title')).to eq({ 'title' => 'A' })
+        expect(builder.to_search_weights(:title)).to eq({ 'title' => 'A' })
+      end
+
+      it 'works with an array of columns' do
+        value = { 'title' => 'A', 'content' => 'B' }
+        expect(builder.to_search_weights(%w[title content])).to eq(value)
+        expect(builder.to_search_weights(%i[title content])).to eq(value)
+      end
+
+      it 'works with a hash of columns and weights' do
+        value = { 'title' => 'A', 'content' => 'B', 'summary' => 'C' }
+        expect(builder.to_search_weights(value.transform_keys(&:to_sym))).to eq(value)
+      end
+
+      it 'works with a hash of columns and invalid weights' do
+        value = { 'title' => 'X', 'content' => 'Y', 'summary' => 'Z' }
+        expect(builder.to_search_weights(value.transform_keys(&:to_sym))).to eq(value)
+      end
+    end
+
+    describe '.to_search_vector_operation' do
+      it 'builds a simple one' do
+        result = builder.to_search_vector_operation('english', { 'title' => 'A' })
+        expect(result.to_sql).to eq("TO_TSVECTOR('english', COALESCE(title, ''))")
+      end
+
+      it 'builds with 2 columns' do
+        columns = { 'title' => 'A', 'content' => 'B' }
+        result = builder.to_search_vector_operation('english', columns)
+        expect(result.to_sql).to eq(<<~SQL.squish)
+          SETWEIGHT(TO_TSVECTOR('english', COALESCE(title, '')), 'A') ||
+          SETWEIGHT(TO_TSVECTOR('english', COALESCE(content, '')), 'B')
+        SQL
+      end
+
+      it 'builds with a dynamic language' do
+        columns = { 'title' => 'A', 'content' => 'B' }
+        result = builder.to_search_vector_operation(:lang, columns)
+        expect(result.to_sql).to eq(<<~SQL.squish)
+          SETWEIGHT(TO_TSVECTOR(lang, COALESCE(title, '')), 'A') ||
+          SETWEIGHT(TO_TSVECTOR(lang, COALESCE(content, '')), 'B')
+        SQL
+      end
+    end
+
+    describe '.search_vector_options' do
+      it 'correctly translates the settings' do
+        options = builder.search_vector_options(columns: 'title')
+        expect(options).to eq(
+          type: :tsvector,
+          as: "TO_TSVECTOR('english', COALESCE(title, ''))",
+          stored: true,
+        )
+      end
+
+      it 'properly adds the index type' do
+        options = builder.search_vector_options(columns: 'title', index: true)
+        expect(options).to eq(
+          type: :tsvector,
+          as: "TO_TSVECTOR('english', COALESCE(title, ''))",
+          stored: true,
+          index: { using: :gin },
+        )
+      end
+    end
+  end
+
+  context 'on schema dumper' do
+    let(:connection) { ActiveRecord::Base.connection }
+    let(:source) { ActiveRecord::Base.connection_pool }
+    let(:dump_result) do
+      ActiveRecord::SchemaDumper.dump(source, (dump_result = StringIO.new))
+      dump_result.string
+    end
+
+    it 'properly supports search language' do
+      parts = %{t.search_language "lang", default: "english", null: false}
+      expect(dump_result).to include(parts)
+    end
+
+    it 'properly translates a simple single search vector with embedded language' do
+      parts = 't.search_vector "search_vector", stored: true'
+      parts << ', language: :lang, columns: :title'
+      expect(dump_result).to include(parts)
+    end
+
+    it 'properly translates a simple multiple column search vector with language' do
+      parts = 't.search_vector "search_vector", stored: true'
+      parts << ', language: "english", columns: [:title, :content]'
+      expect(dump_result).to include(parts)
+    end
+
+    it 'supports a custom definition of weights' do
+      connection.create_table :custom_search do |t|
+        t.string :title
+        t.string :content
+        t.string :subtitle
+        t.search_vector :sample_a, columns: {
+          title: 'A',
+          subtitle: 'A',
+          content: 'B',
+        }
+        t.search_vector :sample_b, columns: {
+          title: 'A',
+          subtitle: 'C',
+          content: 'D',
+        }
+        t.search_vector :sample_c, columns: {
+          title: 'C',
+          subtitle: 'B',
+          content: 'A',
+        }
+      end
+
+      parts = 't.search_vector "sample_a", stored: true'
+      parts << ', language: "english", columns: { title: "A", subtitle: "A", content: "B" }'
+      expect(dump_result).to include(parts)
+
+      parts = 't.search_vector "sample_b", stored: true'
+      parts << ', language: "english", columns: { title: "A", subtitle: "C", content: "D" }'
+      expect(dump_result).to include(parts)
+
+      parts = 't.search_vector "sample_c", stored: true'
+      parts << ', language: "english", columns: [:content, :subtitle, :title]'
+      expect(dump_result).to include(parts)
+    end
+  end
+
+  context 'on config' do
+    let(:base) { Course }
+    let(:scope) { 'full_text_search' }
+
+    let(:mod) { base.singleton_class.included_modules.first }
+
+    after { mod.send(:undef_method, scope) if scope.present? }
+
+    it 'has the initialization method' do
+      scope.replace('')
+      expect(base).to respond_to(:torque_search_for)
+    end
+
+    it 'properly generates the search scope' do
+      base.torque_search_for(:search_vector)
+      expect(base.all).to respond_to(:full_text_search)
+    end
+
+    it 'works with prefix and suffix' do
+      scope.replace('custom_full_text_search_scope')
+      base.torque_search_for(:search_vector, prefix: 'custom', suffix: 'scope')
+      expect(base.all).to respond_to(:custom_full_text_search_scope)
+    end
+  end
+
+  context 'on relation' do
+    let(:base) { Course }
+    let(:scope) { 'full_text_search' }
+
+    let(:mod) { base.singleton_class.included_modules.first }
+
+    before { Course.torque_search_for(:search_vector) }
+    after { mod.send(:undef_method, :full_text_search) }
+
+    it 'performs a simple query' do
+      result = Course.full_text_search('test')
+      parts = 'SELECT "courses".* FROM "courses"'
+      parts << ' WHERE "courses"."search_vector" @@'
+      parts << " PHRASETO_TSQUERY('english', 'test')"
+      expect(result.to_sql).to eql(parts)
+    end
+
+    it 'can include the order' do
+      result = Course.full_text_search('test', order: true)
+      parts = 'SELECT "courses".* FROM "courses"'
+      parts << ' WHERE "courses"."search_vector" @@'
+      parts << " PHRASETO_TSQUERY('english', 'test')"
+      parts << ' ORDER BY TS_RANK("courses"."search_vector",'
+      parts << " PHRASETO_TSQUERY('english', 'test')) ASC"
+      expect(result.to_sql).to eql(parts)
+    end
+
+    it 'can include the order descending' do
+      result = Course.full_text_search('test', order: :desc)
+      parts = 'SELECT "courses".* FROM "courses"'
+      parts << ' WHERE "courses"."search_vector" @@'
+      parts << " PHRASETO_TSQUERY('english', 'test')"
+      parts << ' ORDER BY TS_RANK("courses"."search_vector",'
+      parts << " PHRASETO_TSQUERY('english', 'test')) DESC"
+      expect(result.to_sql).to eql(parts)
+    end
+
+    it 'can include the rank' do
+      result = Course.full_text_search('test', rank: true)
+      parts = 'SELECT "courses".*, TS_RANK("courses"."search_vector",'
+      parts << " PHRASETO_TSQUERY('english', 'test')) AS rank"
+      parts << ' FROM "courses" WHERE "courses"."search_vector" @@'
+      parts << " PHRASETO_TSQUERY('english', 'test')"
+      expect(result.to_sql).to eql(parts)
+    end
+
+    it 'can include the rank named differently' do
+      result = Course.full_text_search('test', rank: :custom_rank)
+      parts = 'SELECT "courses".*, TS_RANK("courses"."search_vector",'
+      parts << " PHRASETO_TSQUERY('english', 'test')) AS custom_rank"
+      parts << ' FROM "courses" WHERE "courses"."search_vector" @@'
+      parts << " PHRASETO_TSQUERY('english', 'test')"
+      expect(result.to_sql).to eql(parts)
+    end
+
+    it 'can use regular query mode' do
+      result = Course.full_text_search('test', phrase: false)
+      parts = 'SELECT "courses".* FROM "courses"'
+      parts << ' WHERE "courses"."search_vector" @@'
+      parts << " TO_TSQUERY('english', 'test')"
+      expect(result.to_sql).to eql(parts)
+    end
+
+    it 'can use a attribute as the language' do
+      result = Course.full_text_search('test', language: :lang)
+      parts = 'SELECT "courses".* FROM "courses"'
+      parts << ' WHERE "courses"."search_vector" @@'
+      parts << %{ PHRASETO_TSQUERY("courses"."lang", 'test')}
+      expect(result.to_sql).to eql(parts)
+    end
+
+    it 'can call a method to pull the language' do
+      Course.define_singleton_method(:search_language) { 'portuguese' }
+      result = Course.full_text_search('test', language: :search_language)
+      parts = 'SELECT "courses".* FROM "courses"'
+      parts << ' WHERE "courses"."search_vector" @@'
+      parts << " PHRASETO_TSQUERY('portuguese', 'test')"
+      expect(result.to_sql).to eql(parts)
+      Course.singleton_class.undef_method(:search_language)
+    end
+
+    it 'properly binds all provided values' do
+      query = Course.full_text_search('test')
+      sql, binds = get_query_with_binds { query.load }
+      expect(sql).to include("PHRASETO_TSQUERY($1, $2)")
+      expect(binds.first.value).to eq('english')
+      expect(binds.second.value).to eq('test')
+    end
+  end
+end

data/spec/tests/function_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+RSpec.describe 'Function' do
+  let(:helper) { Torque::PostgreSQL::FN }
+  let(:conn) { ActiveRecord::Base.connection }
+  let(:visitor) { ::Arel::Visitors::PostgreSQL.new(conn) }
+  let(:collector) { ::Arel::Collectors::SQLString }
+
+  context 'on helper' do
+    it 'helps creating a bind' do
+      type = ::ActiveRecord::Type::String.new
+      expect(helper.bind(:foo, 'test', type)).to be_a(::Arel::Nodes::BindParam)
+    end
+
+    it 'helps creating a bind for a model attribute' do
+      expect(helper.bind_for(Video, :title, 'test')).to be_a(::Arel::Nodes::BindParam)
+    end
+
+    it 'helps creating a bind for an arel attribute' do
+      attr = Video.arel_table['title']
+      expect(helper.bind_with(attr, 'test')).to be_a(::Arel::Nodes::BindParam)
+    end
+
+    it 'helps concatenating arguments' do
+      values = %w[a b c].map(&::Arel.method(:sql))
+
+      # Unable to just call .sql with a simple thing
+      visited = visitor.accept(helper.concat(values[0]), collector.new)
+      expect(visited.value).to eq("a")
+
+      # 2+ we can call .sql directly
+      expect(helper.concat(values[0], values[1]).to_sql).to eq("a || b")
+      expect(helper.concat(values[0], values[1], values[2]).to_sql).to eq("a || b || c")
+    end
+
+    it 'helps building any other function' do
+      values = %w[a b c].map(&::Arel.method(:sql))
+      expect(helper).to respond_to(:coalesce)
+      expect(helper.coalesce(values[0], values[1]).to_sql).to eq("COALESCE(a, b)")
+    end
+  end
+end

data/spec/tests/has_many_spec.rb

@@ -11,7 +11,7 @@ RSpec.describe 'HasMany' do
 
   context 'on original' do
     let(:other) { Text }
-    let(:key) { Torque::PostgreSQL::AR720 ? :texts : 'texts' }
+    let(:key) { :texts }
 
     before { User.has_many :texts }
     subject { User.create(name: 'User 1') }
@@ -247,7 +247,7 @@ RSpec.describe 'HasMany' do
 
   context 'on array' do
     let(:other) { Video }
-    let(:key) { Torque::PostgreSQL::AR720 ? :videos : 'videos' }
+    let(:key) { :videos }
 
     before { Tag.has_many :videos, array: true }
     subject { Tag.create(name: 'A') }
@@ -264,15 +264,21 @@ RSpec.describe 'HasMany' do
     end
 
     it 'loads associated records' do
-      expect(subject.videos.to_sql).to match(Regexp.new(<<-SQL.squish))
-        SELECT "videos"\\.\\* FROM "videos"
-        WHERE \\(?"videos"\\."tag_ids" && ARRAY\\[#{subject.id}\\]::bigint\\[\\]\\)?
+      expect(subject.videos.to_sql).to eq(<<~SQL.squish)
+        SELECT "videos".* FROM "videos" WHERE #{subject.id} = ANY("videos"."tag_ids")
       SQL
 
       expect(subject.videos.load).to be_a(ActiveRecord::Associations::CollectionProxy)
       expect(subject.videos.to_a).to be_eql([])
     end
 
+    it 'uses binds instead of the literal value' do
+      query = subject.videos
+      sql, binds = get_query_with_binds { query.load }
+      expect(sql).to include('WHERE $1 = ANY("videos"."tag_ids")')
+      expect(binds.first.value).to eq(subject.id)
+    end
+
     it 'can be marked as loaded' do
       expect(subject.videos.loaded?).to be_eql(false)
       expect(subject.videos).to respond_to(:load_target)
@@ -474,15 +480,22 @@ RSpec.describe 'HasMany' do
     subject { player.create }
 
     it 'loads associated records' do
-      expect(subject.games.to_sql).to match(Regexp.new(<<-SQL.squish))
-        SELECT "games"\\.\\* FROM "games"
-        WHERE \\(?"games"\\."player_ids" && ARRAY\\['#{subject.id}'\\]::uuid\\[\\]\\)?
+      expect(subject.games.to_sql).to eq(<<~SQL.squish)
+        SELECT "games".* FROM "games"
+        WHERE '#{subject.id}' = ANY("games"."player_ids")
       SQL
 
       expect(subject.games.load).to be_a(ActiveRecord::Associations::CollectionProxy)
       expect(subject.games.to_a).to be_eql([])
     end
 
+    it 'uses binds instead of the literal value' do
+      query = subject.games
+      sql, binds = get_query_with_binds { query.load }
+      expect(sql).to include('WHERE $1 = ANY("games"."player_ids")')
+      expect(binds.first.value).to eq(subject.id)
+    end
+
     it 'can preload records' do
       5.times { game.create(player_ids: [subject.id]) }
       entries = player.all.includes(:games).load

data/spec/tests/interval_spec.rb

@@ -3,13 +3,7 @@ require 'spec_helper'
 RSpec.describe 'Interval' do
   let(:table_definition) { ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition }
   let(:connection) { ActiveRecord::Base.connection }
-  let(:source) do
-    if Torque::PostgreSQL::AR720
-      ActiveRecord::Base.connection_pool
-    else
-      ActiveRecord::Base.connection
-    end
-  end
+  let(:source) { ActiveRecord::Base.connection_pool }
 
   context 'on settings' do
     it 'must be set to ISO 8601' do