ibm_db 5.2.0-x86-mingw32 → 5.3.2-x86-mingw32

data/test/cases/pooled_connections_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/project"
 require "timeout"
@@ -7,7 +9,7 @@ class PooledConnectionsTest < ActiveRecord::TestCase
 
   def setup
     @per_test_teardown = []
-    @connection = ActiveRecord::Base.remove_connection
+    @connection = ActiveRecord::Base.remove_connection.configuration_hash
   end
 
   teardown do
@@ -18,36 +20,32 @@ class PooledConnectionsTest < ActiveRecord::TestCase
 
   # Will deadlock due to lack of Monitor timeouts in 1.9
   def checkout_checkin_connections(pool_size, threads)
-    ActiveRecord::Base.establish_connection(@connection.merge({:pool => pool_size, :checkout_timeout => 0.5}))
+    ActiveRecord::Base.establish_connection(@connection.merge(pool: pool_size, checkout_timeout: 0.5))
     @connection_count = 0
     @timed_out = 0
     threads.times do
       Thread.new do
-        begin
-          conn = ActiveRecord::Base.connection_pool.checkout
-          sleep 0.1
-          ActiveRecord::Base.connection_pool.checkin conn
-          @connection_count += 1
-        rescue ActiveRecord::ConnectionTimeoutError
-          @timed_out += 1
-        end
+        conn = ActiveRecord::Base.connection_pool.checkout
+        sleep 0.1
+        ActiveRecord::Base.connection_pool.checkin conn
+        @connection_count += 1
+      rescue ActiveRecord::ConnectionTimeoutError
+        @timed_out += 1
       end.join
     end
   end
 
   def checkout_checkin_connections_loop(pool_size, loops)
-    ActiveRecord::Base.establish_connection(@connection.merge({:pool => pool_size, :checkout_timeout => 0.5}))
+    ActiveRecord::Base.establish_connection(@connection.merge(pool: pool_size, checkout_timeout: 0.5))
     @connection_count = 0
     @timed_out = 0
     loops.times do
-      begin
-        conn = ActiveRecord::Base.connection_pool.checkout
-        ActiveRecord::Base.connection_pool.checkin conn
-        @connection_count += 1
-        ActiveRecord::Base.connection.data_sources
-      rescue ActiveRecord::ConnectionTimeoutError
-        @timed_out += 1
-      end
+      conn = ActiveRecord::Base.connection_pool.checkout
+      ActiveRecord::Base.connection_pool.checkin conn
+      @connection_count += 1
+      ActiveRecord::Base.connection.data_sources
+    rescue ActiveRecord::ConnectionTimeoutError
+      @timed_out += 1
     end
   end
 
@@ -66,16 +64,10 @@ class PooledConnectionsTest < ActiveRecord::TestCase
   end
 
   def test_pooled_connection_remove
-    ActiveRecord::Base.establish_connection(@connection.merge({:pool => 2, :checkout_timeout => 0.5}))
+    ActiveRecord::Base.establish_connection(@connection.merge(pool: 2, checkout_timeout: 0.5))
     old_connection = ActiveRecord::Base.connection
     extra_connection = ActiveRecord::Base.connection_pool.checkout
     ActiveRecord::Base.connection_pool.remove(extra_connection)
     assert_equal ActiveRecord::Base.connection, old_connection
   end
-
-  private
-
-  def add_record(name)
-    ActiveRecord::Base.connection_pool.with_connection { Project.create! :name => name }
-  end
 end unless in_memory_db?

