ibm_db 3.0.4 → 5.0.4

data/lib/active_record/connection_adapters/ibmdb_adapter.rb

@@ -1,2 +1,5 @@
 #rb file to support alising of adapter name as ibmdb [without underscore] that will require ibm_db_adapter.rb
-require 'active_record/connection_adapters/ibm_db_adapter'
+require 'active_record/connection_adapters/ibm_db_adapter'
+
+require 'active_record/connection_adapters/ibm_schema_dumper'
+

data/test/active_record/connection_adapters/fake_adapter.rb

@@ -7,7 +7,7 @@ module ActiveRecord
 
   module ConnectionAdapters
     class FakeAdapter < AbstractAdapter
-      attr_accessor :tables, :primary_keys
+      attr_accessor :data_sources, :primary_keys
 
       @columns = Hash.new { |h,k| h[k] = [] }
       class << self
@@ -16,21 +16,20 @@ module ActiveRecord
 
       def initialize(connection, logger)
         super
-        @tables       = []
+        @data_sources = []
         @primary_keys = {}
         @columns      = self.class.columns
       end
 
       def primary_key(table)
-        @primary_keys[table]
+        @primary_keys[table] || "id"
       end
 
       def merge_column(table_name, name, sql_type = nil, options = {})
         @columns[table_name] << ActiveRecord::ConnectionAdapters::Column.new(
           name.to_s,
           options[:default],
-          lookup_cast_type(sql_type.to_s),
-          sql_type.to_s,
+          fetch_type_metadata(sql_type),
           options[:null])
       end
 
@@ -38,6 +37,10 @@ module ActiveRecord
         @columns[table_name]
       end
 
+      def data_source_exists?(*)
+        true
+      end
+
       def active?
         true
       end

data/test/cases/adapter_test.rb

@@ -1,19 +1,19 @@
-# encoding: utf-8
-
 require "cases/helper"
 require "models/book"
 require "models/post"
 require "models/author"
+require "models/event"
 
 module ActiveRecord
   class AdapterTest < ActiveRecord::TestCase
-    def setup
+    def setup	  
       @connection = ActiveRecord::Base.connection
     end
 
     ##
     # PostgreSQL does not support null bytes in strings
-    unless current_adapter?(:PostgreSQLAdapter)
+    unless current_adapter?(:PostgreSQLAdapter, :IBM_DBAdapter) ||
+        (current_adapter?(:SQLite3Adapter) && !ActiveRecord::Base.connection.prepared_statements)
       def test_update_prepared_statement
         b = Book.create(name: "my \x00 book")
         b.reload
@@ -24,18 +24,49 @@ module ActiveRecord
       end
     end
 
+	unless current_adapter?(:IBM_DBAdapter) 
+		def test_create_record_with_pk_as_zero
+		  Book.create(id: 0)
+		  assert_equal 0, Book.find(0).id
+		  assert_nothing_raised { Book.destroy(0) }
+		end
+	end
+
     def test_tables
-      tables = @connection.tables
+      tables = nil
+      ActiveSupport::Deprecation.silence { tables = @connection.tables }
       assert tables.include?("accounts")
       assert tables.include?("authors")
       assert tables.include?("tasks")
       assert tables.include?("topics")
     end
 
+	
     def test_table_exists?
-      assert @connection.table_exists?("accounts")
-      assert !@connection.table_exists?("nonexistingtable")
-      assert !@connection.table_exists?(nil)
+      ActiveSupport::Deprecation.silence do
+        assert @connection.table_exists?("accounts")
+        assert !@connection.table_exists?("nonexistingtable")
+        assert !@connection.table_exists?(nil)
+      end
+    end
+
+    def test_table_exists_checking_both_tables_and_views_is_deprecated
+      assert_deprecated { @connection.table_exists?("accounts") }
+    end
+
+    def test_data_sources
+      data_sources = @connection.data_sources
+      assert data_sources.include?("accounts")
+      assert data_sources.include?("authors")
+      assert data_sources.include?("tasks")
+      assert data_sources.include?("topics")
+    end
+
+    def test_data_source_exists?
+      assert @connection.data_source_exists?("accounts")
+      assert @connection.data_source_exists?(:accounts)
+      assert_not @connection.data_source_exists?("nonexistingtable")
+      assert_not @connection.data_source_exists?(nil)
     end
 
     def test_indexes
@@ -59,13 +90,26 @@ module ActiveRecord
       @connection.remove_index(:accounts, :name => idx_name) rescue nil
     end
 
