ibm_db 5.2.0-x86-mingw32 → 5.4.0-x86-mingw32

data/test/cases/adapters/postgresql/network_test.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 class PostgresqlNetworkTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
@@ -7,75 +9,75 @@ class PostgresqlNetworkTest < ActiveRecord::PostgreSQLTestCase
 
   setup do
     @connection = ActiveRecord::Base.connection
-    @connection.create_table('postgresql_network_addresses', force: true) do |t|
-      t.inet 'inet_address', default: "192.168.1.1"
-      t.cidr 'cidr_address', default: "192.168.1.0/24"
-      t.macaddr 'mac_address', default: "ff:ff:ff:ff:ff:ff"
+    @connection.create_table("postgresql_network_addresses", force: true) do |t|
+      t.inet "inet_address", default: "192.168.1.1"
+      t.cidr "cidr_address", default: "192.168.1.0/24"
+      t.macaddr "mac_address", default: "ff:ff:ff:ff:ff:ff"
     end
   end
 
   teardown do
-    @connection.drop_table 'postgresql_network_addresses', if_exists: true
+    @connection.drop_table "postgresql_network_addresses", if_exists: true
   end
 
   def test_cidr_column
     column = PostgresqlNetworkAddress.columns_hash["cidr_address"]
     assert_equal :cidr, column.type
     assert_equal "cidr", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlNetworkAddress.type_for_attribute("cidr_address")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_inet_column
     column = PostgresqlNetworkAddress.columns_hash["inet_address"]
     assert_equal :inet, column.type
     assert_equal "inet", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlNetworkAddress.type_for_attribute("inet_address")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_macaddr_column
     column = PostgresqlNetworkAddress.columns_hash["mac_address"]
     assert_equal :macaddr, column.type
     assert_equal "macaddr", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlNetworkAddress.type_for_attribute("mac_address")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_network_types
-    PostgresqlNetworkAddress.create(cidr_address: '192.168.0.0/24',
-                                    inet_address: '172.16.1.254/32',
-                                    mac_address: '01:23:45:67:89:0a')
+    PostgresqlNetworkAddress.create(cidr_address: "192.168.0.0/24",
+                                    inet_address: "172.16.1.254/32",
+                                    mac_address: "01:23:45:67:89:0a")
 
     address = PostgresqlNetworkAddress.first
-    assert_equal IPAddr.new('192.168.0.0/24'), address.cidr_address
-    assert_equal IPAddr.new('172.16.1.254'), address.inet_address
-    assert_equal '01:23:45:67:89:0a', address.mac_address
+    assert_equal IPAddr.new("192.168.0.0/24"), address.cidr_address
+    assert_equal IPAddr.new("172.16.1.254"), address.inet_address
+    assert_equal "01:23:45:67:89:0a", address.mac_address
 
-    address.cidr_address = '10.1.2.3/32'
-    address.inet_address = '10.0.0.0/8'
-    address.mac_address = 'bc:de:f0:12:34:56'
+    address.cidr_address = "10.1.2.3/32"
+    address.inet_address = "10.0.0.0/8"
+    address.mac_address = "bc:de:f0:12:34:56"
 
     address.save!
     assert address.reload
-    assert_equal IPAddr.new('10.1.2.3/32'), address.cidr_address
-    assert_equal IPAddr.new('10.0.0.0/8'), address.inet_address
-    assert_equal 'bc:de:f0:12:34:56', address.mac_address
+    assert_equal IPAddr.new("10.1.2.3/32"), address.cidr_address
+    assert_equal IPAddr.new("10.0.0.0/8"), address.inet_address
+    assert_equal "bc:de:f0:12:34:56", address.mac_address
   end
 
   def test_invalid_network_address
-    invalid_address = PostgresqlNetworkAddress.new(cidr_address: 'invalid addr',
-                                                   inet_address: 'invalid addr')
+    invalid_address = PostgresqlNetworkAddress.new(cidr_address: "invalid addr",
+                                                   inet_address: "invalid addr")
     assert_nil invalid_address.cidr_address
     assert_nil invalid_address.inet_address