data/test/cases/prepared_statement_status_test.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/course"
+require "models/entrant"
+
+module ActiveRecord
+  class PreparedStatementStatusTest < ActiveRecord::TestCase
+    def test_prepared_statement_status_is_thread_and_instance_specific
+      course_conn = Course.connection
+      entrant_conn = Entrant.connection
+
+      inside = Concurrent::Event.new
+      preventing = Concurrent::Event.new
+      finished = Concurrent::Event.new
+
+      assert_not_same course_conn, entrant_conn
+
+      if ActiveRecord::Base.connection.prepared_statements
+        t1 = Thread.new do
+          course_conn.unprepared_statement do
+            inside.set
+            preventing.wait
+            assert_not course_conn.prepared_statements
+            assert entrant_conn.prepared_statements
+            finished.set
+          end
+        end
+
+        t2 = Thread.new do
+          entrant_conn.unprepared_statement do
+            inside.wait
+            assert course_conn.prepared_statements
+            assert_not entrant_conn.prepared_statements
+            preventing.set
+            finished.wait
+          end
+        end
+
+        t1.join
+        t2.join
+      else
+        assert_not course_conn.prepared_statements
+        assert_not entrant_conn.prepared_statements
+      end
+    end
+  end
+end

data/test/cases/primary_keys_test.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'support/schema_dumping_helper'
-require 'models/topic'
-require 'models/reply'
-require 'models/subscriber'
-require 'models/movie'
-require 'models/keyboard'
-require 'models/mixed_case_monkey'
-require 'models/dashboard'
-require 'models/non_primary_key'
+require "support/schema_dumping_helper"
+require "models/topic"
+require "models/reply"
+require "models/subscriber"
+require "models/movie"
+require "models/keyboard"
+require "models/mixed_case_monkey"
+require "models/dashboard"
+require "models/non_primary_key"
 
 class PrimaryKeysTest < ActiveRecord::TestCase
   fixtures :topics, :subscribers, :movies, :mixed_case_monkeys
@@ -46,7 +48,7 @@ class PrimaryKeysTest < ActiveRecord::TestCase
     topic = Topic.new
     topic.title = "New Topic"
     assert_nil topic.id
-    assert_nothing_raised { topic.save! }
+    topic.save!
     id = topic.id
 
     topicReloaded = Topic.find(id)
@@ -55,22 +57,35 @@ class PrimaryKeysTest < ActiveRecord::TestCase
 
   def test_customized_primary_key_auto_assigns_on_save
     Keyboard.delete_all
-    keyboard = Keyboard.new(:name => 'HHKB')
-    assert_nothing_raised { keyboard.save! }
-    assert_equal keyboard.id, Keyboard.find_by_name('HHKB').id
+    keyboard = Keyboard.new(name: "HHKB")
+    keyboard.save!
+    assert_equal keyboard.id, Keyboard.find_by_name("HHKB").id
   end
 
   def test_customized_primary_key_can_be_get_before_saving
     keyboard = Keyboard.new
     assert_nil keyboard.id
-    assert_nothing_raised { assert_nil keyboard.key_number }
+    assert_nil keyboard.key_number
   end
 
   def test_customized_string_primary_key_settable_before_save
     subscriber = Subscriber.new
-    assert_nothing_raised { subscriber.id = 'webster123' }
-    assert_equal 'webster123', subscriber.id
-    assert_equal 'webster123', subscriber.nick
+    subscriber.id = "webster123"
+    assert_equal "webster123", subscriber.id
+    assert_equal "webster123", subscriber.nick
+  end
+
+  def test_update_with_non_primary_key_id_column
+    subscriber = Subscriber.first
+    subscriber.update(update_count: 1)
+    subscriber.reload
+    assert_equal 1, subscriber.update_count
+  end
+
+  def test_update_columns_with_non_primary_key_id_column
+    subscriber = Subscriber.first
+    subscriber.update_columns(id: 1)
+    assert_not_equal 1, subscriber.nick
   end
 
   def test_string_key
@@ -83,7 +98,7 @@ class PrimaryKeysTest < ActiveRecord::TestCase
     subscriber.id = "jdoe"
     assert_equal("jdoe", subscriber.id)
     subscriber.name = "John Doe"
-    assert_nothing_raised { subscriber.save! }
+    subscriber.save!
     assert_equal("jdoe", subscriber.id)
 
     subscriberReloaded = Subscriber.find("jdoe")
