torque-postgresql 4.0.1 → 4.1.1

data/spec/tests/cross_join_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+
+RSpec.describe 'CrossJoin' do
+  let(:table) { Profile.arel_table }
+  let(:snippets) { Torque::PostgreSQL::FN.unnest(table[:snippets]) }
+
+  context 'on model' do
+    it 'has its method' do
+      expect(Profile).to respond_to(:cross_join)
+    end
+
+    it 'returns a relation when using the method' do
+      expect(Profile.cross_join(snippets, as: :doc)).to be_a(ActiveRecord::Relation)
+    end
+  end
+
+  context 'on relation' do
+    subject { Profile.unscoped }
+
+    it 'has its method' do
+      expect(subject).to respond_to(:cross_join)
+    end
+
+    it 'joins an arel function without naming its columns' do
+      expect(subject.cross_join(snippets, as: :doc).to_sql).to \
+        eql('SELECT "profiles".* FROM "profiles" CROSS JOIN UNNEST("profiles"."snippets") "doc"')
+    end
+
+    it 'names the columns when they are given' do
+      expect(subject.cross_join(snippets, as: :doc, columns: %i[value]).to_sql).to \
+        eql('SELECT "profiles".* FROM "profiles" CROSS JOIN UNNEST("profiles"."snippets") "doc"("value")')
+    end
+
+    it 'does not write LATERAL for a function' do
+      expect(subject.cross_join(snippets, as: :doc).to_sql).not_to include('LATERAL')
+    end
+
+    it 'does not write ROWS FROM without an ordinality' do
+      expect(subject.cross_join(snippets, as: :doc).to_sql).not_to include('ROWS FROM')
+    end
+
+    it 'raises for a source it cannot join' do
+      expect { subject.cross_join('whatever', as: :doc) }.to \
+        raise_error(ArgumentError, /Unable to join/)
+    end
+  end
+
+  context 'modes' do
+    subject { Profile.unscoped }
+
+    it 'writes a left join against a true condition' do
+      expect(subject.cross_join(snippets, as: :doc, mode: :left).to_sql).to \
+        eql('SELECT "profiles".* FROM "profiles" LEFT OUTER JOIN UNNEST("profiles"."snippets") "doc" ON TRUE')
+    end
+
+    it 'raises for a mode postgres cannot combine with a lateral reference' do
+      expect { subject.cross_join(snippets, as: :doc, mode: :right) }.to \
+        raise_error(ArgumentError, /not implemented as a join type/)
+    end
+  end
+
+  context 'rows' do
+    subject { Profile.unscoped }
+
+    it 'turns a list of documents into one array per column' do
+      result = subject.cross_join([{ id: 1, label: 'a' }, { id: 2, label: 'b' }], as: :v)
+      expect(result.to_sql).to \
+        eql('SELECT "profiles".* FROM "profiles" CROSS JOIN UNNEST(ARRAY[1, 2], ARRAY[\'a\', \'b\']) "v"("id", "label")')
+    end
+
+    it 'accepts plain rows when the columns are named' do
+      result = subject.cross_join([[1, 'a']], as: :v, columns: %i[id label])
+      expect(result.to_sql).to \
+        eql('SELECT "profiles".* FROM "profiles" CROSS JOIN UNNEST(ARRAY[1], ARRAY[\'a\']) "v"("id", "label")')
+    end
+
+    it 'reads the documents by name, in any order' do
+      result = subject.cross_join([{ id: 1, label: 'a' }, { label: 'b', id: 2 }], as: :v)
+      expect(result.to_sql).to \
+        eql('SELECT "profiles".* FROM "profiles" CROSS JOIN UNNEST(ARRAY[1, 2], ARRAY[\'a\', \'b\']) "v"("id", "label")')
+    end
+
+    it 'does not care whether the keys are strings or symbols' do
+      result = subject.cross_join([{ 'id' => 1 }], as: :v, columns: %i[id])
+      expect(result.to_sql).to include('UNNEST(ARRAY[1]) "v"("id")')
+    end
+
+    it 'raises when the columns cannot be named' do
+      expect { subject.cross_join([[1, 'a']], as: :v) }.to \
+        raise_error(ArgumentError, /Unable to name the columns/)
+    end
+
+    it 'raises for an empty list' do
+      expect { subject.cross_join([], as: :v) }.to \
+        raise_error(ArgumentError, /empty list/)
+    end
+
+    it 'multiplies the rows of the query' do
+      Profile.create!(name: 'one')
+      Profile.create!(name: 'two')
+
+      expect(subject.cross_join([{ n: 1 }, { n: 2 }, { n: 3 }], as: :v).count).to be_eql(6)
+    end
+
+    it 'keeps the values typed' do
+      Profile.create!(name: 'one')
+      result = subject.cross_join([{ n: 10 }], as: :v).pluck(Arel.sql('"v"."n"'))
+
+      expect(result).to be_eql([10])
+    end
+  end
+
+  context 'a relation' do
+    subject { Profile.unscoped }
+
+    it 'is written as a lateral subquery' do
+      other = Profile.select(:name).limit(1)
+      expect(subject.cross_join(other, as: :other, columns: %i[name]).to_sql).to \
+        include('CROSS JOIN LATERAL (SELECT "profiles"."name" FROM "profiles" LIMIT 1) "other"("name")')
+    end
+
+    it 'keeps the bindings of both queries apart' do
+      Profile.create!(name: 'aaa')
+      Profile.create!(name: 'bbb')
+
+      other = Profile.where(name: 'aaa').select(:name).limit(1)
+      result = subject.where(name: 'bbb').cross_join(other, as: :other, columns: %i[name])
+
+      expect(result.pluck(:name, Arel.sql('"other"."name"'))).to be_eql([%w[bbb aaa]])
+    end
+  end
+
+  context 'with_ordinality' do
+    subject { Profile.unscoped }
+
+    it 'uses the configured name' do
+      expect(subject.cross_join(snippets, as: :doc, columns: %i[value], with_ordinality: true).to_sql).to \
+        eql('SELECT "profiles".* FROM "profiles" CROSS JOIN UNNEST("profiles"."snippets")' \
+          ' WITH ORDINALITY "doc"("value", "ordinality")')
+    end
+
+    it 'accepts a name of its own' do
+      expect(subject.cross_join(snippets, as: :doc, columns: %i[value], with_ordinality: :idx).to_sql).to \
+        eql('SELECT "profiles".* FROM "profiles" CROSS JOIN UNNEST("profiles"."snippets")' \
+          ' WITH ORDINALITY "doc"("value", "idx")')
+    end
+
+    it 'leaves the list out when the columns are unknown' do
+      result = subject.cross_join(snippets, as: :doc, with_ordinality: true).to_sql
+      expect(result).to end_with('WITH ORDINALITY "doc"')
+    end
+
+    it 'refuses a name of its own when the columns are unknown' do
+      expect { subject.cross_join(snippets, as: :doc, with_ordinality: :idx) }.to \
+        raise_error(ArgumentError, /columns of the source are unknown/)
+    end
+
+    it 'counts from one, in the order of the list' do
+      Profile.create!(name: 'one')
+      result = subject.cross_join([{ n: 'a' }, { n: 'b' }, { n: 'c' }], as: :v, with_ordinality: true)
+
+      expect(result.pluck(Arel.sql('"v"."ordinality"'))).to be_eql([1, 2, 3])
+    end
+  end
+
+  context 'scoping' do
+    subject { Profile.unscoped.cross_join(snippets, as: :doc) }
+
+    it 'is removed by unscope' do
+      expect(subject.unscope(:cross_joins).to_sql).to eql('SELECT "profiles".* FROM "profiles"')
+    end
+
+    it 'is removed by except' do
+      expect(subject.except(:cross_joins).to_sql).to eql('SELECT "profiles".* FROM "profiles"')
+    end
+
+    it 'is carried over by merge' do
+      expect(Profile.all.merge(subject).to_sql).to include('CROSS JOIN UNNEST')
+    end
+
+    it 'is not removed by except(:joins)' do
+      expect(subject.except(:joins).to_sql).to include('CROSS JOIN UNNEST')
+    end
+  end
+end