+	unless current_adapter?(:IBM_DBAdapter)
+		def test_remove_index_when_name_and_wrong_column_name_specified
+		  index_name = "accounts_idx"
+
+		  @connection.add_index :accounts, :firm_id, :name => index_name
+		  assert_raises ArgumentError do
+			@connection.remove_index :accounts, :name => index_name, :column => :wrong_column_name
+		  end
+		ensure
+		  @connection.remove_index(:accounts, :name => index_name)
+		end
+	end
+	
     def test_current_database
       if @connection.respond_to?(:current_database)
         assert_equal ARTest.connection_config['arunit']['database'], @connection.current_database
       end
     end
 
-    if current_adapter?(:MysqlAdapter)
+    if current_adapter?(:Mysql2Adapter)
       def test_charset
         assert_not_nil @connection.charset
         assert_not_equal 'character_set_database', @connection.charset
@@ -135,17 +179,21 @@ module ActiveRecord
         assert_nothing_raised { sub.save! }
       end
     end
-
-    def test_uniqueness_violations_are_translated_to_specific_exception
-      @connection.execute "INSERT INTO subscribers(nick) VALUES('me')"
-      assert_raises(ActiveRecord::RecordNotUnique) do
-        @connection.execute "INSERT INTO subscribers(nick) VALUES('me')"
-      end
-    end
-
-    unless current_adapter?(:SQLite3Adapter)
+	
+	unless current_adapter?(:IBM_DBAdapter)
+		def test_uniqueness_violations_are_translated_to_specific_exception
+		  @connection.execute "INSERT INTO subscribers(nick) VALUES('me')"
+		  error = assert_raises(ActiveRecord::RecordNotUnique) do
+			@connection.execute "INSERT INTO subscribers(nick) VALUES('me')"
+		  end
+
+		  assert_not_nil error.cause
+		end
+	end
+
+    unless current_adapter?(:SQLite3Adapter, :IBM_DBAdapter)
       def test_foreign_key_violations_are_translated_to_specific_exception
-        assert_raises(ActiveRecord::InvalidForeignKey) do
+        error = assert_raises(ActiveRecord::InvalidForeignKey) do
           # Oracle adapter uses prefetched primary key values from sequence and passes them to connection adapter insert method
           if @connection.prefetch_primary_key?
             id_value = @connection.next_sequence_value(@connection.default_sequence_name("fk_test_has_fk", "id"))
@@ -154,6 +202,8 @@ module ActiveRecord
             @connection.execute "INSERT INTO fk_test_has_fk (fk_id) VALUES (0)"
           end
         end
+
+        assert_not_nil error.cause
       end
 
       def test_foreign_key_violations_are_translated_to_specific_exception_with_validate_false
@@ -161,11 +211,21 @@ module ActiveRecord
           self.table_name = 'fk_test_has_fk'
         end
 
-        assert_raises(ActiveRecord::InvalidForeignKey) do
+        error = assert_raises(ActiveRecord::InvalidForeignKey) do
           has_fk = klass_has_fk.new
           has_fk.fk_id = 1231231231
           has_fk.save(validate: false)
         end
+
+        assert_not_nil error.cause
+      end
+
+      def test_value_limit_violations_are_translated_to_specific_exception
+        error = assert_raises(ActiveRecord::ValueTooLong) do
+          Event.create(title: 'abcdefgh')
+        end
+
+        assert_not_nil error.cause
       end
     end
 
@@ -191,44 +251,69 @@ module ActiveRecord
       assert result.is_a?(ActiveRecord::Result)
     end
 
-    def test_select_methods_passing_a_association_relation
-      author = Author.create!(name: 'john')
-      Post.create!(author: author, title: 'foo', body: 'bar')
-      query = author.posts.where(title: 'foo').select(:title)
-      assert_equal({"title" => "foo"}, @connection.select_one(query.arel, nil, query.bind_values))
-      assert_equal({"title" => "foo"}, @connection.select_one(query))
-      assert @connection.select_all(query).is_a?(ActiveRecord::Result)
-      assert_equal "foo", @connection.select_value(query)
-      assert_equal ["foo"], @connection.select_values(query)
+    if ActiveRecord::Base.connection.prepared_statements
+      def test_select_all_with_legacy_binds
+        post = Post.create!(title: "foo", body: "bar")
+        expected = @connection.select_all("SELECT * FROM posts WHERE id = #{post.id}")
+        result = @connection.select_all("SELECT * FROM posts WHERE id = #{Arel::Nodes::BindParam.new.to_sql}", nil, [[nil, post.id]])
+        assert_equal expected.to_hash, result.to_hash
+      end
     end
 
