torque-postgresql 3.4.1 → 4.0.0

data/spec/tests/relation_spec.rb

@@ -54,4 +54,233 @@ RSpec.describe 'Relation', type: :helper do
     end
   end
 
+  context 'on joining series' do
+    let(:source) { Video.all }
+
+    it 'works' do
+      list = create_list(:video, 5)[1..4]
+      range = list.first.id..list.last.id
+      expect(source.join_series(range, with: :id).to_a).to eq(list)
+      expect(source.join_series(range, with: :id, step: 3).to_a).to eq([list.first, list.last])
+    end
+
+    it 'produces the right SQL' do
+      sql = 'SELECT "videos".* FROM "videos"'
+      sql += ' INNER JOIN GENERATE_SERIES(1::integer, 10::integer)'
+      sql += ' AS series ON "series" = "videos"."id"'
+      expect(source.join_series(1..10, with: :id).to_sql).to eq(sql)
+    end
+
+    it 'can be renamed' do
+      sql = 'SELECT "videos".* FROM "videos"'
+      sql += ' INNER JOIN GENERATE_SERIES(1::integer, 10::integer)'
+      sql += ' AS seq ON "seq" = "videos"."id"'
+      expect(source.join_series(1..10, with: :id, as: :seq).to_sql).to eq(sql)
+    end
+
+    it 'can contain the step' do
+      sql = 'SELECT "videos".* FROM "videos"'
+      sql += ' INNER JOIN GENERATE_SERIES(1::integer, 10::integer, 2::integer)'
+      sql += ' AS series ON "series" = "videos"."id"'
+      expect(source.join_series(1..10, with: :id, step: 2).to_sql).to eq(sql)
+    end
+
+    it 'works with float values' do
+      sql = 'SELECT "videos".* FROM "videos"'
+      sql += ' INNER JOIN GENERATE_SERIES(1.0::numeric, 10.0::numeric, 0.5::numeric)'
+      sql += ' AS series ON "series" = "videos"."id"'
+      expect(source.join_series(1.0..10.0, with: :id, step: 0.5).to_sql).to eq(sql)
+    end
+
+    it 'works with time values' do
+      sql = 'SELECT "videos".* FROM "videos"'
+      sql += ' INNER JOIN GENERATE_SERIES('
+      sql += "'2025-01-01 00:00:00'::timestamp, '2025-01-01 01:00:00'::timestamp"
+      sql += ", 'PT1M'::interval"
+      sql += ') AS series ON "series" = "videos"."created_at"'
+      range = (Time.utc(2025, 1, 1, 0)..Time.utc(2025, 1, 1, 1))
+      expect(source.join_series(range, with: :created_at, step: 1.minute).to_sql).to eq(sql)
+    end
+
+    it 'works with date values' do
+      sql = 'SELECT "videos".* FROM "videos"'
+      sql += ' INNER JOIN GENERATE_SERIES('
+      sql += "'2025-01-01 00:00:00'::timestamp, '2025-01-02 00:00:00'::timestamp"
+      sql += ", 'P1D'::interval"
+      sql += ') AS series ON "series" = "videos"."created_at"'
+      range = (Date.new(2025, 1, 1)..Date.new(2025, 1, 2))
+      expect(source.join_series(range, with: :created_at, step: 1.day).to_sql).to eq(sql)
+    end
+
+    it 'works with time with zones values' do
+      sql = 'SELECT "videos".* FROM "videos"'
+      sql += ' INNER JOIN GENERATE_SERIES('
+      sql += "'2025-01-01 00:00:00'::timestamptz, '2025-01-01 01:00:00'::timestamptz"
+      sql += ", 'PT1M'::interval"
+      sql += ') AS series ON "series" = "videos"."id"'
+      left = ActiveSupport::TimeZone['UTC'].local(2025, 1, 1, 0)
+      right = ActiveSupport::TimeZone['UTC'].local(2025, 1, 1, 1)
+      expect(source.join_series(left..right, with: :id, step: 1.minute).to_sql).to eq(sql)
+    end
+
+    it 'can provide the additional time zone value' do
+      sql = 'SELECT "videos".* FROM "videos"'
+      sql += ' INNER JOIN GENERATE_SERIES('
+      sql += "'2025-01-01 00:00:00'::timestamptz, '2025-01-01 01:00:00'::timestamptz"
+      sql += ", 'PT1M'::interval, 'UTC'::text"
+      sql += ') AS series ON "series" = "videos"."id"'
+      left = ActiveSupport::TimeZone['UTC'].local(2025, 1, 1, 0)
+      right = ActiveSupport::TimeZone['UTC'].local(2025, 1, 1, 1)
+
+      query = source.join_series(left..right, with: :id, step: 1.minute, time_zone: 'UTC')
+      expect(query.to_sql).to eq(sql)
+    end
+
+    it 'can use other types of joins' do
+      sql = ' LEFT OUTER JOIN GENERATE_SERIES(1::integer, 10::integer)'
+      expect(source.join_series(1..10, with: :id, mode: :left).to_sql).to include(sql)
+
+      sql = ' RIGHT OUTER JOIN GENERATE_SERIES(1::integer, 10::integer)'
+      expect(source.join_series(1..10, with: :id, mode: :right).to_sql).to include(sql)
+
+      sql = ' FULL OUTER JOIN GENERATE_SERIES(1::integer, 10::integer)'
+      expect(source.join_series(1..10, with: :id, mode: :full).to_sql).to include(sql)
+    end
+
+    it 'supports a complex way of joining' do
+      query = source.join_series(1..10) do |series, table|
+        table['id'].lteq(series)
+      end
+
+      sql = 'SELECT "videos".* FROM "videos"'
+      sql += ' INNER JOIN GENERATE_SERIES(1::integer, 10::integer)'
+      sql += ' AS series ON "videos"."id" <= "series"'
+      expect(query.to_sql).to eq(sql)
+    end
+
+    it 'properly binds all provided values' do
+      query = source.join_series(1..10, with: :id, step: 2)
+      sql, binds = get_query_with_binds { query.load }
+
+      expect(sql).to include('GENERATE_SERIES($1::integer, $2::integer, $3::integer)')
+      expect(binds.map(&:value)).to eq([1, 10, 2])
+    end
+
+    context 'on errors' do
+      it 'does not support non-range values' do
+        expect do
+          source.join_series(1, with: :id)
+        end.to raise_error(ArgumentError, /Range/)
+      end
+
+      it 'does not support beginless ranges' do
+        expect do
+          source.join_series(..10, with: :id)
+        end.to raise_error(ArgumentError, /Beginless/)
+      end
+
+      it 'does not support endless ranges' do
+        expect do
+          source.join_series(1.., with: :id)
+        end.to raise_error(ArgumentError, /Endless/)
+      end
+
+      it 'requires a step when using non-numeric ranges' do
+        range = Date.new(2025, 1, 1)..Date.new(2025, 1, 10)
+        expect do
+          source.join_series(range, with: :id)
+        end.to raise_error(ArgumentError, /:step/)
+      end
+
+      it 'has strict type of join support' do
+        expect do
+          source.join_series(1..10, with: :id, mode: :cross)
+        end.to raise_error(ArgumentError, /join type/)
+      end
+
+      it 'requires a :with keyword' do
+        expect do
+          source.join_series(1..10)
+        end.to raise_error(ArgumentError, /:with/)
+      end
+
+      it 'does not support unexpected values' do
+        expect do
+          source.join_series(1..10, step: :other)
+        end.to raise_error(ArgumentError, /value type/)
+      end
+    end
+  end
+
+  context 'on buckets' 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 '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)]
+      query = source.buckets(:age, 0..50, count: 5).count
+
+      expect(query).to be_a(Hash)
+      expect(query.keys).to match_array([0...10, 10...20])
+      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
+  end
+
 end

