activerecord-sqlserver-adapter 4.1.8 → 4.2.0.pre

data/test/cases/connection_test_sqlserver.rb

@@ -0,0 +1,216 @@
+require 'cases/helper_sqlserver'
+require 'models/reply'
+require 'models/topic'
+
+class ConnectionTestSQLServer < ActiveRecord::TestCase
+
+  self.use_transactional_fixtures = false
+
+  fixtures :topics, :accounts
+
+  before { assert connection.active? }
+  after  { connection.reconnect! }
+
+  it 'affect rows' do
+    topic_data = { 1 => { "content" => "1 updated" }, 2 => { "content" => "2 updated" } }
+    updated = Topic.update(topic_data.keys, topic_data.values)
+    assert_equal 2, updated.size
+    assert_equal "1 updated", Topic.find(1).content
+    assert_equal "2 updated", Topic.find(2).content
+    assert_equal 2, Topic.delete([1, 2])
+  end
+
+  it 'allow usage of :database connection option to remove setting from dsn' do
+    assert_equal 'activerecord_unittest', connection.current_database
+    begin
+      connection.use_database('activerecord_unittest2')
+      assert_equal 'activerecord_unittest2', connection.current_database
+    ensure
+      connection.use_database
+      assert_equal 'activerecord_unittest', connection.current_database, 'Would default back to connection options'
+    end
+  end unless sqlserver_azure?
+
+  describe 'ODBC connection management' do
+
+    it 'return finished ODBC statement handle from #execute without block' do
+      assert_all_odbc_statements_used_are_closed do
+        connection.execute('SELECT * FROM [topics]')
+      end
+    end
+
+    it 'finish ODBC statement handle from #execute with block' do
+      assert_all_odbc_statements_used_are_closed do
+        connection.execute('SELECT * FROM [topics]') { }
+      end
+    end
+
+    it 'finish connection from #raw_select' do
+      assert_all_odbc_statements_used_are_closed do
+        connection.send(:raw_select,'SELECT * FROM [topics]')
+      end
+    end
+
+    it 'execute without block closes statement' do
+      assert_all_odbc_statements_used_are_closed do
+        connection.execute("SELECT 1")
+      end
+    end
+
+    it 'execute with block closes statement' do
+      assert_all_odbc_statements_used_are_closed do
+        connection.execute("SELECT 1") do |sth|
+          assert !sth.finished?, "Statement should still be alive within block"
+        end
+      end
+    end
+
+    it 'insert with identity closes statement' do
+      assert_all_odbc_statements_used_are_closed do
+        connection.exec_insert "INSERT INTO accounts ([id],[firm_id],[credit_limit]) VALUES (999, 1, 50)", "SQL", []
+      end
+    end
+
+    it 'insert without identity closes statement' do
+      assert_all_odbc_statements_used_are_closed do
+        connection.exec_insert "INSERT INTO accounts ([firm_id],[credit_limit]) VALUES (1, 50)", "SQL", []
+      end
+    end
+
+    it 'active closes statement' do
+      assert_all_odbc_statements_used_are_closed do
+        connection.active?
+      end
+    end
+
+  end if connection_mode_odbc?
+
+
+  describe 'Connection management' do
+
+    it 'set spid on connect' do
+      assert_instance_of Fixnum, connection.spid
+    end
+
+    it 'reset spid on disconnect!' do
+      connection.disconnect!
+      assert connection.spid.nil?
+    end
+
+    it 'reset the connection' do
+      connection.disconnect!
+      connection.raw_connection.must_be_nil
+    end
+
+    it 'be able to disconnect and reconnect at will' do
+      disconnect_raw_connection!
+      assert !connection.active?
+      connection.reconnect!
+      assert connection.active?
+    end
+
+    describe 'with a deadlock victim exception 1205' do
+
+      describe 'outside a transaction' do
+
+        before do
+          @query = "SELECT 1 as [one]"
+          @expected = connection.execute(@query)
+          # Execute the query to get a handle of the expected result, which
+          # will be returned after a simulated deadlock victim (1205).
+          raw_conn = connection.raw_connection
+          stubbed_handle = raw_conn.execute(@query)
+          connection.send(:finish_statement_handle, stubbed_handle)
+          raw_conn.stubs(:execute).raises(deadlock_victim_exception(@query)).then.returns(stubbed_handle)
+        end
+
+        it 'raise ActiveRecord::DeadlockVictim' do
+          assert_raise(ActiveRecord::DeadlockVictim) do
+            assert_equal @expected, connection.execute(@query)
+          end
+        end
+
+      end
+
+      describe 'within a transaction' do
+
+        before do
+          @query = "SELECT 1 as [one]"
+          @expected = connection.execute(@query)
+          # We "stub" the execute method to simulate raising a deadlock victim exception once.
+          connection.class.class_eval do
+            def execute_with_deadlock_exception(sql, *args)
+              if !@raised_deadlock_exception && sql == "SELECT 1 as [one]"
+                sql = "RAISERROR('Transaction (Process ID #{Process.pid}) was deadlocked on lock resources with another process and has been chosen as the deadlock victim. Rerun the transaction.: #{sql}', 13, 1)"
+                @raised_deadlock_exception = true
+              elsif @raised_deadlock_exception == true && sql =~ /RAISERROR\('Transaction \(Process ID \d+\) was deadlocked on lock resources with another process and has been chosen as the deadlock victim\. Rerun the transaction\.: SELECT 1 as \[one\]', 13, 1\)/
+                sql = "SELECT 1 as [one]"
+              end
+              execute_without_deadlock_exception(sql, *args)
+            end
+            alias :execute_without_deadlock_exception :execute
+            alias :execute :execute_with_deadlock_exception
+          end
+        end
+
+        after do
+          # Cleanup the "stubbed" execute method.
+          connection.class.class_eval do
+            alias :execute :execute_without_deadlock_exception
+            remove_method :execute_with_deadlock_exception
+            remove_method :execute_without_deadlock_exception
+          end
+          connection.send(:remove_instance_variable, :@raised_deadlock_exception)
+        end
+
+        it 'raise ActiveRecord::DeadlockVictim if retry disabled' do
+          assert_raise(ActiveRecord::DeadlockVictim) do
+            ActiveRecord::Base.transaction do
+              assert_equal @expected, connection.execute(@query)
+            end
+          end
+        end
+
+      end
+
+    end if connection_mode_dblib? # Since it is easier to test, but feature should work in ODBC too.
+
+  end
+
+
+  private
+
+  def disconnect_raw_connection!
+    case connection.instance_variable_get(:@connection_options)[:mode]
+    when :dblib
+      connection.raw_connection.close rescue nil
+    when :odbc
+      connection.raw_connection.disconnect rescue nil
+    end
+  end
+
+  def assert_all_odbc_statements_used_are_closed(&block)
+    odbc = connection.raw_connection.class.parent
+    existing_handles = []
+    ObjectSpace.each_object(odbc::Statement) { |h| existing_handles << h }
+    existing_handle_ids = existing_handles.map(&:object_id)
+    assert existing_handles.all?(&:finished?), "Somewhere before the block some statements were not closed"
+    GC.disable
+    yield
+    used_handles = []
+    ObjectSpace.each_object(odbc::Statement) { |h| used_handles << h unless existing_handle_ids.include?(h.object_id) }
+    assert used_handles.size > 0, "No statements were used within given block"
+    assert used_handles.all?(&:finished?), "Statement should have been closed within given block"
+  ensure
+    GC.enable
+  end
+
+  def deadlock_victim_exception(sql)
+    require 'tiny_tds/error'
+    error = TinyTds::Error.new("Transaction (Process ID #{Process.pid}) was deadlocked on lock resources with another process and has been chosen as the deadlock victim. Rerun the transaction.: #{sql}")
+    error.severity = 13
+    error.db_error_number = 1205
+    error
+  end
+
+end

