torque-postgresql 4.1.0 → 4.1.1

data/spec/tests/arel_spec.rb

@@ -56,9 +56,7 @@ RSpec.describe 'Arel' do
     it 'does not break the change column default value method' do
       connection.add_column(:authors, :enabled, :boolean)
       expect { connection.change_column_default(:authors, :enabled, { from: nil, to: true }) }.not_to raise_error
-      # Rails 8.1 type casts column defaults, so it is no longer a string
-      expected = Torque::PostgreSQL::AR810 ? true : 'true'
-      expect(Author.columns_hash['enabled'].default).to eq(expected)
+      expect(Author.new.enabled).to be(true)
     end
 
     it 'does not break jsonb' do

data/spec/tests/auxiliary_statement_spec.rb

@@ -101,6 +101,18 @@ RSpec.describe 'AuxiliaryStatement' do
       expect(query.send(:bound_attributes).map(&:value_before_type_cast)).to eql([1, 2])
     end
 
+    it 'collects the bound attributes without a permanent connection' do
+      klass.send(:auxiliary_statement, :comments) do |cte|
+        cte.query Comment.where(id: 1)
+        cte.attributes content: :comment_content
+      end
+
+      expect(ActiveRecord::Base).not_to receive(:connection)
+
+      query = subject.where(id: 2).with(:comments)
+      expect(query.send(:bound_attributes).map(&:value_before_type_cast)).to eql([1, 2])
+    end
+
     it 'accepts string as attributes' do
       klass.send(:auxiliary_statement, :comments) do |cte|
         cte.query Comment.all