-    def test_select_methods_passing_a_relation
-      Post.create!(title: 'foo', body: 'bar')
-      query = Post.where(title: 'foo').select(:title)
-      assert_equal({"title" => "foo"}, @connection.select_one(query.arel, nil, query.bind_values))
-      assert_equal({"title" => "foo"}, @connection.select_one(query))
-      assert @connection.select_all(query).is_a?(ActiveRecord::Result)
-      assert_equal "foo", @connection.select_value(query)
-      assert_equal ["foo"], @connection.select_values(query)
-    end
+	unless current_adapter?(:IBM_DBAdapter)
+		def test_select_methods_passing_a_association_relation
+		  author = Author.create!(name: 'john')
+		  Post.create!(author: author, title: 'foo', body: 'bar')
+		  query = author.posts.where(title: 'foo').select(:title)
+		  assert_equal({"title" => "foo"}, @connection.select_one(query.arel, nil, query.bound_attributes))
+		  assert_equal({"title" => "foo"}, @connection.select_one(query))
+		  assert @connection.select_all(query).is_a?(ActiveRecord::Result)
+		  assert_equal "foo", @connection.select_value(query)
+		  assert_equal ["foo"], @connection.select_values(query)
+		end
+	end
+	
+	unless current_adapter?(:IBM_DBAdapter)
+		def test_select_methods_passing_a_relation
+		  Post.create!(title: 'foo', body: 'bar')
+		  query = Post.where(title: 'foo').select(:title)
+		  assert_equal({"title" => "foo"}, @connection.select_one(query.arel, nil, query.bound_attributes))
+		  assert_equal({"title" => "foo"}, @connection.select_one(query))
+		  assert @connection.select_all(query).is_a?(ActiveRecord::Result)
+		  assert_equal "foo", @connection.select_value(query)
+		  assert_equal ["foo"], @connection.select_values(query)
+		end
+	end
 
     test "type_to_sql returns a String for unmapped types" do
       assert_equal "special_db_type", @connection.type_to_sql(:special_db_type)
     end
 
-    unless current_adapter?(:PostgreSQLAdapter)
+    unless current_adapter?(:PostgreSQLAdapter, :IBM_DBAdapter)
       def test_log_invalid_encoding
-        assert_raise ActiveRecord::StatementInvalid do
-          @connection.send :log, "SELECT '?' FROM DUAL" do
-            raise '?'.force_encoding(Encoding::ASCII_8BIT)
+        error = assert_raise ActiveRecord::StatementInvalid do
+          @connection.send :log, "SELECT 'ы' FROM DUAL" do
+            raise 'ы'.force_encoding(Encoding::ASCII_8BIT)
           end
         end
+
+        assert_not_nil error.cause
+      end
+    end
+
+    if current_adapter?(:Mysql2Adapter, :SQLite3Adapter)
+      def test_tables_returning_both_tables_and_views_is_deprecated
+        assert_deprecated { @connection.tables }
       end
     end
+
+    def test_passing_arguments_to_tables_is_deprecated
+      assert_deprecated { @connection.tables(:books) }
+    end
   end
 
   class AdapterTestWithoutTransaction < ActiveRecord::TestCase
-    self.use_transactional_fixtures = false
+    self.use_transactional_tests = false
 
     class Klass < ActiveRecord::Base
     end
@@ -242,20 +327,25 @@ module ActiveRecord
       Klass.remove_connection
     end
 
-    unless in_memory_db?
-      test "transaction state is reset after a reconnect" do
-        @connection.begin_transaction
-        assert @connection.transaction_open?
-        @connection.reconnect!
-        assert !@connection.transaction_open?
-      end
-
-      test "transaction state is reset after a disconnect" do
-        @connection.begin_transaction
-        assert @connection.transaction_open?
-        @connection.disconnect!
-        assert !@connection.transaction_open?
-      end
-    end
+	unless current_adapter?(:IBM_DBAdapter)
+		unless in_memory_db?
+		  test "transaction state is reset after a reconnect" do
+			@connection.begin_transaction
+			assert @connection.transaction_open?
+			@connection.reconnect!
+			assert !@connection.transaction_open?
+		  end
+
+		  test "transaction state is reset after a disconnect" do
+			@connection.begin_transaction
+			assert @connection.transaction_open?
+			@connection.disconnect!
+			assert !@connection.transaction_open?
+		  end
+		end
+	end
+	
   end
+  
+  
 end

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