data/test/cases/database_statements_test_sqlserver.rb

@@ -0,0 +1,57 @@
+require 'cases/helper_sqlserver'
+
+class DatabaseStatementsTestSQLServer < ActiveRecord::TestCase
+
+  self.use_transactional_fixtures = false
+
+  after { connection.use_database }
+
+  it 'create database' do
+    connection.create_database 'activerecord_unittest3'
+    database_name = connection.select_value "SELECT name FROM master.dbo.sysdatabases WHERE name = 'activerecord_unittest3'"
+    assert_equal 'activerecord_unittest3', database_name
+  end
+
+  it 'drop database' do
+    connection.drop_database 'activerecord_unittest3'
+    database_name = connection.select_value "SELECT name FROM master.dbo.sysdatabases WHERE name = 'activerecord_unittest3'"
+    assert_equal nil, database_name
+  end
+
+  it 'create/use/drop database with name with dots' do
+    connection.drop_database '[activerecord.unittest]' rescue nil
+    connection.create_database '[activerecord.unittest]'
+    database_name = connection.select_value "SELECT name FROM master.dbo.sysdatabases WHERE name = 'activerecord.unittest'"
+    assert_equal 'activerecord.unittest', database_name
+    connection.use_database '[activerecord.unittest]'
+    connection.use_database
+    connection.drop_database '[activerecord.unittest]'
+  end
+
+  describe 'with collation' do
+
+    after { connection.drop_database 'activerecord_unittest3' }
+
+    it 'create database with default collation for the server' do
+      connection.create_database 'activerecord_unittest3'
+      default_collation = connection.select_value "SELECT SERVERPROPERTY('Collation')"
+      database_collation = connection.select_value "SELECT DATABASEPROPERTYEX('activerecord_unittest3', 'Collation') SQLCollation"
+      assert_equal default_collation, database_collation
+    end
+
+    it 'create database with collation set by the method' do
+      connection.create_database 'activerecord_unittest3', collation: 'SQL_Latin1_General_CP1_CI_AS'
+      collation = connection.select_value "SELECT DATABASEPROPERTYEX('activerecord_unittest3', 'Collation') SQLCollation"
+      assert_equal 'SQL_Latin1_General_CP1_CI_AS', collation
+    end
+
+    it 'create database with collation set by the config' do
+      connection.instance_variable_get(:@connection_options)[:collation] = 'SQL_Latin1_General_CP1_CI_AS'
+      connection.create_database 'activerecord_unittest3'
+      collation = connection.select_value "SELECT DATABASEPROPERTYEX('activerecord_unittest3', 'Collation') SQLCollation"
+      assert_equal 'SQL_Latin1_General_CP1_CI_AS', collation
+    end
+
+  end
+
+end