data/spec/tests/schema_spec.rb

@@ -2,13 +2,7 @@ require 'spec_helper'
 
 RSpec.describe 'Schema' do
   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 }
 
   before do
     connection.instance_variable_set(:@schemas_blacklist, nil)
@@ -16,7 +10,7 @@ RSpec.describe 'Schema' do
   end
 
   context 'on migration' do
-    it 'can check for existance' do
+    it 'can check for existence' do
       expect(connection.schema_exists?(:information_schema)).to be_falsey
       expect(connection.schema_exists?(:information_schema, filtered: false)).to be_truthy
     end
@@ -51,7 +45,10 @@ RSpec.describe 'Schema' do
     context 'reverting' do
       let(:migration) { ActiveRecord::Migration::Current.new('Testing') }
 
-      before { connection.create_schema(:legacy) }
+      before do
+        allow_any_instance_of(ActiveRecord::Migration).to receive(:puts) # Disable messages
+        connection.create_schema(:legacy)
+      end
 
       it 'reverts the creation of a schema' do
         expect(connection.schema_exists?(:legacy, filtered: false)).to be_truthy

data/spec/tests/table_inheritance_spec.rb

@@ -73,14 +73,7 @@ RSpec.describe 'TableInheritance' do
   end
 
   context 'on schema' do