data/spec/tests/distinct_on_spec.rb

@@ -39,6 +39,11 @@ RSpec.describe 'DistinctOn' do
         eql('SELECT DISTINCT ON ( "authors"."name", "authors"."age" ) "posts".* FROM "posts"')
     end
 
+    it 'is able to do with a part of a column' do
+      expect(Profile.distinct_on(settings: :theme).to_sql).to \
+        eql(%{SELECT DISTINCT ON ( ("profiles"."settings" #>> ARRAY['theme']) ) "profiles".* FROM "profiles"})
+    end
+
     it 'raises with invalid relation' do
       expect { subject.distinct_on(supervisors: :name).to_sql }.to \
         raise_error(ArgumentError, /Relation for/)

data/spec/tests/enum_set_spec.rb

@@ -227,6 +227,10 @@ RSpec.describe 'Enum' do
         expect(subject.serialize(enum.B | enum.C)).to be_eql('{B,C}')
         expect(subject.serialize(3)).to be_eql('{A,B}')
       end
+
+      it 'keeps an invalid value for the database to reject' do
+        expect(subject.serialize(%w[A E])).to be_eql('{A,E}')
+      end
     end
 
     context 'on cast' do

data/spec/tests/enum_spec.rb

@@ -98,6 +98,13 @@ RSpec.describe 'Enum' do
       expect(subject.values).to be_eql(values)
     end
 
+    it 'loads the values without a permanent connection' do
+      expect(ActiveRecord::Base).not_to receive(:connection)
+
+      subject.remove_instance_variable(:@values) if subject.instance_variable_defined?(:@values)
+      expect(subject.values).to be_eql(values)
+    end
+
     it 'can return a sample value' do
       expect(Enum).to respond_to(:sample)
       expect(Enum::ContentStatus).to respond_to(:sample)
@@ -291,8 +298,13 @@ RSpec.describe 'Enum' do
     context 'on serialize' do
       it 'returns nil' do
         expect(subject.serialize(nil)).to be_nil
-        expect(subject.serialize('test')).to be_nil
-        expect(subject.serialize(15)).to be_nil
+      end
+
+      it 'keeps an invalid value for the database to reject' do
+        expect(subject.serialize('test')).to be_eql('test')
+        expect(subject.serialize(15)).to be_eql('15')
+        expect { User.create!(name: 'Rick', role: 'bogus') }
+          .to raise_error(ActiveRecord::StatementInvalid, /invalid input value for enum/)
       end
 
       it 'returns as string' do
@@ -306,12 +318,16 @@ RSpec.describe 'Enum' do
         expect(subject.cast(nil)).to be_nil
       end
 
-      it 'accepts invalid values as nil' do
+      it 'accepts blank values as nil' do
         expect(subject.cast(false)).to be_nil
-        expect(subject.cast(true)).to be_nil
         expect(subject.cast([])).to be_nil
       end
 
+      it 'keeps invalid values for the database to reject' do
+        expect(subject.cast(true)).to be(true)
+        expect(subject.cast('bogus')).to be_eql('bogus')
+      end
+
       it 'accepts string' do
         value = subject.cast('created')
         expect(value).to be_a(enum)

data/spec/tests/geometric_builder_spec.rb

@@ -73,13 +73,23 @@ RSpec.describe 'Geometries' do
         expect(config_class).to receive(:new).with(1.0, 2.0, 3.0, 4.0).and_return(1)
         expect(instance.cast('1.0, 2.0, 3.0, 4.0')).to be_eql(1)
 
-        expect { instance.cast(['6 6 6']) }.to raise_error(RuntimeError, 'Invalid format')
+        expect(config_class).to receive(:new).with(6.0).and_return(9)
+        expect(instance.cast(['6 6 6'])).to be_eql(9)
+      end
+
+      it 'does not change the given value' do
+        value = '(1, 2, 3, 4)'
+        expect(config_class).to receive(:new).with(1, 2, 3, 4).twice.and_return(1)
+        expect(instance.cast(value)).to be_eql(1)
+        expect(value).to be_eql('(1, 2, 3, 4)')
+        expect(instance.cast(value.freeze)).to be_eql(1)
       end
 
       it 'accepts hash values' do
         expect(instance.cast({})).to be_nil
 
-        expect { instance.cast({ 'a' => 1, 'b' => 2 }) }.to raise_error(RuntimeError, 'Invalid format')
+        expect(config_class).to receive(:new).with(1, 2).and_return(9)
+        expect(instance.cast({ 'a' => 1, 'b' => 2 })).to be_eql(9)
 
         expect(config_class).to receive(:new).with(1, 2, 3, 4).and_return(4)
         expect(instance.cast({ 'a' => 1, 'b' => 2 , 'c' => 3, 'd' => 4})).to be_eql(4)
@@ -103,7 +113,8 @@ RSpec.describe 'Geometries' do
 
         expect(instance.cast([])).to be_nil
 
-        expect { instance.cast([6, 5, 4]) }.to raise_error(RuntimeError, 'Invalid format')
+        expect(config_class).to receive(:new).with(6, 5, 4).and_return(9)
+        expect(instance.cast([6, 5, 4])).to be_eql(9)
       end
     end
 
@@ -121,13 +132,13 @@ RSpec.describe 'Geometries' do
       end
 
       it 'accepts hash value' do
-        expect { instance.cast({a: 1, b: 2, c: 3}) }.to raise_error(RuntimeError, 'Invalid format')
+        expect(instance.serialize({a: 1, b: 2, c: 3})).to be_eql('(1, 2, <3, {}>)')
         expect(instance.serialize({a: 1, b: 2, c: 3, d: 4})).to be_eql('(1, 2, <3, {4}>)')
         expect(instance.serialize({a: 1, b: 2, c: 3, d: 4, e: 5, f: 6})).to be_eql('(1, 2, <3, {4}>)')
       end
 
       it 'accepts array value' do
-        expect { instance.serialize([6, 5, 4]) }.to raise_error(RuntimeError, 'Invalid format')
+        expect(instance.serialize([6, 5, 4])).to be_eql('(6, 5, <4, {}>)')
         expect(instance.serialize([1, 2, 3, 4])).to be_eql('(1, 2, <3, {4}>)')
         expect(instance.serialize([5, 4, 3, 2, 1, 0])).to be_eql('(5, 4, <3, {2}>)')
       end

data/spec/tests/has_many_spec.rb

@@ -204,7 +204,8 @@ RSpec.describe 'HasMany' do
     end
 
     context 'with query constraint' do
-      let(:activity) { Activity.create! }
+      # why: Rails 8.1.4+ skips preloading for owners whose composite key has a nil part
+      let(:activity) { Activity.create!(author: FactoryBot.create(:author)) }
 
       before do
         skip('Only Rails 7.1 onwards') unless Post.respond_to?(:query_constraints)

data/spec/tests/interval_spec.rb

@@ -98,6 +98,12 @@ RSpec.describe 'Interval' do
         expect(value).to eq(reference)
       end
 
+      it 'does not change the given array' do
+        value = [1, nil, 2]
+        subject.cast(value)
+        expect(value).to be_eql([1, nil, 2])
+      end
+
       it 'accepts array with Y-M-D H:M:S format' do
         value = subject.cast([1, 2, 3, 4, 5, 6])
         expect(value).to be_a(ActiveSupport::Duration)