data/spec/tests/buckets_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+RSpec.describe 'Buckets', type: :helper do
+  context 'on relation' do
+    let(:source) { User.all }
+
+    it 'produces the right query' do
+      query = source.buckets(:age, 0..50, count: 5)
+      sql, binds = get_query_with_binds { query.load }
+
+      expect(sql).to include(<<~SQL.squish)
+        WIDTH_BUCKET("users"."age", $1::numeric, $2::numeric, $3::integer) AS bucket
+      SQL
+      expect(binds.map(&:value)).to eq([0, 50, 5])
+    end
+
+    it 'accepts a part of a column' do
+      Profile.create!(name: 'a', settings: { theme: 'dark' })
+      Profile.create!(name: 'b', settings: { theme: 'light' })
+
+      query = Profile.buckets({ settings: :theme }, %w[dark light])
+      expect(query.to_sql).to include(<<~SQL.squish)
+        WIDTH_BUCKET(("profiles"."settings" #>> ARRAY['theme']), ARRAY['dark', 'light']) AS bucket
+      SQL
+
+      query = Profile.buckets({ settings: :theme }, %w[dark light])
+      expect(query.count).to be_eql('dark' => 1, 'light' => 1)
+    end
+
+    it 'can query records by buckets' do
+      list = [create(:user, age: 5), create(:user, age: 5), create(:user, age: 15)]
+      query = source.buckets(:age, 0..50, count: 5).records
+
+      expect(query).to be_a(Hash)
+      expect(query.keys).to match_array([0...10, 10...20])
+      expect(query[0...10]).to match_array([list[0], list[1]])
+      expect(query[10...20]).to match_array([list[2]])
+    end
+
+    it 'can query buckets of roles' do
+      list = [create(:user, role: :visitor)]
+      list << create(:user, role: :assistant)
+      list << create(:user, role: :manager)
+      query = source.buckets(:role, %w[assistant manager], cast: :roles).records
+
+      expect(query).to be_a(Hash)
+      expect(query.keys).to match_array([nil, 'assistant', 'manager'])
+      expect(query[nil]).to eq([list[0]])
+      expect(query['assistant']).to eq([list[1]])
+      expect(query['manager']).to eq([list[2]])
+    end
+
+    it 'works with calculations' do
+      list = [create(:user, age: 5), create(:user, age: 5), create(:user, age: 15)]
+      list << create(:user, age: nil)
+      query = source.buckets(:age, 0..50, count: 5).count
+
+      expect(query).to be_a(Hash)
+      expect(query.keys).to match_array([nil, 0...10, 10...20])
+      expect(query[nil]).to eq(1)
+      expect(query[0...10]).to eq(2)
+      expect(query[10...20]).to eq(1)
+    end
+
+    it 'works with other types of calculations' do
+      list = [create(:user, age: 5), create(:user, age: 5), create(:user, age: 15)]
+      query = source.buckets(:age, 0..50, count: 5).sum(:age)
+
+      expect(query).to be_a(Hash)
+      expect(query.keys).to match_array([0...10, 10...20])
+      expect(query[0...10]).to eq(10)
+      expect(query[10...20]).to eq(15)
+    end
+
+    it 'work with joins and merge' do
+      list = [create(:user, age: 5), create(:user, age: 5), create(:user, age: 15)]
+      records = [create(:comment, user: list[0], content: 'Hello')]
+      records << create(:comment, user: list[1], content: 'World')
+      records << create(:comment, user: list[2], content: 'Test')
+
+      query = Comment.joins(:user).merge(source.buckets(:age, 0..50, count: 5)).records
+
+      expect(query).to be_a(Hash)
+      expect(query.keys).to match_array([0...10, 10...20])
+      expect(query[0...10]).to match_array([records[0], records[1]])
+      expect(query[10...20]).to match_array([records[2]])
+    end
+
+    context 'with dates' do
+      let(:keys) { 3.times.map { |add| Date.new(2010 + add) } }
+      let(:query) { source.buckets(:created_at, keys, cast: :date) }
+
+      let!(:list) do
+        list = [create(:user, created_at: Date.new(2009, 6, 1))]
+        list << create(:user, created_at: Date.new(2010, 6, 1))
+        list << create(:user, created_at: Date.new(2011, 6, 1))
+        list << create(:user, created_at: Date.new(2011, 12, 31))
+        list << create(:user, created_at: Date.new(2015, 6, 1))
+        list
+      end
+
+      it 'produces the right query' do
+        expect(query.to_sql).to include(<<~SQL.squish)
+          WIDTH_BUCKET("users"."created_at", ARRAY['2010-01-01', '2011-01-01', '2012-01-01']::date[]) AS bucket
+        SQL
+      end
+
+      it 'outputs the right results' do
+        result = query.records
+        expect(result.keys).to match_array([nil, *keys])
+        expect(result[nil]).to eq([list[0]])
+        expect(result[keys[0]]).to eq([list[1]])
+        expect(result[keys[1]]).to match_array([list[2], list[3]])
+        expect(result[keys[2]]).to eq([list[4]])
+      end
+
+      it 'works with count just fine' do
+        expect(query.count).to be_eql(nil => 1, keys[0] => 1, keys[1] => 2, keys[2] => 1)
+      end
+    end
+  end
+end

data/spec/tests/composite_spec.rb

@@ -692,6 +692,22 @@ RSpec.describe 'Composite' do
       expect(Place.where(offices: many.offices).first).to be_eql(many)
     end
 
+    it 'lists whole values on a plain column' do
+      other = Composite::Address.new(street: 'Side', number: 1)
+
+      expect(Place.where(home: [address, other]).to_sql)
+        .to include(%{"places"."home" IN ('("Main",,"9",)'::address, '("Side",,"1",)'::address)})
+      expect(Place.where(home: [address, other]).first).to be_eql(place)
+      expect(Place.where(home: [other]).first).to be_nil
+    end
+
+    it 'loads the columns without a permanent connection' do
+      expect(ActiveRecord::Base).not_to receive(:connection)
+
+      Composite::Address.reset_columns!
+      expect(Composite::Address.new(street: 'Main').street).to be_eql('Main')
+    end
+
     it 'checks each entry of a list of hashes' do
       expect(Place.where(offices: [{ street: 'A' }, { street: 'B' }]).to_sql)
         .to include('EXISTS', 'OR')
@@ -709,6 +725,46 @@ RSpec.describe 'Composite' do
     end
   end
 
+  context 'on ordering and grouping' do
+    let!(:first) { Place.create!(name: 'a', home: { street: 'Main', number: 9 }) }
+    let!(:second) { Place.create!(name: 'b', home: { street: 'Side', number: 1 }) }
+
+    it 'orders by a column' do
+      expect(Place.order(home: { street: :desc }).to_sql)
+        .to include(%{ORDER BY ("places"."home")."street" DESC})
+
+      expect(Place.order(home: { street: :desc }).pluck(:name)).to be_eql(%w[b a])
+      expect(Place.order(home: { number: :asc }).pluck(:name)).to be_eql(%w[b a])
+    end
+
+    it 'orders by the whole value' do
+      expect(Place.order(:home).to_sql).to include(%{ORDER BY "places"."home" ASC})
+      expect(Place.order(:home).pluck(:name)).to be_eql(%w[a b])
+    end
+
+    it 'groups by a column' do
+      expect(Place.group(home: :street).to_sql).to include(%{GROUP BY ("places"."home")."street"})
+      expect(Place.group(home: :street).count).to be_eql('Main' => 1, 'Side' => 1)
+    end
+
+    it 'filters groups with having' do
+      expect(Place.group(:home).having(home: { street: 'Main' }).to_sql)
+        .to include(%{HAVING (("places"."home")."street" = 'Main')})
+
+      expect(Place.group(home: :street).having(home: { street: 'Main' }).count)
+        .to be_eql('Main' => 1)
+    end
+
+    it 'plucks a column' do
+      expect(Place.order(:name).pluck(home: :number)).to be_eql([9, 1])
+    end
+
+    it 'raises when a key is not a column of the composite type' do
+      expect { Place.order(home: { nope: :asc }).to_sql }
+        .to raise_error(ArgumentError, /not a column of the "address"/)
+    end
+  end
+
   context 'on validation' do
     let(:validator) { Torque::PostgreSQL::Validations::NestedValidator }
 
@@ -736,6 +792,17 @@ RSpec.describe 'Composite' do
       expect(Place.new(name: 'Fine', home: { street: 'Main' })).to be_valid
     end
 
+    it 'validates the attributes that are also normalized' do
+      klass = Class.new(Place) do
+        normalizes :home, with: ->(value) { value }
+      end
+
+      place = klass.new(name: 'Broken', home: invalid_address)
+
+      expect(place).to be_invalid
+      expect(place.errors.attribute_names).to include(:home)
+    end
+
     it 'only validates the attributes backed by a composite type' do
       Place.new
 

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)