data/test/cases/execute_procedure_test_sqlserver.rb

@@ -0,0 +1,38 @@
+require 'cases/helper_sqlserver'
+
+class ExecuteProcedureTestSQLServer < ActiveRecord::TestCase
+
+  it 'execute a simple procedure' do
+    tables = ActiveRecord::Base.execute_procedure :sp_tables
+    assert_instance_of Array, tables
+    assert tables.first.respond_to?(:keys)
+  end
+
+  it 'take parameter arguments' do
+    tables = ActiveRecord::Base.execute_procedure :sp_tables, 'sst_datatypes'
+    table_info = tables.first
+    assert_equal 1, tables.size
+    assert_equal (ENV['ARUNIT_DB_NAME'] || 'activerecord_unittest'), table_info['TABLE_QUALIFIER'], "Table Info: #{table_info.inspect}"
+    assert_equal 'TABLE', table_info['TABLE_TYPE'], "Table Info: #{table_info.inspect}"
+  end
+
+  it 'allow multiple result sets to be returned' do
+    results1, results2 = ActiveRecord::Base.execute_procedure('sp_helpconstraint','accounts')
+    assert_instance_of Array, results1
+    assert results1.first.respond_to?(:keys)
+    assert results1.first['Object Name']
+    assert_instance_of Array, results2
+    assert results2.first.respond_to?(:keys)
+    assert results2.first['constraint_name']
+    assert results2.first['constraint_type']
+  end
+
+  it 'take named parameter arguments' do
+    tables = ActiveRecord::Base.execute_procedure :sp_tables, table_name: 'tables', table_owner: 'sys'
+    table_info = tables.first
+    assert_equal 1, tables.size
+    assert_equal (ENV['ARUNIT_DB_NAME'] || 'activerecord_unittest'), table_info['TABLE_QUALIFIER'], "Table Info: #{table_info.inspect}"
+    assert_equal 'VIEW', table_info['TABLE_TYPE'], "Table Info: #{table_info.inspect}"
+  end
+
+end

data/test/cases/helper_sqlserver.rb