@@ -120,48 +135,45 @@ class PrimaryKeysTest < ActiveRecord::TestCase
   def test_delete_should_quote_pkey
     assert_nothing_raised { MixedCaseMonkey.delete(1) }
   end
+
   def test_update_counters_should_quote_pkey_and_quote_counter_columns
-    assert_nothing_raised { MixedCaseMonkey.update_counters(1, :fleaCount => 99) }
+    assert_nothing_raised { MixedCaseMonkey.update_counters(1, fleaCount: 99) }
   end
+
   def test_find_with_one_id_should_quote_pkey
     assert_nothing_raised { MixedCaseMonkey.find(1) }
   end
+
   def test_find_with_multiple_ids_should_quote_pkey
-    assert_nothing_raised { MixedCaseMonkey.find([1,2]) }
+    assert_nothing_raised { MixedCaseMonkey.find([1, 2]) }
   end
+
   def test_instance_update_should_quote_pkey
     assert_nothing_raised { MixedCaseMonkey.find(1).save }
   end
+
   def test_instance_destroy_should_quote_pkey
     assert_nothing_raised { MixedCaseMonkey.find(1).destroy }
   end
 
-  def test_supports_primary_key
-    assert_nothing_raised do
-      ActiveRecord::Base.connection.supports_primary_key?
+  def test_primary_key_returns_value_if_it_exists
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "developers"
     end
-  end
 
-  if ActiveRecord::Base.connection.supports_primary_key?
-    def test_primary_key_returns_value_if_it_exists
-      klass = Class.new(ActiveRecord::Base) do
-        self.table_name = 'developers'
-      end
+    assert_equal "id", klass.primary_key
+  end
 
-      assert_equal 'id', klass.primary_key
+  def test_primary_key_returns_nil_if_it_does_not_exist
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "developers_projects"
     end
 
-    def test_primary_key_returns_nil_if_it_does_not_exist
-      klass = Class.new(ActiveRecord::Base) do
-        self.table_name = 'developers_projects'
-      end
-
-      assert_nil klass.primary_key
-    end
+    assert_nil klass.primary_key
   end
 
   def test_quoted_primary_key_after_set_primary_key
-    k = Class.new( ActiveRecord::Base )
+    k = Class.new(ActiveRecord::Base)
     assert_equal k.connection.quote_column_name("id"), k.quoted_primary_key
     k.primary_key = "foo"
     assert_equal k.connection.quote_column_name("foo"), k.quoted_primary_key
@@ -169,29 +181,47 @@ class PrimaryKeysTest < ActiveRecord::TestCase
 
   def test_auto_detect_primary_key_from_schema
     MixedCaseMonkey.reset_primary_key
-    assert_equal "monkeyID", MixedCaseMonkey.primary_key
+    assert_equal "monkeyid", MixedCaseMonkey.primary_key
   end
 
   def test_primary_key_update_with_custom_key_name
-    dashboard = Dashboard.create!(dashboard_id: '1')
-    dashboard.id = '2'
+    dashboard = Dashboard.create!(dashboard_id: "1")
+    dashboard.id = "2"
     dashboard.save!
 
     dashboard = Dashboard.first
-    assert_equal '2', dashboard.id
+    assert_equal "2", dashboard.id
+  end
+
+  def test_create_without_primary_key_no_extra_query
+    skip if current_adapter?(:OracleAdapter, :IBM_DBAdapter)
+
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "dashboards"
+    end
+    klass.create! # warmup schema cache
+    assert_queries(3, ignore_none: true) { klass.create! }
+  end
+
+  def test_assign_id_raises_error_if_primary_key_doesnt_exist
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "dashboards"
+    end
+    dashboard = klass.new
+    assert_raises(ActiveModel::MissingAttributeError) { dashboard.id = "1" }
   end
 
   if current_adapter?(:PostgreSQLAdapter)
     def test_serial_with_quoted_sequence_name
       column = MixedCaseMonkey.columns_hash[MixedCaseMonkey.primary_key]
