activerecord-sqlserver-adapter_new 4.2.15

data/test/cases/connection_test_sqlserver.rb

@@ -0,0 +1,142 @@
+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 connection_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_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
+
+  end
+
+
+  private
+
+  def disconnect_raw_connection!
+    case 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
+
+end

data/test/cases/execute_procedure_test_sqlserver.rb

@@ -0,0 +1,44 @@
+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
+
+  it 'uses the proper timezone' do
+    date_proc = connection.execute_procedure('my_getutcdate').first['utcdate']
+    date_base = connection.select_value('select GETUTCDATE()')
+    assert_equal date_base.change(usec: 0), date_proc.change(usec: 0)
+  end
+
+end

data/test/cases/fetch_test_sqlserver.rb

@@ -0,0 +1,57 @@
+require 'cases/helper_sqlserver'
+require 'models/book'
+
+class FetchTestSqlserver < ActiveRecord::TestCase
+
+  let(:books) { @books }
+
+  before { create_10_books }
+
+  it 'work with fully qualified table and columns in select' do
+    books = Book.select('books.id, books.name').limit(3).offset(5)
+    assert_equal Book.all[5,3].map(&:id), books.map(&:id)
+  end
+
+  describe 'count' do
+
+    it 'gauntlet' do
+      books[0].destroy
+      books[1].destroy
+      books[2].destroy
+      assert_equal 7, Book.count
+      assert_equal 1, Book.limit(1).offset(1).count
+      assert_equal 1, Book.limit(1).offset(5).count
+      assert_equal 1, Book.limit(1).offset(6).count
+      assert_equal 0, Book.limit(1).offset(7).count
+      assert_equal 3, Book.limit(3).offset(4).count
+      assert_equal 2, Book.limit(3).offset(5).count
+      assert_equal 1, Book.limit(3).offset(6).count
+      assert_equal 0, Book.limit(3).offset(7).count
+      assert_equal 0, Book.limit(3).offset(8).count
+    end
+
+  end
+
+  describe 'order' do
+
+    it 'gauntlet' do
+      Book.where(name:'Name-10').delete_all
+      Book.order(:name).limit(1).offset(1).map(&:name).must_equal ['Name-2']
+      Book.order(:name).limit(2).offset(2).map(&:name).must_equal ['Name-3', 'Name-4']
+      Book.order(:name).limit(2).offset(7).map(&:name).must_equal ['Name-8', 'Name-9']
+      Book.order(:name).limit(3).offset(7).map(&:name).must_equal ['Name-8', 'Name-9']
+      Book.order(:name).limit(3).offset(9).map(&:name).must_equal []
+    end
+
+  end
+
+
+  protected
+
+  def create_10_books
+    Book.delete_all
+    @books = (1..10).map { |i| Book.create! name: "Name-#{i}" }
+  end
+
+end
+

data/test/cases/fully_qualified_identifier_test_sqlserver.rb

@@ -0,0 +1,76 @@
+require 'cases/helper_sqlserver'
+
+class FullyQualifiedIdentifierTestSQLServer < ActiveRecord::TestCase
+
+  describe 'local server' do
+
+    it 'should use table name in select projections' do
+      table = Arel::Table.new(:table)
+      expected_sql = "SELECT [table].[name] FROM [table]"
+      assert_equal expected_sql, table.project(table[:name]).to_sql
+    end
+
+  end
+
+  describe 'remote server' do
+
+    before do
+      connection_options[:database_prefix] = "[my.server].db.schema."
+    end
+
+    after do
+      connection_options.delete :database_prefix
+    end
+
+    it 'should use fully qualified table name in select from clause' do
+      table = Arel::Table.new(:table)
+      expected_sql = "SELECT * FROM [my.server].[db].[schema].[table]"
+      assert_equal expected_sql, table.project(Arel.star).to_sql
+    end
+
+    it 'should not use fully qualified table name in select projections' do
+      table = Arel::Table.new(:table)
+      expected_sql = "SELECT [table].[name] FROM [my.server].[db].[schema].[table]"
+      assert_equal expected_sql, table.project(table[:name]).to_sql
+    end
+
+    it 'should not use fully qualified table name in where clause' do
+      table = Arel::Table.new(:table)
+      expected_sql = "SELECT * FROM [my.server].[db].[schema].[table] WHERE [table].[id] = 42"
+      assert_equal expected_sql, table.project(Arel.star).where(table[:id].eq(42)).to_sql
+    end
+
+    it 'should not use fully qualified table name in order clause' do
+      table = Arel::Table.new(:table)
+      expected_sql = "SELECT * FROM [my.server].[db].[schema].[table]  ORDER BY [table].[name]"
+      assert_equal expected_sql, table.project(Arel.star).order(table[:name]).to_sql
+    end
+
+    it 'should use fully qualified table name in insert statement' do
+      manager = Arel::InsertManager.new(Arel::Table.engine)
+      manager.into Arel::Table.new(:table)
+      manager.values = manager.create_values [Arel.sql('*')], %w{ a }
+      expected_sql = "INSERT INTO [my.server].[db].[schema].[table] VALUES (*)"
+      assert_equal expected_sql, manager.to_sql
+    end
+
+    it 'should use fully qualified table name in update statement' do
+      table = Arel::Table.new(:table)
+      manager = Arel::UpdateManager.new(Arel::Table.engine)
+      manager.table(table).where(table[:id].eq(42))
+      manager.set([[table[:name], "Bob"]])
+      expected_sql = "UPDATE [my.server].[db].[schema].[table] SET [name] = N'Bob' WHERE [table].[id] = 42"
+      assert_equal expected_sql, manager.to_sql
+    end
+
+    it 'should use fully qualified table name in delete statement' do
+      table = Arel::Table.new(:table)
+      manager = Arel::DeleteManager.new(Arel::Table.engine)
+      manager.from(table).where(table[:id].eq(42))
+      expected_sql = "DELETE FROM [my.server].[db].[schema].[table] WHERE [table].[id] = 42"
+      assert_equal expected_sql, manager.to_sql
+    end
+
+  end
+
+end

data/test/cases/helper_sqlserver.rb

@@ -0,0 +1,54 @@
+require 'support/paths_sqlserver'
+require 'bundler/setup'
+Bundler.require :default, :development
+require 'support/minitest_sqlserver'
+require 'cases/helper'
+require 'support/load_schema_sqlserver'
+require 'support/coerceable_test_sqlserver'
+require 'support/sql_counter_sqlserver'
+require 'support/connection_reflection'
+require 'mocha/mini_test'
+
+module ActiveRecord
+  class TestCase < ActiveSupport::TestCase
+
+    SQLServer = ActiveRecord::ConnectionAdapters::SQLServer
+
+    include ARTest::SQLServer::CoerceableTest,
+            ARTest::SQLServer::ConnectionReflection
+
+    let(:logger) { ActiveRecord::Base.logger }
+
+
+    private
+
+    def host_windows?
+      RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+    end
+
+    def with_use_output_inserted_disabled
+      klass = ActiveRecord::ConnectionAdapters::SQLServerAdapter
+      klass.use_output_inserted = false
+      yield
+    ensure
+      klass.use_output_inserted = true
+    end
+
+    def silence_stream(stream)
+      old_stream = stream.dup
+      stream.reopen(RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ ? 'NUL:' : '/dev/null')
+      stream.sync = true
+      yield
+    ensure
+      stream.reopen(old_stream)
+      old_stream.close
+    end
+
+    def quietly
+      silence_stream(STDOUT) { silence_stream(STDERR) { yield } }
+    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,61 @@
+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
+
+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