ibm_db 3.0.5 → 5.0.5

data/test/cases/adapters/mysql2/mysql2_adapter_test.rb

@@ -0,0 +1,83 @@
+require "cases/helper"
+require "support/ddl_helper"
+
+class Mysql2AdapterTest < ActiveRecord::Mysql2TestCase
+  include DdlHelper
+
+  def setup
+    @conn = ActiveRecord::Base.connection
+  end
+
+  def test_exec_query_nothing_raises_with_no_result_queries
+    assert_nothing_raised do
+      with_example_table do
+        @conn.exec_query('INSERT INTO ex (number) VALUES (1)')
+        @conn.exec_query('DELETE FROM ex WHERE number = 1')
+      end
+    end
+  end
+
+  def test_valid_column
+    with_example_table do
+      column = @conn.columns('ex').find { |col| col.name == 'id' }
+      assert @conn.valid_type?(column.type)
+    end
+  end
+
+  def test_invalid_column
+    assert_not @conn.valid_type?(:foobar)
+  end
+
+  def test_columns_for_distinct_zero_orders
+    assert_equal "posts.id",
+      @conn.columns_for_distinct("posts.id", [])
+  end
+
+  def test_columns_for_distinct_one_order
+    assert_equal "posts.id, posts.created_at AS alias_0",
+      @conn.columns_for_distinct("posts.id", ["posts.created_at desc"])
+  end
+
+  def test_columns_for_distinct_few_orders
+    assert_equal "posts.id, posts.created_at AS alias_0, posts.position AS alias_1",
+      @conn.columns_for_distinct("posts.id", ["posts.created_at desc", "posts.position asc"])
+  end
+
+  def test_columns_for_distinct_with_case
+    assert_equal(
+      'posts.id, CASE WHEN author.is_active THEN UPPER(author.name) ELSE UPPER(author.email) END AS alias_0',
+      @conn.columns_for_distinct('posts.id',
+        ["CASE WHEN author.is_active THEN UPPER(author.name) ELSE UPPER(author.email) END"])
+    )
+  end
+
+  def test_columns_for_distinct_blank_not_nil_orders
+    assert_equal "posts.id, posts.created_at AS alias_0",
+      @conn.columns_for_distinct("posts.id", ["posts.created_at desc", "", "   "])
+  end
+
+  def test_columns_for_distinct_with_arel_order
+    order = Object.new
+    def order.to_sql
+      "posts.created_at desc"
+    end
+    assert_equal "posts.id, posts.created_at AS alias_0",
+      @conn.columns_for_distinct("posts.id", [order])
+  end
+
+  def test_table_exists_acts_upon_current_database
+    previous_db = @conn.select_value("SELECT DATABASE()")
+
+    assert @conn.table_exists?("accounts")
+    @conn.execute("USE activerecord_unittest2")
+    assert_not @conn.table_exists?("accounts")
+  ensure
+    @conn.execute("USE #{previous_db}")
+  end
+
+  private
+
+  def with_example_table(definition = 'id int auto_increment primary key, number int, data varchar(255)', &block)
+    super(@conn, 'ex', definition, &block)
+  end
+end

data/test/cases/adapters/mysql2/reserved_word_test.rb