-      assert_equal "nextval('\"mixed_case_monkeys_monkeyID_seq\"'::regclass)", column.default_function
-      assert column.serial?
+      assert_equal "nextval('\"mixed_case_monkeys_monkeyid_seq\"'::regclass)", column.default_function
+      assert_predicate column, :serial?
     end
 
     def test_serial_with_unquoted_sequence_name
       column = Topic.columns_hash[Topic.primary_key]
       assert_equal "nextval('topics_id_seq'::regclass)", column.default_function
-      assert column.serial?
+      assert_predicate column, :serial?
     end
   end
 end
@@ -204,17 +234,54 @@ class PrimaryKeyWithNoConnectionTest < ActiveRecord::TestCase
       connection = ActiveRecord::Base.remove_connection
 
       model = Class.new(ActiveRecord::Base)
-      model.primary_key = 'foo'
+      model.primary_key = "foo"
 
-      assert_equal 'foo', model.primary_key
+      assert_equal "foo", model.primary_key
 
       ActiveRecord::Base.establish_connection(connection)
 
-      assert_equal 'foo', model.primary_key
+      assert_equal "foo", model.primary_key
     end
   end
 end
 
+class PrimaryKeyWithAutoIncrementTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  class AutoIncrement < ActiveRecord::Base
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    @connection.drop_table(:auto_increments, if_exists: true)
+  end
+
+  def test_primary_key_with_integer
+    @connection.create_table(:auto_increments, id: :integer, force: true)
+    assert_auto_incremented
+  end
+
+  def test_primary_key_with_bigint
+    @connection.create_table(:auto_increments, id: :bigint, force: true)
+    assert_auto_incremented
+  end
+
+  private
+    def assert_auto_incremented
+      record1 = AutoIncrement.create!
+      assert_not_nil record1.id
+
+      record1.destroy
+
+      record2 = AutoIncrement.create!
+      assert_not_nil record2.id
+      assert_operator record2.id, :>, record1.id
+    end
+end
+
 class PrimaryKeyAnyTypeTest < ActiveRecord::TestCase
   include SchemaDumpingHelper
 
@@ -229,8 +296,7 @@ class PrimaryKeyAnyTypeTest < ActiveRecord::TestCase
   end
 
   teardown do
-    @connection.drop_table(:barcodes)
-	#, if_exists: true)
+    @connection.drop_table(:barcodes, if_exists: true)
   end
 
   def test_any_type_primary_key
@@ -240,11 +306,22 @@ class PrimaryKeyAnyTypeTest < ActiveRecord::TestCase
     assert_not column.null
     assert_equal :string, column.type
     assert_equal 42, column.limit
+  ensure
+    Barcode.reset_column_information
   end
 
   test "schema dump primary key includes type and options" do
     schema = dump_table_schema "barcodes"
-    assert_match %r{create_table "barcodes", primary_key: "code", id: :string, limit: 42}, schema
+    assert_match %r/create_table "barcodes", primary_key: "code", id: { type: :string, limit: 42 }/, schema
+    assert_no_match %r{t\.index \["code"\]}, schema
+  end
+
+  if current_adapter?(:Mysql2Adapter) && supports_datetime_with_precision?
+    test "schema typed primary key column" do
+      @connection.create_table(:scheduled_logs, id: :timestamp, precision: 6, force: true)
+      schema = dump_table_schema("scheduled_logs")
+      assert_match %r/create_table "scheduled_logs", id: { type: :timestamp, precision: 6.* }/, schema
+    end
   end
 end
 
@@ -256,25 +333,43 @@ class CompositePrimaryKeyTest < ActiveRecord::TestCase
   def setup
     @connection = ActiveRecord::Base.connection
     @connection.schema_cache.clear!