@@ -0,0 +1,36 @@
+require 'bundler' ; Bundler.require :default, :development, :test
+require 'support/paths_sqlserver'
+require 'support/minitest_sqlserver'
+require 'cases/helper'
+require 'support/load_schema_sqlserver'
+require 'support/coerceable_test_sqlserver'
+require 'support/sql_counter_sqlserver'
+require 'mocha/mini_test'
+
+module ActiveRecord
+  class TestCase < ActiveSupport::TestCase
+
+    SQLServer = ActiveRecord::ConnectionAdapters::SQLServer
+
+    include ARTest::SQLServer::CoerceableTest
+
+    let(:logger) { ActiveRecord::Base.logger }
+    let(:connection) { ActiveRecord::Base.connection }
+
+    class << self
+      def connection_mode_dblib? ; ActiveRecord::Base.connection.instance_variable_get(:@connection_options)[:mode] == :dblib ; end
+      def connection_mode_odbc? ; ActiveRecord::Base.connection.instance_variable_get(:@connection_options)[:mode] == :odbc ; end
+      def sqlserver_azure? ; ActiveRecord::Base.connection.sqlserver_azure? ; end
+    end
+
+
+    private
+
+    def connection_mode_dblib? ; self.class.connection_mode_dblib? ; end
+    def connection_mode_odbc? ; self.class.connection_mode_odbc? ; end
+    def sqlserver_azure? ; self.class.sqlserver_azure? ; end
+
+  end
+end
+
+Dir["#{ARTest::SQLServer.test_root_sqlserver}/models/**/*.rb"].each { |f| require f }

data/test/cases/migration_test_sqlserver.rb

@@ -0,0 +1,66 @@
+require 'cases/helper_sqlserver'
+require 'models/person'
+
+class MigrationTestSQLServer < ActiveRecord::TestCase
+
+  describe 'For transactions' do
+
+    before do
+      @trans_test_table1 = 'sqlserver_trans_table1'
+      @trans_test_table2 = 'sqlserver_trans_table2'
+      @trans_tables = [@trans_test_table1,@trans_test_table2]
+    end
+
+    after do
+      @trans_tables.each do |table_name|
+        ActiveRecord::Migration.drop_table(table_name) if connection.tables.include?(table_name)
+      end
+    end
+
+    it 'not create a tables if error in migrations' do
+      begin
+        migrations_dir = File.join ARTest::SQLServer.migrations_root, 'transaction_table'
+        quietly { ActiveRecord::Migrator.up(migrations_dir) }
+      rescue Exception => e
+        assert_match %r|this and all later migrations canceled|, e.message
+      end
+      connection.tables.wont_include @trans_test_table1
+      connection.tables.wont_include @trans_test_table2
+    end
+
+  end
+
+  describe 'For changing column' do
+
+    it 'not raise exception when column contains default constraint' do
+      lock_version_column = Person.columns_hash['lock_version']
+      assert_equal :integer, lock_version_column.type
+      assert lock_version_column.default.present?
+      assert_nothing_raised { connection.change_column 'people', 'lock_version', :string }
+      Person.reset_column_information
+      lock_version_column = Person.columns_hash['lock_version']
+      assert_equal :string, lock_version_column.type
+      assert lock_version_column.default.nil?
+    end
+
+    it 'not drop the default contraint if just renaming' do
+      find_default = lambda do
+        connection.execute_procedure(:sp_helpconstraint, 'sst_string_defaults', 'nomsg').select do |row|
+          row['constraint_type'] == "DEFAULT on column string_with_pretend_paren_three"
+        end.last
+      end
+      default_before = find_default.call
+      connection.change_column :sst_string_defaults, :string_with_pretend_paren_three, :string, limit: 255
+      default_after = find_default.call
+      assert default_after
+      assert_equal default_before['constraint_keys'], default_after['constraint_keys']
+    end
+
+  end
+
+
+  def quietly
+    silence_stream(STDOUT) { silence_stream(STDERR) { yield } }
+  end
+
+end

data/test/cases/order_test_sqlserver.rb