@@ -0,0 +1,152 @@
+require "cases/helper"
+
+# a suite of tests to ensure the ConnectionAdapters#MysqlAdapter can handle tables with
+# reserved word names (ie: group, order, values, etc...)
+class Mysql2ReservedWordTest < ActiveRecord::Mysql2TestCase
+  class Group < ActiveRecord::Base
+    Group.table_name = 'group'
+    belongs_to :select
+    has_one :values
+  end
+
+  class Select < ActiveRecord::Base
+    Select.table_name = 'select'
+    has_many :groups
+  end
+
+  class Values < ActiveRecord::Base
+    Values.table_name = 'values'
+  end
+
+  class Distinct < ActiveRecord::Base
+    Distinct.table_name = 'distinct'
+    has_and_belongs_to_many :selects
+    has_many :values, :through => :groups
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+
+    # we call execute directly here (and do similar below) because ActiveRecord::Base#create_table()
+    # will fail with these table names if these test cases fail
+
+    create_tables_directly 'group'=>'id int auto_increment primary key, `order` varchar(255), select_id int',
+      'select'=>'id int auto_increment primary key',
+      'values'=>'id int auto_increment primary key, group_id int',
+      'distinct'=>'id int auto_increment primary key',
+      'distinct_select'=>'distinct_id int, select_id int'
+  end
+
+  teardown do
+    drop_tables_directly ['group', 'select', 'values', 'distinct', 'distinct_select', 'order']
+  end
+
+  # create tables with reserved-word names and columns
+  def test_create_tables
+    assert_nothing_raised {
+      @connection.create_table :order do |t|
+        t.column :group, :string
+      end
+    }
+  end
+
+  # rename tables with reserved-word names
+  def test_rename_tables
+    assert_nothing_raised { @connection.rename_table(:group, :order) }
+  end
+
+  # alter column with a reserved-word name in a table with a reserved-word name
+  def test_change_columns
+    assert_nothing_raised { @connection.change_column_default(:group, :order, 'whatever') }
+    #the quoting here will reveal any double quoting issues in change_column's interaction with the column method in the adapter
+    assert_nothing_raised { @connection.change_column('group', 'order', :Int, :default => 0) }
+    assert_nothing_raised { @connection.rename_column(:group, :order, :values) }
+  end
+
+  # introspect table with reserved word name
+  def test_introspect
+    assert_nothing_raised { @connection.columns(:group) }
+    assert_nothing_raised { @connection.indexes(:group) }
+  end
+
+  #fixtures
+  self.use_instantiated_fixtures = true
+  self.use_transactional_tests = false
+
+  #activerecord model class with reserved-word table name
+  def test_activerecord_model
+    create_test_fixtures :select, :distinct, :group, :values, :distinct_select
+    x = nil
+    assert_nothing_raised { x = Group.new }
+    x.order = 'x'
+    assert_nothing_raised { x.save }
+    x.order = 'y'
+    assert_nothing_raised { x.save }
+    assert_nothing_raised { Group.find_by_order('y') }
+    assert_nothing_raised { Group.find(1) }
+  end
+
+  # has_one association with reserved-word table name
+  def test_has_one_associations
+    create_test_fixtures :select, :distinct, :group, :values, :distinct_select
+    v = nil
+    assert_nothing_raised { v = Group.find(1).values }
+    assert_equal 2, v.id
+  end
+
+  # belongs_to association with reserved-word table name
+  def test_belongs_to_associations
+    create_test_fixtures :select, :distinct, :group, :values, :distinct_select
+    gs = nil
+    assert_nothing_raised { gs = Select.find(2).groups }
+    assert_equal gs.length, 2
+    assert(gs.collect(&:id).sort == [2, 3])
+  end
+
+  # has_and_belongs_to_many with reserved-word table name
+  def test_has_and_belongs_to_many
+    create_test_fixtures :select, :distinct, :group, :values, :distinct_select
+    s = nil
+    assert_nothing_raised { s = Distinct.find(1).selects }
+    assert_equal s.length, 2
+    assert(s.collect(&:id).sort == [1, 2])
+  end
+
+  # activerecord model introspection with reserved-word table and column names
+  def test_activerecord_introspection
+    assert_nothing_raised { Group.table_exists? }
+    assert_nothing_raised { Group.columns }
+  end
+
+  # Calculations
+  def test_calculations_work_with_reserved_words
+    assert_nothing_raised { Group.count }
+  end
+
+  def test_associations_work_with_reserved_words
+    assert_nothing_raised { Select.all.merge!(:includes => [:groups]).to_a }
+  end
+
+  #the following functions were added to DRY test cases
+
+  private
+  # custom fixture loader, uses FixtureSet#create_fixtures and appends base_path to the current file's path
+  def create_test_fixtures(*fixture_names)
+    ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT + "/reserved_words", fixture_names)
+  end
+
+  # custom drop table, uses execute on connection to drop a table if it exists. note: escapes table_name
+  def drop_tables_directly(table_names, connection = @connection)
+    table_names.each do |name|
+      connection.drop_table name, if_exists: true
+    end
+  end
+
+  # custom create table, uses execute on connection to create a table, note: escapes table_name, does NOT escape columns
+  def create_tables_directly(tables, connection = @connection)
+    tables.each do |table_name, column_properties|
+      connection.execute("CREATE TABLE `#{table_name}` ( #{column_properties} )")
+    end
+  end
+
+end