-    @connection.create_table(:barcodes, primary_key: ["region", "code"], force: true) do |t|
+    @connection.create_table(:uber_barcodes, primary_key: ["region", "code"], force: true) do |t|
+      t.string :region, null: false
+      t.integer :code, null: false
+    end
+    @connection.create_table(:barcodes_reverse, primary_key: ["code", "region"], force: true) do |t|
       t.string :region, null: false
       t.integer :code, null: false
     end
+    @connection.create_table(:travels, primary_key: ["from", "to"], force: true) do |t|
+      t.string :from, null: false
+      t.string :to, null: false
+    end
   end
 
   def teardown
-    @connection.drop_table(:barcodes)
-	#, if_exists: true)
+    @connection.drop_table :uber_barcodes, if_exists: true
+    @connection.drop_table :barcodes_reverse, if_exists: true
+    @connection.drop_table :travels, if_exists: true
   end
 
   def test_composite_primary_key
-    assert_equal ["region", "code"], @connection.primary_keys("barcodes")
+    pri =  @connection.primary_keys("uber_barcodes")
+    assert_equal ["region", "code"], @connection.primary_keys("uber_barcodes")
+  end
+
+  def test_composite_primary_key_with_reserved_words
+    assert_equal ["from", "to"], @connection.primary_keys("travels")
+  end
+
+  def test_composite_primary_key_out_of_order
+    assert_equal ["code", "region"], @connection.primary_keys("barcodes_reverse")
   end
 
   def test_primary_key_issues_warning
     model = Class.new(ActiveRecord::Base) do
       def self.table_name
-        "barcodes"
+        "uber_barcodes"
       end
     end
     warning = capture(:stderr) do
@@ -284,42 +379,45 @@ class CompositePrimaryKeyTest < ActiveRecord::TestCase
   end
 
   def test_collectly_dump_composite_primary_key
-    schema = dump_table_schema "barcodes"
-    assert_match %r{create_table "barcodes", primary_key: \["region", "code"\]}, schema
+    schema = dump_table_schema "uber_barcodes"
+    assert_match %r{create_table "uber_barcodes", primary_key: \["region", "code"\]}, schema
+  end
+
+  def test_dumping_composite_primary_key_out_of_order
+    schema = dump_table_schema "barcodes_reverse"
+    assert_match %r{create_table "barcodes_reverse", primary_key: \["code", "region"\]}, schema
   end
 end
 
-if current_adapter?(:Mysql2Adapter)
-  class PrimaryKeyBigintNilDefaultTest < ActiveRecord::TestCase
-    include SchemaDumpingHelper
+class PrimaryKeyIntegerNilDefaultTest < ActiveRecord::TestCase
+  include SchemaDumpingHelper
 
-    self.use_transactional_tests = false
+  self.use_transactional_tests = false
 
-    def setup
-      @connection = ActiveRecord::Base.connection
-      @connection.create_table(:bigint_defaults, id: :bigint, default: nil, force: true)
-    end
+  def setup
+    @connection = ActiveRecord::Base.connection
+  end
 
-    def teardown
-      @connection.drop_table :bigint_defaults
-	  #, if_exists: true
-    end
+  def teardown
+    @connection.drop_table :int_defaults, if_exists: true
+  end
 
-    test "primary key with bigint allows default override via nil" do
-      column = @connection.columns(:bigint_defaults).find { |c| c.name == 'id' }
-      assert column.bigint?
-      assert_not column.auto_increment?
-    end
+  def test_schema_dump_primary_key_integer_with_default_nil
+    skip if current_adapter?(:SQLite3Adapter, :IBM_DBAdapter)
+    @connection.create_table(:int_defaults, id: :integer, default: nil, force: true)
+    schema = dump_table_schema "int_defaults"
+    assert_match %r{create_table "int_defaults", id: :integer, default: nil}, schema
+  end
 
-    test "schema dump primary key with bigint default nil" do
-      schema = dump_table_schema "bigint_defaults"
-      assert_match %r{create_table "bigint_defaults", id: :bigint, default: nil}, schema
-    end
+  def test_schema_dump_primary_key_bigint_with_default_nil
+    @connection.create_table(:int_defaults, id: :bigint, default: nil, force: true)
+    schema = dump_table_schema "int_defaults"
+    assert_match %r{create_table "int_defaults", id: :bigint, default: nil}, schema
   end
 end
 
 if current_adapter?(:PostgreSQLAdapter, :Mysql2Adapter)