@@ -0,0 +1,147 @@
+require 'cases/helper_sqlserver'
+require 'models/post'
+
+class OrderTestSQLServer < ActiveRecord::TestCase
+
+  fixtures :posts
+
+  it 'not mangel complex order clauses' do
+    xyz_order = "CASE WHEN [title] LIKE N'XYZ%' THEN 0 ELSE 1 END"
+    xyz_post = Post.create title: 'XYZ Post', body: 'Test cased orders.'
+    assert_equal xyz_post, Post.order(Arel.sql(xyz_order)).first
+  end
+
+  it 'support column' do
+    order = "title"
+    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    assert_equal post1, Post.order(order).first
+  end
+
+  it 'support column ASC' do
+    order = "title ASC"
+    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    assert_equal post1, Post.order(order).first
+  end
+
+  it 'support column DESC' do
+    order = "title DESC"
+    post1 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
+    assert_equal post1, Post.order(order).first
+  end
+
+  it 'support column as symbol' do
+    order = :title
+    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    assert_equal post1, Post.order(order).first
+  end
+
+  it 'support table and column' do
+    order = "posts.title"
+    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    assert_equal post1, Post.order(order).first
+  end
+
+  it 'support quoted column' do
+    order = "[title]"
+    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    assert_equal post1, Post.order(order).first
+  end
+
+  it 'support quoted table and column' do
+    order = "[posts].[title]"
+    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    assert_equal post1, Post.order(order).first
+  end
+
+  it 'support primary: column, secondary: column' do
+    order = "title DESC, body"
+    post1 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
+    post2 = Post.create title: 'ZZZ Post', body: 'ZZZ Test cased orders.'
+    assert_equal post1, Post.order(order).first
+    assert_equal post2, Post.order(order).second
+  end
+
+  it 'support primary: table and column, secondary: column' do
+    order = "posts.title DESC, body"
+    post1 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
+    post2 = Post.create title: 'ZZZ Post', body: 'ZZZ Test cased orders.'
+    assert_equal post1, Post.order(order).first
+    assert_equal post2, Post.order(order).second
+  end
+
+  it 'support primary: case expression, secondary: column' do
+    order = "(CASE WHEN [title] LIKE N'ZZZ%' THEN title ELSE '' END) DESC, body"
+    post1 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
+    post2 = Post.create title: 'ZZZ Post', body: 'ZZZ Test cased orders.'
+    assert_equal post1, Post.order(order).first
+    assert_equal post2, Post.order(order).second
+  end
+
+  it 'support primary: quoted table and column, secondary: case expresion' do
+    order = "[posts].[body] DESC, (CASE WHEN [title] LIKE N'ZZZ%' THEN title ELSE '' END) DESC"
+    post1 = Post.create title: 'ZZZ Post', body: 'ZZZ Test cased orders.'
+    post2 = Post.create title: 'ZZY Post', body: 'ZZZ Test cased orders.'
+    assert_equal post1, Post.order(order).first
+    assert_equal post2, Post.order(order).second
+  end
+
+  it 'support inline function' do
+    order = "LEN(title)"
+    post1 = Post.create title: 'A', body: 'AAA Test cased orders.'
+    assert_equal post1, Post.order(order).first
+  end
+
+  it 'support inline function with parameters' do
+    order = "SUBSTRING(title, 1, 3)"
+    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    assert_equal post1, Post.order(order).first
+  end
+
+  it 'support inline function with parameters DESC' do
+    order = "SUBSTRING(title, 1, 3) DESC"
+    post1 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
+    assert_equal post1, Post.order(order).first
+  end
+
+  it 'support primary: inline function, secondary: column' do
+    order = "LEN(title), body"
+    post1 = Post.create title: 'A', body: 'AAA Test cased orders.'
+    post2 = Post.create title: 'A', body: 'Test cased orders.'
+    assert_equal post1, Post.order(order).first
+    assert_equal post2, Post.order(order).second
+  end
+
+  it 'support primary: inline function, secondary: column with direction' do
+    order = "LEN(title) ASC, body DESC"
+    post1 = Post.create title: 'A', body: 'ZZZ Test cased orders.'
+    post2 = Post.create title: 'A', body: 'Test cased orders.'
+    assert_equal post1, Post.order(order).first
+    assert_equal post2, Post.order(order).second
+  end
+
+  it 'support primary: column, secondary: inline function' do
+    order = "body DESC, LEN(title)"
+    post1 = Post.create title: 'Post', body: 'ZZZ Test cased orders.'
+    post2 = Post.create title: 'Longer Post', body: 'ZZZ Test cased orders.'
+    assert_equal post1, Post.order(order).first
+    assert_equal post2, Post.order(order).second
+  end
+
+  it 'support primary: case expression, secondary: inline function' do
+    order = "CASE WHEN [title] LIKE N'ZZZ%' THEN title ELSE '' END DESC, LEN(body) ASC"
+    post1 = Post.create title: 'ZZZ Post', body: 'Z'
+    post2 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
+    assert_equal post1, Post.order(order).first
+    assert_equal post2, Post.order(order).second
+  end
+
+  it 'support primary: inline function, secondary: case expression' do
+    order = "LEN(body), CASE WHEN [title] LIKE N'ZZZ%' THEN title ELSE '' END DESC"
+    post1 = Post.create title: 'ZZZ Post', body: 'Z'
+    post2 = Post.create title: 'Post', body: 'Z'
+    assert_equal post1, Post.order(order).first
+    assert_equal post2, Post.order(order).second
+  end
+
+
+end