-    assert_equal 'invalid addr', invalid_address.cidr_address_before_type_cast
-    assert_equal 'invalid addr', invalid_address.inet_address_before_type_cast
+    assert_equal "invalid addr", invalid_address.cidr_address_before_type_cast
+    assert_equal "invalid addr", invalid_address.inet_address_before_type_cast
     assert invalid_address.save
 
     invalid_address.reload
@@ -91,4 +93,10 @@ class PostgresqlNetworkTest < ActiveRecord::PostgreSQLTestCase
     assert_match %r{t\.cidr\s+"cidr_address",\s+default: "192\.168\.1\.0/24"}, output
     assert_match %r{t\.macaddr\s+"mac_address",\s+default: "ff:ff:ff:ff:ff:ff"}, output
   end
+
+  def test_mac_address_change_case_does_not_mark_dirty
+    model = PostgresqlNetworkAddress.create(mac_address: "Ab:Cd:Ef:01:02:03")
+    model.mac_address = model.mac_address.swapcase
+    assert_not_predicate model, :changed?
+  end
 end

data/test/cases/adapters/postgresql/numbers_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class PostgresqlNumberTest < ActiveRecord::PostgreSQLTestCase
@@ -5,14 +7,14 @@ class PostgresqlNumberTest < ActiveRecord::PostgreSQLTestCase
 
   setup do
     @connection = ActiveRecord::Base.connection
-    @connection.create_table('postgresql_numbers', force: true) do |t|
-      t.column 'single', 'REAL'
-      t.column 'double', 'DOUBLE PRECISION'
+    @connection.create_table("postgresql_numbers", force: true) do |t|
+      t.column "single", "REAL"
+      t.column "double", "DOUBLE PRECISION"
     end
   end
 
   teardown do
-    @connection.drop_table 'postgresql_numbers', if_exists: true
+    @connection.drop_table "postgresql_numbers", if_exists: true
   end
 
   def test_data_type
@@ -31,7 +33,7 @@ class PostgresqlNumberTest < ActiveRecord::PostgreSQLTestCase
     assert_equal 123456.789, first.double
     assert_equal(-::Float::INFINITY, second.single)
     assert_equal ::Float::INFINITY, second.double
-    assert_send [third.double, :nan?]
+    assert third.double.nan?, "Expected #{third.double} to be NaN"
   end
 
   def test_update

data/test/cases/adapters/postgresql/optimizer_hints_test.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+
+if supports_optimizer_hints?
+  class PostgresqlOptimzerHintsTest < ActiveRecord::PostgreSQLTestCase
+    fixtures :posts
+
+    def setup
+      enable_extension!("pg_hint_plan", ActiveRecord::Base.connection)
+    end
+
+    def test_optimizer_hints
+      assert_sql(%r{\ASELECT /\*\+ SeqScan\(posts\) \*/}) do
+        posts = Post.optimizer_hints("SeqScan(posts)")
+        posts = posts.select(:id).where(author_id: [0, 1])
+        assert_includes posts.explain, "Seq Scan on posts"
+      end
+    end
+
+    def test_optimizer_hints_with_count_subquery
+      assert_sql(%r{\ASELECT /\*\+ SeqScan\(posts\) \*/}) do
+        posts = Post.optimizer_hints("SeqScan(posts)")
+        posts = posts.select(:id).where(author_id: [0, 1]).limit(5)
+        assert_equal 5, posts.count
+      end
+    end
+
+    def test_optimizer_hints_is_sanitized
+      assert_sql(%r{\ASELECT /\*\+ SeqScan\(posts\) \*/}) do
+        posts = Post.optimizer_hints("/*+ SeqScan(posts) */")
+        posts = posts.select(:id).where(author_id: [0, 1])
+        assert_includes posts.explain, "Seq Scan on posts"
+      end
+
+      assert_sql(%r{\ASELECT /\*\+  "posts"\.\*,  \*/}) do
+        posts = Post.optimizer_hints("**// \"posts\".*, //**")
+        posts = posts.select(:id).where(author_id: [0, 1])
+        assert_equal({ "id" => 1 }, posts.first.as_json)
+      end
+    end
+
+    def test_optimizer_hints_with_unscope
+      assert_sql(%r{\ASELECT "posts"\."id"}) do
+        posts = Post.optimizer_hints("/*+ SeqScan(posts) */")
+        posts = posts.select(:id).where(author_id: [0, 1])
+        posts.unscope(:optimizer_hints).load
+      end
+    end
+
+    def test_optimizer_hints_with_or
+      assert_sql(%r{\ASELECT /\*\+ SeqScan\(posts\) \*/}) do
+        Post.optimizer_hints("SeqScan(posts)").or(Post.all).load
+      end
+
+      queries = capture_sql do
+        Post.optimizer_hints("SeqScan(posts)").or(Post.optimizer_hints("IndexScan(posts)")).load
+      end
+      assert_equal 1, queries.length
+      assert_includes queries.first, "/*+ SeqScan(posts) */"
+      assert_not_includes queries.first, "/*+ IndexScan(posts) */"
+
+      queries = capture_sql do
+        Post.all.or(Post.optimizer_hints("IndexScan(posts)")).load
+      end
+      assert_equal 1, queries.length
+      assert_not_includes queries.first, "/*+ IndexScan(posts) */"
+    end
+  end
+end