data/test/cases/adapters/mysql2/schema_migrations_test.rb

@@ -0,0 +1,59 @@
+require "cases/helper"
+
+class SchemaMigrationsTest < ActiveRecord::Mysql2TestCase
+  def test_renaming_index_on_foreign_key
+    connection.add_index "engines", "car_id"
+    connection.add_foreign_key :engines, :cars, name: "fk_engines_cars"
+
+    connection.rename_index("engines", "index_engines_on_car_id", "idx_renamed")
+    assert_equal ["idx_renamed"], connection.indexes("engines").map(&:name)
+  ensure
+    connection.remove_foreign_key :engines, name: "fk_engines_cars"
+  end
+
+  def test_initializes_schema_migrations_for_encoding_utf8mb4
+    with_encoding_utf8mb4 do
+      table_name = ActiveRecord::SchemaMigration.table_name
+      connection.drop_table table_name, if_exists: true
+
+      connection.initialize_schema_migrations_table
+
+      assert connection.column_exists?(table_name, :version, :string, collation: 'utf8_general_ci')
+    end
+  end
+
+  def test_initializes_internal_metadata_for_encoding_utf8mb4
+    with_encoding_utf8mb4 do
+      table_name = ActiveRecord::InternalMetadata.table_name
+      connection.drop_table table_name, if_exists: true
+
+      connection.initialize_internal_metadata_table
+
+      assert connection.column_exists?(table_name, :key, :string, collation: 'utf8_general_ci')
+    end
+  end
+
+  private
+
+  def with_encoding_utf8mb4
+    database_name = connection.current_database
+    database_info = connection.select_one("SELECT * FROM information_schema.schemata WHERE schema_name = '#{database_name}'")
+
+    original_charset = database_info["DEFAULT_CHARACTER_SET_NAME"]
+    original_collation = database_info["DEFAULT_COLLATION_NAME"]
+
+    execute("ALTER DATABASE #{database_name} DEFAULT CHARACTER SET utf8mb4")
+
+    yield
+  ensure
+    execute("ALTER DATABASE #{database_name} DEFAULT CHARACTER SET #{original_charset} COLLATE #{original_collation}")
+  end
+
+  def connection
+    @connection ||= ActiveRecord::Base.connection
+  end
+
+  def execute(sql)
+    connection.execute(sql)
+  end
+end

data/test/cases/adapters/mysql2/schema_test.rb

