activerecord-jdbcsqlserver-adapter 50.0.0

data/test/cases/connection_test_sqlserver.rb

@@ -0,0 +1,71 @@
+require 'cases/helper_sqlserver'
+require 'models/reply'
+require 'models/topic'
+
+class ConnectionTestSQLServer < ActiveRecord::TestCase
+
+  self.use_transactional_tests = false
+
+  fixtures :topics, :accounts
+
+  before do
+    connection.reconnect!
+    assert connection.active?
+  end
+
+  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 'Connection management' do
+
+    it 'set spid on connect' do
+      ['Fixnum', 'Integer'].must_include connection.spid.class.name
+    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 unless defined? JRUBY_VERSION
+
+    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
+    #end
+  end
+
+end

data/test/cases/execute_procedure_test_sqlserver.rb

@@ -0,0 +1,45 @@
+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
+    skip 'For whatever reason, this stored procedure is only returning 1 result so this test does not work' if defined? JRUBY_VERSION
+    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"
+      quietly { 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
+      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 (*)"
+      quietly { 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
+      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"
+      quietly { 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
+      manager.from(table).where(table[:id].eq(42))
+      expected_sql = "DELETE FROM [my.server].[db].[schema].[table] WHERE [table].[id] = 42"
+      quietly { assert_equal expected_sql, manager.to_sql }
+    end
+
+  end
+
+end

data/test/cases/helper_sqlserver.rb

@@ -0,0 +1,44 @@
+require 'support/paths_sqlserver'
+require 'bundler/setup'
+Bundler.require :default, :development
+require 'pry'
+require 'support/minitest_sqlserver'
+require 'support/test_in_memory_oltp'
+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,
+            ARTest::SQLServer::SqlCounterSqlserver,
+            ActiveSupport::Testing::Stream
+
+    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
+
+  end
+end
+
+Dir["#{ARTest::SQLServer.test_root_sqlserver}/models/**/*.rb"].each { |f| require f }

data/test/cases/index_test_sqlserver.rb

@@ -0,0 +1,47 @@
+require 'cases/helper_sqlserver'
+
+class IndexTestSQLServer < ActiveRecord::TestCase
+
+  before do
+    connection.create_table(:testings) do |t|
+      t.column :foo, :string, limit: 100
+      t.column :bar, :string, limit: 100
+      t.string :first_name
+      t.string :last_name,    limit: 100
+      t.string :key,          limit: 100
+      t.boolean :administrator
+    end
+  end
+
+  after do
+    connection.drop_table :testings rescue nil
+  end
+
+  it 'add index with order' do
+    assert_sql(/CREATE.*INDEX.*\(\[last_name\] DESC\)/i) do
+      connection.add_index 'testings', ['last_name'], order: { last_name: :desc }
+      connection.remove_index 'testings', ['last_name']
+    end
+    assert_sql(/CREATE.*INDEX.*\(\[last_name\] DESC, \[first_name\]\)/i) do
+      connection.add_index 'testings', ['last_name', 'first_name'], order: { last_name: :desc }
+      connection.remove_index 'testings', ['last_name', 'first_name']
+    end
+    assert_sql(/CREATE.*INDEX.*\(\[last_name\] DESC, \[first_name\] ASC\)/i) do
+      connection.add_index 'testings', ['last_name', 'first_name'], order: { last_name: :desc, first_name: :asc }
+      connection.remove_index 'testings', ['last_name', 'first_name']
+    end
+  end
+
+  it 'add index with where' do
+    assert_sql(/CREATE.*INDEX.*\(\[last_name\]\) WHERE \[first_name\] = N'john doe'/i) do
+      connection.add_index 'testings', 'last_name', where: "[first_name] = N'john doe'"
+      connection.remove_index 'testings', 'last_name'
+    end
+  end
+
+  it 'add index with expression' do
+    connection.execute "ALTER TABLE [testings] ADD [first_name_upper] AS UPPER([first_name])"
+    connection.add_index 'testings', 'first_name_upper'
+  end
+
+end

data/test/cases/json_test_sqlserver.rb

@@ -0,0 +1,32 @@
+require 'cases/helper_sqlserver'
+
+if ActiveRecord::Base.connection.supports_json?
+class JsonTestSQLServer < ActiveRecord::TestCase
+
+  before do
+    @o1 = SSTestDatatypeMigrationJson.create! json_col: { 'a' => 'a', 'b' => 'b', 'c' => 'c' }
+    @o2 = SSTestDatatypeMigrationJson.create! json_col: { 'a' => nil, 'b' => 'b', 'c' => 'c' }
+    @o3 = SSTestDatatypeMigrationJson.create! json_col: { 'x' => 1, 'y' => 2, 'z' => 3 }
+    @o4 = SSTestDatatypeMigrationJson.create! json_col: { 'array' => [1, 2, 3] }
+    @o5 = SSTestDatatypeMigrationJson.create! json_col: nil
+  end
+
+  it 'can return and save JSON data' do
+    SSTestDatatypeMigrationJson.find(@o1.id).json_col.must_equal({ 'a' => 'a', 'b' => 'b', 'c' => 'c' })
+    @o1.json_col = { 'a' => 'a' }
+    @o1.json_col.must_equal({ 'a' => 'a' })
+    @o1.save!
+    @o1.reload.json_col.must_equal({ 'a' => 'a' })
+  end
+
+  it 'can use ISJSON function' do
+    SSTestDatatypeMigrationJson.where('ISJSON(json_col) > 0').count.must_equal 4
+    SSTestDatatypeMigrationJson.where('ISJSON(json_col) IS NULL').count.must_equal 1
+  end
+
+  it 'can use JSON_VALUE function' do
+    SSTestDatatypeMigrationJson.where("JSON_VALUE(json_col, '$.b') = 'b'").count.must_equal 2
+  end
+
+end
+end

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