-    let(:source) do
-      if Torque::PostgreSQL::AR720
-        ActiveRecord::Base.connection_pool
-      else
-        ActiveRecord::Base.connection
-      end
-    end
-
+    let(:source) { ActiveRecord::Base.connection_pool }
     let(:dump_result) do
       ActiveRecord::SchemaDumper.dump(source, (dump_result = StringIO.new))
       dump_result.string
@@ -89,24 +82,24 @@ RSpec.describe 'TableInheritance' do
     it 'dumps single inheritance with body' do
       parts = '"activity_books"'
       parts << ', id: false'
-      parts << ', force: :cascade'
       parts << ', inherits: "activities"'
+      parts << ', force: :cascade'
       expect(dump_result).to match(/create_table #{parts} do /)
     end
 
     it 'dumps single inheritance without body' do
       parts = '"activity_post_samples"'
       parts << ', id: false'
-      parts << ', force: :cascade'
       parts << ', inherits: "activity_posts"'
+      parts << ', force: :cascade'
       expect(dump_result).to match(/create_table #{parts}(?! do \|t\|)/)
     end
 
     it 'dumps multiple inheritance' do
       parts = '"activity_posts"'
       parts << ', id: false'
-      parts << ', force: :cascade'
       parts << ', inherits: (\["images", "activities"\]|\["activities", "images"\])'
+      parts << ', force: :cascade'
       expect(dump_result).to match(/create_table #{parts}/)
     end
   end
@@ -115,12 +108,9 @@ RSpec.describe 'TableInheritance' do
     let(:schema_cache) { ActiveRecord::Base.connection.schema_cache }
     let(:schema_cache_reflection) { schema_cache.instance_variable_get(:@schema_reflection) }
     let(:new_schema_cache) { schema_cache_reflection.send(:cache, schema_cache_source) }
+    let(:schema_cache_source) { schema_cache.instance_variable_get(:@pool) }
 
-    let(:schema_cache_source) do
-      schema_cache.instance_variable_get(Torque::PostgreSQL::AR720 ? :@pool : :@connection)
-    end
-
-    subject { Torque::PostgreSQL::AR710 ? new_schema_cache : schema_cache }
+    subject { new_schema_cache }
 
     it 'correctly defines the associations' do
       scenario = {
@@ -148,8 +138,8 @@ RSpec.describe 'TableInheritance' do
     end
 
     context 'on looking up models' do
-      let(:prepare_arguments) { Torque::PostgreSQL::AR710 ? [schema_cache_source] : nil }
-      let(:prepare_method) { Torque::PostgreSQL::AR720 ? :add_all : :prepare_data_sources }
+      let(:prepare_arguments) { [schema_cache_source] }
+      let(:prepare_method) { :add_all }
 
       after(:all) do
         schema_cache = ActiveRecord::Base.connection.schema_cache
@@ -375,28 +365,37 @@ RSpec.describe 'TableInheritance' do
         ActivityPost::Sample.create(title: 'Activity post')
         records = base.cast_records.order(:id).load.to_a
 
-        expect(records[0].class).to eql(Activity)
-        expect(records[1].class).to eql(ActivityBook)
-        expect(records[2].class).to eql(ActivityPost)
-        expect(records[3].class).to eql(ActivityPost::Sample)
+        expect(records[0]).to be_instance_of(Activity)
+        expect(records[1]).to be_instance_of(ActivityBook)
+        expect(records[2]).to be_instance_of(ActivityPost)
+        expect(records[3]).to be_instance_of(ActivityPost::Sample)
       end
 
       it 'does not cast unnecessary records' do
         ActivityPost.create(title: 'Activity post')
         records = base.cast_records(ActivityBook).order(:id).load.to_a
 
-        expect(records[0].class).to eql(Activity)
-        expect(records[1].class).to eql(ActivityBook)
-        expect(records[2].class).to eql(Activity)
+        expect(records[0]).to be_instance_of(Activity)
+        expect(records[1]).to be_instance_of(ActivityBook)
+        expect(records[2]).to be_instance_of(Activity)
       end
 
-      it 'correctly identify same name attributes' do
+      it 'correctly identifies same name attributes' do
         ActivityPost.create(title: 'Activity post', url: 'posturl1')
         records = base.cast_records.order(:id).load.to_a
 
         expect(records[1].url).to eql('bookurl1')
         expect(records[2].url).to eql('posturl1')
       end
+
+      # TODO: Maybe in the future
+      xit 'does not make internal inheritance attributes accessible' do
+        record = base.cast_records.order(:id).load.last
+
+        expect(record).to be_instance_of(ActivityBook)
+        expect(record).not_to respond_to(:_record_class)
+        expect(record).not_to respond_to(:_auto_cast)
+      end
     end
 
     context 'cast record' do