@@ -0,0 +1,126 @@
+require "cases/helper"
+require 'models/post'
+require 'models/comment'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class Mysql2SchemaTest < ActiveRecord::Mysql2TestCase
+      fixtures :posts
+
+      def setup
+        @connection = ActiveRecord::Base.connection
+        db          = Post.connection_pool.spec.config[:database]
+        table       = Post.table_name
+        @db_name    = db
+
+        @omgpost = Class.new(ActiveRecord::Base) do
+          self.inheritance_column = :disabled
+          self.table_name = "#{db}.#{table}"
+          def self.name; 'Post'; end
+        end
+      end
+
+      def test_float_limits
+        @connection.create_table :mysql_doubles do |t|
+          t.float :float_no_limit
+          t.float :float_short, limit: 5
+          t.float :float_long, limit: 53
+
+          t.float :float_23, limit: 23
+          t.float :float_24, limit: 24
+          t.float :float_25, limit: 25
+        end
+
+        column_no_limit = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_no_limit' }
+        column_short = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_short' }
+        column_long = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_long' }
+
+        column_23 = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_23' }
+        column_24 = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_24' }
+        column_25 = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_25' }
+
+        # Mysql floats are precision 0..24, Mysql doubles are precision 25..53
+        assert_equal 24, column_no_limit.limit
+        assert_equal 24, column_short.limit
+        assert_equal 53, column_long.limit
+
+        assert_equal 24, column_23.limit
+        assert_equal 24, column_24.limit
+        assert_equal 53, column_25.limit
+      ensure
+        @connection.drop_table "mysql_doubles", if_exists: true
+      end
+
+      def test_schema
+        assert @omgpost.first
+      end
+
+      def test_primary_key
+        assert_equal 'id', @omgpost.primary_key
+      end
+
+      def test_data_source_exists?
+        name = @omgpost.table_name
+        assert @connection.data_source_exists?(name), "#{name} data_source should exist"
+      end
+
+      def test_data_source_exists_wrong_schema
+        assert(!@connection.data_source_exists?("#{@db_name}.zomg"), "data_source should not exist")
+      end
+
+      def test_dump_indexes
+        index_a_name = 'index_key_tests_on_snack'
+        index_b_name = 'index_key_tests_on_pizza'
+        index_c_name = 'index_key_tests_on_awesome'
+
+        table = 'key_tests'
+
+        indexes = @connection.indexes(table).sort_by(&:name)
+        assert_equal 3,indexes.size
+
+        index_a = indexes.select{|i| i.name == index_a_name}[0]
+        index_b = indexes.select{|i| i.name == index_b_name}[0]
+        index_c = indexes.select{|i| i.name == index_c_name}[0]
+        assert_equal :btree, index_a.using
+        assert_nil index_a.type
+        assert_equal :btree, index_b.using
+        assert_nil index_b.type
+
+        assert_nil index_c.using
+        assert_equal :fulltext, index_c.type
+      end
+
+      unless mysql_enforcing_gtid_consistency?
+        def test_drop_temporary_table
+          @connection.transaction do
+            @connection.create_table(:temp_table, temporary: true)
+            # if it doesn't properly say DROP TEMPORARY TABLE, the transaction commit
+            # will complain that no transaction is active
+            @connection.drop_table(:temp_table, temporary: true)
+          end
+        end
+      end
+    end
+  end
+end
+
+class Mysql2AnsiQuotesTest < ActiveRecord::Mysql2TestCase
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.execute("SET SESSION sql_mode='ANSI_QUOTES'")
+  end
+
+  def teardown
+    @connection.reconnect!
+  end
+
+  def test_primary_key_method_with_ansi_quotes
+    assert_equal "id", @connection.primary_key("topics")
+  end
+
+  def test_foreign_keys_method_with_ansi_quotes
+    fks = @connection.foreign_keys("lessons_students")
+    assert_equal([["lessons_students", "students", :cascade]],
+                 fks.map {|fk| [fk.from_table, fk.to_table, fk.on_delete] })
+  end
+end

data/test/cases/adapters/mysql2/sp_test.rb

@@ -0,0 +1,36 @@
+require "cases/helper"
+require 'models/topic'
+require 'models/reply'
+
+class Mysql2StoredProcedureTest < ActiveRecord::Mysql2TestCase
+  fixtures :topics
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    unless ActiveRecord::Base.connection.version >= '5.6.0'
+      skip("no stored procedure support")
+    end
+  end
+
+  # Test that MySQL allows multiple results for stored procedures
+  #
+  # In MySQL 5.6, CLIENT_MULTI_RESULTS is enabled by default.
+  # http://dev.mysql.com/doc/refman/5.6/en/call.html
+  def test_multi_results
+    rows = @connection.select_rows('CALL ten();')
+    assert_equal 10, rows[0][0].to_i, "ten() did not return 10 as expected: #{rows.inspect}"
+    assert @connection.active?, "Bad connection use by 'Mysql2Adapter.select_rows'"
+  end
+
+  def test_multi_results_from_select_one
+    row = @connection.select_one('CALL topics(1);')
+    assert_equal 'David', row['author_name']
+    assert @connection.active?, "Bad connection use by 'Mysql2Adapter.select_one'"
+  end
+
+  def test_multi_results_from_find_by_sql
+    topics = Topic.find_by_sql 'CALL topics(3);'
+    assert_equal 3, topics.size
+    assert @connection.active?, "Bad connection use by 'Mysql2Adapter.select'"
+  end
+end