@@ -0,0 +1,193 @@
+require "cases/helper"
+require 'support/connection_helper'
+
+class Mysql2ActiveSchemaTest < ActiveRecord::Mysql2TestCase
+  include ConnectionHelper
+
+  def setup
+    ActiveRecord::Base.connection.singleton_class.class_eval do
+      alias_method :execute_without_stub, :execute
+      def execute(sql, name = nil) return sql end
+    end
+  end
+
+  teardown do
+    reset_connection
+  end
+
+  def test_add_index
+    # add_index calls data_source_exists? and index_name_exists? which can't work since execute is stubbed
+    def (ActiveRecord::Base.connection).data_source_exists?(*); true; end
+    def (ActiveRecord::Base.connection).index_name_exists?(*); false; end
+
+    expected = "CREATE  INDEX `index_people_on_last_name`  ON `people` (`last_name`) "
+    assert_equal expected, add_index(:people, :last_name, :length => nil)
+
+    expected = "CREATE  INDEX `index_people_on_last_name`  ON `people` (`last_name`(10)) "
+    assert_equal expected, add_index(:people, :last_name, :length => 10)
+
+    expected = "CREATE  INDEX `index_people_on_last_name_and_first_name`  ON `people` (`last_name`(15), `first_name`(15)) "
+    assert_equal expected, add_index(:people, [:last_name, :first_name], length: 15)
+    assert_equal expected, add_index(:people, ["last_name", "first_name"], length: 15)
+
+    expected = "CREATE  INDEX `index_people_on_last_name_and_first_name`  ON `people` (`last_name`(15), `first_name`) "
+    assert_equal expected, add_index(:people, [:last_name, :first_name], length: { last_name: 15 })
+    assert_equal expected, add_index(:people, ["last_name", "first_name"], length: { last_name: 15 })
+
+    expected = "CREATE  INDEX `index_people_on_last_name_and_first_name`  ON `people` (`last_name`(15), `first_name`(10)) "
+    assert_equal expected, add_index(:people, [:last_name, :first_name], length: { last_name: 15, first_name: 10 })
+    assert_equal expected, add_index(:people, ["last_name", :first_name], length: { last_name: 15, "first_name" => 10 })
+
+    %w(SPATIAL FULLTEXT UNIQUE).each do |type|
+      expected = "CREATE #{type} INDEX `index_people_on_last_name`  ON `people` (`last_name`) "
+      assert_equal expected, add_index(:people, :last_name, :type => type)
+    end
+
+    %w(btree hash).each do |using|
+      expected = "CREATE  INDEX `index_people_on_last_name` USING #{using} ON `people` (`last_name`) "
+      assert_equal expected, add_index(:people, :last_name, :using => using)
+    end
+
+    expected = "CREATE  INDEX `index_people_on_last_name` USING btree ON `people` (`last_name`(10)) "
+    assert_equal expected, add_index(:people, :last_name, :length => 10, :using => :btree)
+
+    expected = "CREATE  INDEX `index_people_on_last_name` USING btree ON `people` (`last_name`(10)) ALGORITHM = COPY"
+    assert_equal expected, add_index(:people, :last_name, :length => 10, using: :btree, algorithm: :copy)
+
+    assert_raise ArgumentError do
+      add_index(:people, :last_name, algorithm: :coyp)
+    end
+
+    expected = "CREATE  INDEX `index_people_on_last_name_and_first_name` USING btree ON `people` (`last_name`(15), `first_name`(15)) "
+    assert_equal expected, add_index(:people, [:last_name, :first_name], :length => 15, :using => :btree)
+  end
+
+  def test_index_in_create
+    def (ActiveRecord::Base.connection).data_source_exists?(*); false; end
+
+    %w(SPATIAL FULLTEXT UNIQUE).each do |type|
+      expected = "CREATE TABLE `people` (#{type} INDEX `index_people_on_last_name`  (`last_name`)) ENGINE=InnoDB"
+      actual = ActiveRecord::Base.connection.create_table(:people, id: false) do |t|
+        t.index :last_name, type: type
+      end
+      assert_equal expected, actual
+    end
+
+    expected = "CREATE TABLE `people` ( INDEX `index_people_on_last_name` USING btree (`last_name`(10))) ENGINE=InnoDB"
+    actual = ActiveRecord::Base.connection.create_table(:people, id: false) do |t|
+      t.index :last_name, length: 10, using: :btree
+    end
+    assert_equal expected, actual
+  end
+
+  def test_index_in_bulk_change
+    def (ActiveRecord::Base.connection).data_source_exists?(*); true; end
+    def (ActiveRecord::Base.connection).index_name_exists?(*); false; end
+
+    %w(SPATIAL FULLTEXT UNIQUE).each do |type|
+      expected = "ALTER TABLE `people` ADD #{type} INDEX `index_people_on_last_name`  (`last_name`)"
+      actual = ActiveRecord::Base.connection.change_table(:people, bulk: true) do |t|
+        t.index :last_name, type: type
+      end
+      assert_equal expected, actual
+    end
+
+    expected = "ALTER TABLE `peaple` ADD  INDEX `index_peaple_on_last_name` USING btree (`last_name`(10)), ALGORITHM = COPY"
+    actual = ActiveRecord::Base.connection.change_table(:peaple, bulk: true) do |t|
+      t.index :last_name, length: 10, using: :btree, algorithm: :copy
+    end
+    assert_equal expected, actual
+  end
+
+  def test_drop_table
+    assert_equal "DROP TABLE `people`", drop_table(:people)
+  end
+
+  def test_create_mysql_database_with_encoding
+    assert_equal "CREATE DATABASE `matt` DEFAULT CHARACTER SET `utf8`", create_database(:matt)
+    assert_equal "CREATE DATABASE `aimonetti` DEFAULT CHARACTER SET `latin1`", create_database(:aimonetti, {:charset => 'latin1'})
+    assert_equal "CREATE DATABASE `matt_aimonetti` DEFAULT CHARACTER SET `big5` COLLATE `big5_chinese_ci`", create_database(:matt_aimonetti, {:charset => :big5, :collation => :big5_chinese_ci})
+  end
+
+  def test_recreate_mysql_database_with_encoding
+    create_database(:luca, {:charset => 'latin1'})
+    assert_equal "CREATE DATABASE `luca` DEFAULT CHARACTER SET `latin1`", recreate_database(:luca, {:charset => 'latin1'})
+  end
+
+  def test_add_column
+    assert_equal "ALTER TABLE `people` ADD `last_name` varchar(255)", add_column(:people, :last_name, :string)
+  end
+
+  def test_add_column_with_limit
+    assert_equal "ALTER TABLE `people` ADD `key` varchar(32)", add_column(:people, :key, :string, :limit => 32)
+  end
+
+  def test_drop_table_with_specific_database
+    assert_equal "DROP TABLE `otherdb`.`people`", drop_table('otherdb.people')
+  end
+
+  def test_add_timestamps
+    with_real_execute do
+      begin
+        ActiveRecord::Base.connection.create_table :delete_me
+        ActiveRecord::Base.connection.add_timestamps :delete_me, null: true
+        assert column_present?('delete_me', 'updated_at', 'datetime')
+        assert column_present?('delete_me', 'created_at', 'datetime')
+      ensure
+        ActiveRecord::Base.connection.drop_table :delete_me rescue nil
+      end
+    end
+  end
+
+  def test_remove_timestamps
+    with_real_execute do
+      begin
+        ActiveRecord::Base.connection.create_table :delete_me do |t|
+          t.timestamps null: true
+        end
+        ActiveRecord::Base.connection.remove_timestamps :delete_me, { null: true }
+        assert !column_present?('delete_me', 'updated_at', 'datetime')
+        assert !column_present?('delete_me', 'created_at', 'datetime')
+      ensure
+        ActiveRecord::Base.connection.drop_table :delete_me rescue nil
+      end
+    end
+  end
+
+  def test_indexes_in_create
+    ActiveRecord::Base.connection.stubs(:data_source_exists?).with(:temp).returns(false)
+    ActiveRecord::Base.connection.stubs(:index_name_exists?).with(:index_temp_on_zip).returns(false)
+
+    expected = "CREATE TEMPORARY TABLE `temp` ( INDEX `index_temp_on_zip`  (`zip`)) ENGINE=InnoDB AS SELECT id, name, zip FROM a_really_complicated_query"
+    actual = ActiveRecord::Base.connection.create_table(:temp, temporary: true, as: "SELECT id, name, zip FROM a_really_complicated_query") do |t|
+      t.index :zip
+    end
+
+    assert_equal expected, actual
+  end
+
+  private
+    def with_real_execute
+      ActiveRecord::Base.connection.singleton_class.class_eval do
+        alias_method :execute_with_stub, :execute
+        remove_method :execute
+        alias_method :execute, :execute_without_stub
+      end
+
+      yield
+    ensure
+      ActiveRecord::Base.connection.singleton_class.class_eval do
+        remove_method :execute
+        alias_method :execute, :execute_with_stub
+      end
+    end
+
+    def method_missing(method_symbol, *arguments)
+      ActiveRecord::Base.connection.send(method_symbol, *arguments)
+    end
+
+    def column_present?(table_name, column_name, type)
+      results = ActiveRecord::Base.connection.select_all("SHOW FIELDS FROM #{table_name} LIKE '#{column_name}'")
+      results.first && results.first['Type'] == type
+    end
+end