data/test/cases/adapters/postgresql/partitions_test.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class PostgreSQLPartitionsTest < ActiveRecord::PostgreSQLTestCase
+  def setup
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    @connection.drop_table "partitioned_events", if_exists: true
+  end
+
+  def test_partitions_table_exists
+    skip unless ActiveRecord::Base.connection.database_version >= 100000
+    @connection.create_table :partitioned_events, force: true, id: false,
+      options: "partition by range (issued_at)" do |t|
+      t.timestamp :issued_at
+    end
+    assert @connection.table_exists?("partitioned_events")
+  end
+end

data/test/cases/adapters/postgresql/postgresql_adapter_prevent_writes_test.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/ddl_helper"
+require "support/connection_helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapterPreventWritesTest < ActiveRecord::PostgreSQLTestCase
+      self.use_transactional_tests = false
+      include DdlHelper
+      include ConnectionHelper
+
+      def setup
+        @connection = ActiveRecord::Base.connection
+      end
+
+      def test_errors_when_an_insert_query_is_called_while_preventing_writes
+        with_example_table do
+          assert_raises(ActiveRecord::ReadOnlyError) do
+            ActiveRecord::Base.while_preventing_writes do
+              @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+            end
+          end
+        end
+      end
+
+      def test_errors_when_an_update_query_is_called_while_preventing_writes
+        with_example_table do
+          @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+
+          assert_raises(ActiveRecord::ReadOnlyError) do
+            ActiveRecord::Base.while_preventing_writes do
+              @connection.execute("UPDATE ex SET data = '9989' WHERE data = '138853948594'")
+            end
+          end
+        end
+      end
+
+      def test_errors_when_a_delete_query_is_called_while_preventing_writes
+        with_example_table do
+          @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+
+          assert_raises(ActiveRecord::ReadOnlyError) do
+            ActiveRecord::Base.while_preventing_writes do
+              @connection.execute("DELETE FROM ex where data = '138853948594'")
+            end
+          end
+        end
+      end
+
+      def test_doesnt_error_when_a_select_query_is_called_while_preventing_writes
+        with_example_table do
+          @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+
+          ActiveRecord::Base.while_preventing_writes do
+            assert_equal 1, @connection.execute("SELECT * FROM ex WHERE data = '138853948594'").entries.count
+          end
+        end
+      end
+
+      def test_doesnt_error_when_a_show_query_is_called_while_preventing_writes
+        ActiveRecord::Base.while_preventing_writes do
+          assert_equal 1, @connection.execute("SHOW TIME ZONE").entries.count
+        end
+      end
+
+      def test_doesnt_error_when_a_set_query_is_called_while_preventing_writes
+        ActiveRecord::Base.while_preventing_writes do
+          assert_equal [], @connection.execute("SET standard_conforming_strings = on").entries
+        end
+      end
+
+      def test_doesnt_error_when_a_read_query_with_leading_chars_is_called_while_preventing_writes
+        with_example_table do
+          @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+
+          ActiveRecord::Base.while_preventing_writes do
+            assert_equal 1, @connection.execute("/*action:index*/(\n( SELECT * FROM ex WHERE data = '138853948594' ) )").entries.count
+          end
+        end
+      end
+
+      def test_doesnt_error_when_a_read_query_with_cursors_is_called_while_preventing_writes
+        with_example_table do
+          ActiveRecord::Base.while_preventing_writes do
+            @connection.transaction do
+              assert_equal [], @connection.execute("DECLARE cur_ex CURSOR FOR SELECT * FROM ex").entries
+              assert_equal [], @connection.execute("FETCH cur_ex").entries
+              assert_equal [], @connection.execute("MOVE cur_ex").entries
+              assert_equal [], @connection.execute("CLOSE cur_ex").entries
+            end
+          end
+        end
+      end
+
+      private
+        def with_example_table(definition = "id serial primary key, number integer, data character varying(255)", &block)
+          super(@connection, "ex", definition, &block)
+        end
+    end
+
+    class PostgreSQLAdapterPreventWritesLegacyTest < ActiveRecord::PostgreSQLTestCase
+      self.use_transactional_tests = false
+      include DdlHelper
+      include ConnectionHelper
+
+      def setup
+        @old_value = ActiveRecord::Base.legacy_connection_handling
+        ActiveRecord::Base.legacy_connection_handling = true
+
+        @connection = ActiveRecord::Base.connection
+        @connection_handler = ActiveRecord::Base.connection_handler
+      end
+
+      def teardown
+        ActiveRecord::Base.legacy_connection_handling = @old_value
+      end
+
+      def test_errors_when_an_insert_query_is_called_while_preventing_writes
+        with_example_table do
+          assert_raises(ActiveRecord::ReadOnlyError) do
+            @connection_handler.while_preventing_writes do
+              @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+            end
+          end
+        end
+      end
+
+      def test_errors_when_an_update_query_is_called_while_preventing_writes
+        with_example_table do
+          @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+
+          assert_raises(ActiveRecord::ReadOnlyError) do
+            @connection_handler.while_preventing_writes do
+              @connection.execute("UPDATE ex SET data = '9989' WHERE data = '138853948594'")
+            end
+          end
+        end
+      end
+
+      def test_errors_when_a_delete_query_is_called_while_preventing_writes
+        with_example_table do
+          @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+
+          assert_raises(ActiveRecord::ReadOnlyError) do
+            @connection_handler.while_preventing_writes do
+              @connection.execute("DELETE FROM ex where data = '138853948594'")
+            end
+          end
+        end
+      end
+
+      def test_doesnt_error_when_a_select_query_is_called_while_preventing_writes
+        with_example_table do
+          @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+
+          @connection_handler.while_preventing_writes do
+            assert_equal 1, @connection.execute("SELECT * FROM ex WHERE data = '138853948594'").entries.count
+          end
+        end
+      end
+
+      def test_doesnt_error_when_a_show_query_is_called_while_preventing_writes
+        @connection_handler.while_preventing_writes do
+          assert_equal 1, @connection.execute("SHOW TIME ZONE").entries.count
+        end
+      end
+
+      def test_doesnt_error_when_a_set_query_is_called_while_preventing_writes
+        @connection_handler.while_preventing_writes do
+          assert_equal [], @connection.execute("SET standard_conforming_strings = on").entries
+        end
+      end
+
+      def test_doesnt_error_when_a_read_query_with_leading_chars_is_called_while_preventing_writes
+        with_example_table do
+          @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+
+          @connection_handler.while_preventing_writes do
+            assert_equal 1, @connection.execute("/*action:index*/(\n( SELECT * FROM ex WHERE data = '138853948594' ) )").entries.count
+          end
+        end
+      end
+
+      def test_doesnt_error_when_a_read_query_with_cursors_is_called_while_preventing_writes
+        with_example_table do
+          @connection_handler.while_preventing_writes do
+            @connection.transaction do
+              assert_equal [], @connection.execute("DECLARE cur_ex CURSOR FOR SELECT * FROM ex").entries
+              assert_equal [], @connection.execute("FETCH cur_ex").entries
+              assert_equal [], @connection.execute("MOVE cur_ex").entries
+              assert_equal [], @connection.execute("CLOSE cur_ex").entries
+            end
+          end
+        end
+      end
+
+      private
+        def with_example_table(definition = "id serial primary key, number integer, data character varying(255)", &block)
+          super(@connection, "ex", definition, &block)
+        end
+    end
+  end
+end