-  class PrimaryKeyBigSerialTest < ActiveRecord::TestCase
+  class PrimaryKeyIntegerTest < ActiveRecord::TestCase
     include SchemaDumpingHelper
 
     self.use_transactional_tests = false
@@ -329,47 +427,55 @@ if current_adapter?(:PostgreSQLAdapter, :Mysql2Adapter)
 
     setup do
       @connection = ActiveRecord::Base.connection
-      if current_adapter?(:PostgreSQLAdapter)
-        @connection.create_table(:widgets, id: :bigserial, force: true)
-      else
-        @connection.create_table(:widgets, id: :bigint, force: true)
-      end
+      @pk_type = current_adapter?(:PostgreSQLAdapter) ? :serial : :integer
     end
 
     teardown do
-      @connection.drop_table :widgets
-	  #, if_exists: true
-      Widget.reset_column_information
+      @connection.drop_table :widgets, if_exists: true
     end
 
-    test "primary key column type with bigserial" do
-      column_type = Widget.type_for_attribute(Widget.primary_key)
-      assert_equal :integer, column_type.type
-      assert_equal 8, column_type.limit
+    test "primary key column type with serial/integer" do
+      @connection.create_table(:widgets, id: @pk_type, force: true)
+      column = @connection.columns(:widgets).find { |c| c.name == "id" }
+      assert_equal :integer, column.type
+      assert_not_predicate column, :bigint?
     end
 
-    test "primary key with bigserial are automatically numbered" do
+    test "primary key with serial/integer are automatically numbered" do
+      @connection.create_table(:widgets, id: @pk_type, force: true)
       widget = Widget.create!
       assert_not_nil widget.id
     end
 
-    test "schema dump primary key with bigserial" do
+    test "schema dump primary key with serial/integer" do
+      @connection.create_table(:widgets, id: @pk_type, force: true)
       schema = dump_table_schema "widgets"
-      if current_adapter?(:PostgreSQLAdapter)
-        assert_match %r{create_table "widgets", id: :bigserial, force: :cascade}, schema
-      else
-        assert_match %r{create_table "widgets", id: :bigint, force: :cascade}, schema
-      end
+      assert_match %r{create_table "widgets", id: :#{@pk_type}, }, schema
     end
 
     if current_adapter?(:Mysql2Adapter)
       test "primary key column type with options" do
-        @connection.create_table(:widgets, id: :primary_key, limit: 8, unsigned: true, force: true)
-        column = @connection.columns(:widgets).find { |c| c.name == 'id' }
-        assert column.auto_increment?
+        @connection.create_table(:widgets, id: :primary_key, limit: 4, unsigned: true, force: true)
+        column = @connection.columns(:widgets).find { |c| c.name == "id" }
+        assert_predicate column, :auto_increment?
         assert_equal :integer, column.type
-        assert_equal 8, column.limit
-        assert column.unsigned?
+        assert_not_predicate column, :bigint?
+        assert_predicate column, :unsigned?
+
+        schema = dump_table_schema "widgets"
+        assert_match %r/create_table "widgets", id: { type: :integer, unsigned: true }/, schema
+      end
+
+      test "bigint primary key with unsigned" do
+        @connection.create_table(:widgets, id: :bigint, unsigned: true, force: true)
+        column = @connection.columns(:widgets).find { |c| c.name == "id" }
+        assert_predicate column, :auto_increment?
+        assert_equal :integer, column.type
+        assert_predicate column, :bigint?
+        assert_predicate column, :unsigned?
+
+        schema = dump_table_schema "widgets"
+        assert_match %r/create_table "widgets", id: { type: :bigint, unsigned: true }/, schema
       end
     end
   end